feat(android): oboe/AAudio audio backend + runtime mic permission (step 3)

This is the big one — the Tauri Android app now has a real audio stack
capable of full-duplex VoIP, reusing the proven C++ Oboe bridge from the
legacy wzp-android crate.

Architecture:
- desktop/src-tauri/cpp/  — copies of oboe_bridge.{h,cpp}, oboe_stub.cpp,
  and getauxval_fix.c from crates/wzp-android/cpp/. build.rs clones
  google/oboe@1.8.1 into OUT_DIR and compiles the bridge + all Oboe
  sources as "oboe_bridge" static lib, linking against shared libc++
  (static would pull broken libc stubs that SIGSEGV in .so libraries).
- src/oboe_audio.rs  — Rust side: an SPSC ring buffer matching the C++
  bridge's AtomicI32 layout, plus OboeHandle::start() which returns
  (capture_ring, playout_ring, owning_handle). The ring exposes the same
  (available / read / write) methods as wzp_client::audio_ring::AudioRing
  so CallEngine treats both backends interchangeably.
- src/engine.rs  — compiled on every platform now. A cfg-switched type
  alias picks wzp_client::audio_ring::AudioRing on desktop and
  crate::oboe_audio::AudioRing on Android. The audio setup block has
  three branches: VPIO/CPAL on macOS, CPAL on Linux/Windows, Oboe on
  Android. Send/recv tasks are identical across platforms.
- src/lib.rs  — removes all the "step 3 not done" Android stubs. The
  engine module is no longer cfg-gated; connect / disconnect / toggle_mic
  / toggle_speaker / get_status are single implementations used by both
  desktop and Android. Identity path resolves via app.path().app_data_dir()
  from the Tauri setup() callback (already wired in step 1).

Runtime mic permission:
- scripts/build-tauri-android.sh now injects RECORD_AUDIO + MODIFY_AUDIO_
  SETTINGS into gen/android/app/src/main/AndroidManifest.xml after init,
  and overwrites MainActivity.kt with a version that calls
  ActivityCompat.requestPermissions in onCreate. This is idempotent:
  every build re-applies the patches so tauri re-init can't regress them.

Cargo.toml:
- cc is now an unconditional build-dep (build.rs runs on the host, so
  target-gating build-deps doesn't work).
- wzp-client is now a dep on every platform. On Android it gets default
  features only (no "audio"/"vpio") so CPAL isn't dragged in — oboe_audio
  provides the capture/playout rings instead.
- tracing-android is added on Android so tracing events flow into logcat.

build.rs also gained embedded git hash (WZP_GIT_HASH) capture, which is
shown under the fingerprint on the home screen — already committed in
7639aaf, reinstated here alongside the Oboe build logic.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

desktop/src-tauri/Cargo.toml

@@ -17,6 +17,10 @@ path = "src/main.rs"
 
 [build-dependencies]
 tauri-build = { version = "2", features = [] }
+# cc is always available because build.rs runs on the HOST, not the TARGET.
+# We gate the actual cc::Build::new() calls on `target.contains("android")` at
+# build-script runtime.
+cc = "1"
 
 [dependencies]
 tauri = { version = "2", features = [] }
@@ -36,11 +40,17 @@ wzp-fec = { path = "../../crates/wzp-fec" }
 wzp-crypto = { path = "../../crates/wzp-crypto" }
 wzp-transport = { path = "../../crates/wzp-transport" }
 
-# wzp-client pulls CPAL + (on macOS) VoiceProcessingIO — desktop only.
-# Android gets an oboe/AAudio backend in Step 3 of the Tauri mobile rewrite.
+# wzp-client on desktop: full audio stack (CPAL + macOS VoiceProcessingIO)
 [target.'cfg(not(target_os = "android"))'.dependencies]
 wzp-client = { path = "../../crates/wzp-client", features = ["audio", "vpio"] }
 
+# wzp-client on Android: only the codec/handshake/call modules. Audio I/O is
+# handled by our own oboe_audio module (C++ Oboe bridge).
+[target.'cfg(target_os = "android")'.dependencies]
+wzp-client = { path = "../../crates/wzp-client", default-features = false }
+# On-device logcat bridge for the tracing crate — useful for native debugging.
+tracing-android = "0.2"
+
 # Platform-specific
 [target.'cfg(target_os = "macos")'.dependencies]
 coreaudio-rs = "0.11"

desktop/src-tauri/build.rs

@@ -1,9 +1,8 @@
+use std::path::PathBuf;
 use std::process::Command;
 
 fn main() {
-    // Capture short git hash so the running app can prove which build it is.
-    // Falls back to "unknown" if git isn't available (e.g. when building from
-    // a tarball without a .git dir).
+    // ─── Embedded git hash ─────────────────────────────────────────────────
     let git_hash = Command::new("git")
         .args(["rev-parse", "--short", "HEAD"])
         .output()
@@ -14,10 +13,138 @@ fn main() {
         .unwrap_or_else(|| "unknown".into());
 
     println!("cargo:rustc-env=WZP_GIT_HASH={git_hash}");
-    // Re-run if the HEAD pointer or its target moves so the embedded hash
-    // tracks reality between builds.
     println!("cargo:rerun-if-changed=../../.git/HEAD");
     println!("cargo:rerun-if-changed=../../.git/refs/heads");
 
+    // ─── Oboe C++ bridge (Android only) ────────────────────────────────────
+    let target = std::env::var("TARGET").unwrap_or_default();
+    if target.contains("android") {
+        build_oboe_android(&target);
+    }
+
     tauri_build::build()
 }
+
+fn build_oboe_android(target: &str) {
+    // Rerun if bridge sources change
+    println!("cargo:rerun-if-changed=cpp/oboe_bridge.cpp");
+    println!("cargo:rerun-if-changed=cpp/oboe_bridge.h");
+    println!("cargo:rerun-if-changed=cpp/oboe_stub.cpp");
+    println!("cargo:rerun-if-changed=cpp/getauxval_fix.c");
+
+    // getauxval_fix: override broken static getauxval from compiler-rt that
+    // SIGSEGVs in shared libraries (runs before any app code).
+    cc::Build::new()
+        .file("cpp/getauxval_fix.c")
+        .compile("getauxval_fix");
+
+    let oboe_dir = fetch_oboe();
+    match oboe_dir {
+        Some(oboe_path) => {
+            println!("cargo:warning=Building with Oboe from {:?}", oboe_path);
+
+            let mut build = cc::Build::new();
+            build
+                .cpp(true)
+                .std("c++17")
+                // Shared libc++ — static pulls broken libc stubs that crash
+                // in shared libraries (getauxval, __init_tcb, pthread_create).
+                .cpp_link_stdlib(Some("c++_shared"))
+                .include("cpp")
+                .include(oboe_path.join("include"))
+                .include(oboe_path.join("src"))
+                .define("WZP_HAS_OBOE", None)
+                .file("cpp/oboe_bridge.cpp");
+
+            add_cpp_files_recursive(&mut build, &oboe_path.join("src"));
+            build.compile("oboe_bridge");
+        }
+        None => {
+            println!("cargo:warning=Oboe not found, building with stub");
+            cc::Build::new()
+                .cpp(true)
+                .std("c++17")
+                .cpp_link_stdlib(Some("c++_shared"))
+                .file("cpp/oboe_stub.cpp")
+                .include("cpp")
+                .compile("oboe_bridge");
+        }
+    }
+
+    // libc++_shared.so must sit next to libwzp_desktop_lib.so in jniLibs —
+    // copy it there from the NDK sysroot. Tauri's gradle project expects the
+    // jniLibs in gen/android/app/src/main/jniLibs/<abi>/.
+    if let Ok(ndk) = std::env::var("ANDROID_NDK_HOME")
+        .or_else(|_| std::env::var("NDK_HOME"))
+    {
+        let (triple, abi) = match target {
+            t if t.contains("aarch64") => ("aarch64-linux-android", "arm64-v8a"),
+            t if t.contains("armv7")   => ("arm-linux-androideabi", "armeabi-v7a"),
+            t if t.contains("x86_64")  => ("x86_64-linux-android", "x86_64"),
+            t if t.contains("i686")    => ("i686-linux-android", "x86"),
+            _                           => ("aarch64-linux-android", "arm64-v8a"),
+        };
+        let lib_dir = format!(
+            "{ndk}/toolchains/llvm/prebuilt/linux-x86_64/sysroot/usr/lib/{triple}"
+        );
+        println!("cargo:rustc-link-search=native={lib_dir}");
+
+        let shared_so = format!("{lib_dir}/libc++_shared.so");
+        if std::path::Path::new(&shared_so).exists() {
+            let manifest = std::env::var("CARGO_MANIFEST_DIR").unwrap_or_default();
+            // Tauri mobile layout: gen/android/app/src/main/jniLibs/<abi>/
+            let jni_dir = format!("{manifest}/gen/android/app/src/main/jniLibs/{abi}");
+            if std::fs::create_dir_all(&jni_dir).is_ok() {
+                let _ = std::fs::copy(&shared_so, format!("{jni_dir}/libc++_shared.so"));
+                println!("cargo:warning=Copied libc++_shared.so to {jni_dir}");
+            }
+        }
+    }
+
+    // Oboe requires Android log + OpenSLES backends
+    println!("cargo:rustc-link-lib=log");
+    println!("cargo:rustc-link-lib=OpenSLES");
+}
+
+/// Recursively add all .cpp files from a directory to a cc::Build.
+fn add_cpp_files_recursive(build: &mut cc::Build, dir: &std::path::Path) {
+    if !dir.is_dir() {
+        return;
+    }
+    for entry in std::fs::read_dir(dir).unwrap() {
+        let entry = entry.unwrap();
+        let path = entry.path();
+        if path.is_dir() {
+            add_cpp_files_recursive(build, &path);
+        } else if path.extension().map_or(false, |e| e == "cpp") {
+            build.file(&path);
+        }
+    }
+}
+
+/// Try to find or fetch Oboe headers + source (v1.8.1).
+fn fetch_oboe() -> Option<PathBuf> {
+    let out_dir = PathBuf::from(std::env::var("OUT_DIR").unwrap());
+    let oboe_dir = out_dir.join("oboe");
+
+    if oboe_dir.join("include").join("oboe").join("Oboe.h").exists() {
+        return Some(oboe_dir);
+    }
+
+    let status = Command::new("git")
+        .args([
+            "clone",
+            "--depth=1",
+            "--branch=1.8.1",
+            "https://github.com/google/oboe.git",
+            oboe_dir.to_str().unwrap(),
+        ])
+        .status();
+
+    match status {
+        Ok(s) if s.success() && oboe_dir.join("include").join("oboe").join("Oboe.h").exists() => {
+            Some(oboe_dir)
+        }
+        _ => None,
+    }
+}

desktop/src-tauri/cpp/getauxval_fix.c

@@ -0,0 +1,21 @@
+// Override the broken static getauxval from compiler-rt/CRT.
+// The static version reads from __libc_auxv which is NULL in shared libs
+// loaded via dlopen, causing SIGSEGV in init_have_lse_atomics at load time.
+// This version calls the real bionic getauxval via dlsym.
+#ifdef __ANDROID__
+#include <dlfcn.h>
+#include <stdint.h>
+
+typedef unsigned long (*getauxval_fn)(unsigned long);
+
+unsigned long getauxval(unsigned long type) {
+    static getauxval_fn real_getauxval = (getauxval_fn)0;
+    if (!real_getauxval) {
+        real_getauxval = (getauxval_fn)dlsym((void*)-1L /* RTLD_DEFAULT */, "getauxval");
+        if (!real_getauxval) {
+            return 0;
+        }
+    }
+    return real_getauxval(type);
+}
+#endif

desktop/src-tauri/cpp/oboe_bridge.cpp

@@ -0,0 +1,278 @@
+// Full Oboe implementation for Android
+// This file is compiled only when targeting Android
+
+#include "oboe_bridge.h"
+
+#ifdef __ANDROID__
+#include <oboe/Oboe.h>
+#include <android/log.h>
+#include <cstring>
+#include <atomic>
+
+#define LOG_TAG "wzp-oboe"
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define LOGW(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+// ---------------------------------------------------------------------------
+// Ring buffer helpers (SPSC, lock-free)
+// ---------------------------------------------------------------------------
+
+static inline int32_t ring_available_read(const wzp_atomic_int* write_idx,
+                                           const wzp_atomic_int* read_idx,
+                                           int32_t capacity) {
+    int32_t w = std::atomic_load_explicit(write_idx, std::memory_order_acquire);
+    int32_t r = std::atomic_load_explicit(read_idx, std::memory_order_relaxed);
+    int32_t avail = w - r;
+    if (avail < 0) avail += capacity;
+    return avail;
+}
+
+static inline int32_t ring_available_write(const wzp_atomic_int* write_idx,
+                                            const wzp_atomic_int* read_idx,
+                                            int32_t capacity) {
+    return capacity - 1 - ring_available_read(write_idx, read_idx, capacity);
+}
+
+static inline void ring_write(int16_t* buf, int32_t capacity,
+                               wzp_atomic_int* write_idx, const wzp_atomic_int* read_idx,
+                               const int16_t* src, int32_t count) {
+    int32_t w = std::atomic_load_explicit(write_idx, std::memory_order_relaxed);
+    for (int32_t i = 0; i < count; i++) {
+        buf[w] = src[i];
+        w++;
+        if (w >= capacity) w = 0;
+    }
+    std::atomic_store_explicit(write_idx, w, std::memory_order_release);
+}
+
+static inline void ring_read(int16_t* buf, int32_t capacity,
+                              const wzp_atomic_int* write_idx, wzp_atomic_int* read_idx,
+                              int16_t* dst, int32_t count) {
+    int32_t r = std::atomic_load_explicit(read_idx, std::memory_order_relaxed);
+    for (int32_t i = 0; i < count; i++) {
+        dst[i] = buf[r];
+        r++;
+        if (r >= capacity) r = 0;
+    }
+    std::atomic_store_explicit(read_idx, r, std::memory_order_release);
+}
+
+// ---------------------------------------------------------------------------
+// Global state
+// ---------------------------------------------------------------------------
+
+static std::shared_ptr<oboe::AudioStream> g_capture_stream;
+static std::shared_ptr<oboe::AudioStream> g_playout_stream;
+static const WzpOboeRings* g_rings = nullptr;
+static std::atomic<bool> g_running{false};
+static std::atomic<float> g_capture_latency_ms{0.0f};
+static std::atomic<float> g_playout_latency_ms{0.0f};
+
+// ---------------------------------------------------------------------------
+// Capture callback
+// ---------------------------------------------------------------------------
+
+class CaptureCallback : public oboe::AudioStreamDataCallback {
+public:
+    oboe::DataCallbackResult onAudioReady(
+            oboe::AudioStream* stream,
+            void* audioData,
+            int32_t numFrames) override {
+        if (!g_running.load(std::memory_order_relaxed) || !g_rings) {
+            return oboe::DataCallbackResult::Stop;
+        }
+
+        const int16_t* src = static_cast<const int16_t*>(audioData);
+        int32_t avail = ring_available_write(g_rings->capture_write_idx,
+                                              g_rings->capture_read_idx,
+                                              g_rings->capture_capacity);
+        int32_t to_write = (numFrames < avail) ? numFrames : avail;
+        if (to_write > 0) {
+            ring_write(g_rings->capture_buf, g_rings->capture_capacity,
+                       g_rings->capture_write_idx, g_rings->capture_read_idx,
+                       src, to_write);
+        }
+
+        // Update latency estimate
+        auto result = stream->calculateLatencyMillis();
+        if (result) {
+            g_capture_latency_ms.store(static_cast<float>(result.value()),
+                                        std::memory_order_relaxed);
+        }
+
+        return oboe::DataCallbackResult::Continue;
+    }
+};
+
+// ---------------------------------------------------------------------------
+// Playout callback
+// ---------------------------------------------------------------------------
+
+class PlayoutCallback : public oboe::AudioStreamDataCallback {
+public:
+    oboe::DataCallbackResult onAudioReady(
+            oboe::AudioStream* stream,
+            void* audioData,
+            int32_t numFrames) override {
+        if (!g_running.load(std::memory_order_relaxed) || !g_rings) {
+            memset(audioData, 0, numFrames * sizeof(int16_t));
+            return oboe::DataCallbackResult::Stop;
+        }
+
+        int16_t* dst = static_cast<int16_t*>(audioData);
+        int32_t avail = ring_available_read(g_rings->playout_write_idx,
+                                             g_rings->playout_read_idx,
+                                             g_rings->playout_capacity);
+        int32_t to_read = (numFrames < avail) ? numFrames : avail;
+
+        if (to_read > 0) {
+            ring_read(g_rings->playout_buf, g_rings->playout_capacity,
+                      g_rings->playout_write_idx, g_rings->playout_read_idx,
+                      dst, to_read);
+        }
+        // Fill remainder with silence on underrun
+        if (to_read < numFrames) {
+            memset(dst + to_read, 0, (numFrames - to_read) * sizeof(int16_t));
+        }
+
+        // Update latency estimate
+        auto result = stream->calculateLatencyMillis();
+        if (result) {
+            g_playout_latency_ms.store(static_cast<float>(result.value()),
+                                        std::memory_order_relaxed);
+        }
+
+        return oboe::DataCallbackResult::Continue;
+    }
+};
+
+static CaptureCallback g_capture_cb;
+static PlayoutCallback g_playout_cb;
+
+// ---------------------------------------------------------------------------
+// Public C API
+// ---------------------------------------------------------------------------
+
+int wzp_oboe_start(const WzpOboeConfig* config, const WzpOboeRings* rings) {
+    if (g_running.load(std::memory_order_relaxed)) {
+        LOGW("wzp_oboe_start: already running");
+        return -1;
+    }
+
+    g_rings = rings;
+
+    // Build capture stream
+    oboe::AudioStreamBuilder captureBuilder;
+    captureBuilder.setDirection(oboe::Direction::Input)
+        ->setPerformanceMode(oboe::PerformanceMode::LowLatency)
+        ->setSharingMode(oboe::SharingMode::Exclusive)
+        ->setFormat(oboe::AudioFormat::I16)
+        ->setChannelCount(config->channel_count)
+        ->setSampleRate(config->sample_rate)
+        ->setFramesPerDataCallback(config->frames_per_burst)
+        ->setInputPreset(oboe::InputPreset::VoiceCommunication)
+        ->setDataCallback(&g_capture_cb);
+
+    oboe::Result result = captureBuilder.openStream(g_capture_stream);
+    if (result != oboe::Result::OK) {
+        LOGE("Failed to open capture stream: %s", oboe::convertToText(result));
+        return -2;
+    }
+
+    // Build playout stream
+    oboe::AudioStreamBuilder playoutBuilder;
+    playoutBuilder.setDirection(oboe::Direction::Output)
+        ->setPerformanceMode(oboe::PerformanceMode::LowLatency)
+        ->setSharingMode(oboe::SharingMode::Exclusive)
+        ->setFormat(oboe::AudioFormat::I16)
+        ->setChannelCount(config->channel_count)
+        ->setSampleRate(config->sample_rate)
+        ->setFramesPerDataCallback(config->frames_per_burst)
+        ->setUsage(oboe::Usage::VoiceCommunication)
+        ->setDataCallback(&g_playout_cb);
+
+    result = playoutBuilder.openStream(g_playout_stream);
+    if (result != oboe::Result::OK) {
+        LOGE("Failed to open playout stream: %s", oboe::convertToText(result));
+        g_capture_stream->close();
+        g_capture_stream.reset();
+        return -3;
+    }
+
+    g_running.store(true, std::memory_order_release);
+
+    // Start both streams
+    result = g_capture_stream->requestStart();
+    if (result != oboe::Result::OK) {
+        LOGE("Failed to start capture: %s", oboe::convertToText(result));
+        g_running.store(false, std::memory_order_release);
+        g_capture_stream->close();
+        g_playout_stream->close();
+        g_capture_stream.reset();
+        g_playout_stream.reset();
+        return -4;
+    }
+
+    result = g_playout_stream->requestStart();
+    if (result != oboe::Result::OK) {
+        LOGE("Failed to start playout: %s", oboe::convertToText(result));
+        g_running.store(false, std::memory_order_release);
+        g_capture_stream->requestStop();
+        g_capture_stream->close();
+        g_playout_stream->close();
+        g_capture_stream.reset();
+        g_playout_stream.reset();
+        return -5;
+    }
+
+    LOGI("Oboe started: sr=%d burst=%d ch=%d",
+         config->sample_rate, config->frames_per_burst, config->channel_count);
+    return 0;
+}
+
+void wzp_oboe_stop(void) {
+    g_running.store(false, std::memory_order_release);
+
+    if (g_capture_stream) {
+        g_capture_stream->requestStop();
+        g_capture_stream->close();
+        g_capture_stream.reset();
+    }
+    if (g_playout_stream) {
+        g_playout_stream->requestStop();
+        g_playout_stream->close();
+        g_playout_stream.reset();
+    }
+
+    g_rings = nullptr;
+    LOGI("Oboe stopped");
+}
+
+float wzp_oboe_capture_latency_ms(void) {
+    return g_capture_latency_ms.load(std::memory_order_relaxed);
+}
+
+float wzp_oboe_playout_latency_ms(void) {
+    return g_playout_latency_ms.load(std::memory_order_relaxed);
+}
+
+int wzp_oboe_is_running(void) {
+    return g_running.load(std::memory_order_relaxed) ? 1 : 0;
+}
+
+#else
+// Non-Android fallback — should not be reached; oboe_stub.cpp is used instead.
+// Provide empty implementations just in case.
+
+int wzp_oboe_start(const WzpOboeConfig* config, const WzpOboeRings* rings) {
+    (void)config; (void)rings;
+    return -99;
+}
+
+void wzp_oboe_stop(void) {}
+float wzp_oboe_capture_latency_ms(void) { return 0.0f; }
+float wzp_oboe_playout_latency_ms(void) { return 0.0f; }
+int wzp_oboe_is_running(void) { return 0; }
+
+#endif // __ANDROID__

desktop/src-tauri/cpp/oboe_bridge.h

@@ -0,0 +1,43 @@
+#ifndef WZP_OBOE_BRIDGE_H
+#define WZP_OBOE_BRIDGE_H
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+#include <atomic>
+typedef std::atomic<int32_t> wzp_atomic_int;
+extern "C" {
+#else
+#include <stdatomic.h>
+typedef atomic_int wzp_atomic_int;
+#endif
+
+typedef struct {
+    int32_t sample_rate;
+    int32_t frames_per_burst;
+    int32_t channel_count;
+} WzpOboeConfig;
+
+typedef struct {
+    int16_t* capture_buf;
+    int32_t  capture_capacity;
+    wzp_atomic_int* capture_write_idx;
+    wzp_atomic_int* capture_read_idx;
+
+    int16_t* playout_buf;
+    int32_t  playout_capacity;
+    wzp_atomic_int* playout_write_idx;
+    wzp_atomic_int* playout_read_idx;
+} WzpOboeRings;
+
+int wzp_oboe_start(const WzpOboeConfig* config, const WzpOboeRings* rings);
+void wzp_oboe_stop(void);
+float wzp_oboe_capture_latency_ms(void);
+float wzp_oboe_playout_latency_ms(void);
+int wzp_oboe_is_running(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // WZP_OBOE_BRIDGE_H

desktop/src-tauri/cpp/oboe_stub.cpp

@@ -0,0 +1,27 @@
+// Stub implementation for non-Android host builds (testing, cargo check, etc.)
+
+#include "oboe_bridge.h"
+#include <stdio.h>
+
+int wzp_oboe_start(const WzpOboeConfig* config, const WzpOboeRings* rings) {
+    (void)config;
+    (void)rings;
+    fprintf(stderr, "wzp_oboe_start: stub (not on Android)\n");
+    return 0;
+}
+
+void wzp_oboe_stop(void) {
+    fprintf(stderr, "wzp_oboe_stop: stub (not on Android)\n");
+}
+
+float wzp_oboe_capture_latency_ms(void) {
+    return 0.0f;
+}
+
+float wzp_oboe_playout_latency_ms(void) {
+    return 0.0f;
+}
+
+int wzp_oboe_is_running(void) {
+    return 0;
+}

desktop/src-tauri/src/engine.rs

@@ -1,5 +1,11 @@
-//! Call engine for the desktop app — wraps wzp-client audio + transport
-//! into a clean async interface for Tauri commands.
+//! Call engine for the Tauri app — desktop and Android share this exact file.
+//!
+//! Desktop (macOS/Linux/Windows) uses `wzp_client::audio_io::{AudioCapture,
+//! AudioPlayback}` on top of CPAL (and VoiceProcessingIO on macOS for OS-level
+//! AEC). Android uses `crate::oboe_audio::OboeHandle` which wraps the C++ Oboe
+//! bridge on high-priority AAudio callback threads. Both expose the same
+//! `Arc<AudioRing>` shape (`available()` / `read()` / `write()`) so the
+//! send/recv tasks below are identical across platforms.
 
 use std::net::SocketAddr;
 use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering};
@@ -9,10 +15,20 @@ use std::time::Instant;
 use tokio::sync::Mutex;
 use tracing::{error, info};
 
-use wzp_client::audio_io::{AudioCapture, AudioPlayback};
 use wzp_client::call::{CallConfig, CallEncoder};
 use wzp_proto::{CodecId, MediaTransport, QualityProfile};
 
+// Ring buffer type used by the send/recv tasks. Different concrete type on
+// each platform but both provide the same method surface: `available()`,
+// `read(&mut [i16]) -> usize`, `write(&[i16]) -> usize`.
+#[cfg(not(target_os = "android"))]
+use wzp_client::audio_ring::AudioRing;
+#[cfg(not(target_os = "android"))]
+use wzp_client::audio_io::{AudioCapture, AudioPlayback};
+
+#[cfg(target_os = "android")]
+use crate::oboe_audio::{AudioRing, OboeHandle};
+
 const FRAME_SAMPLES_40MS: usize = 1920;
 
 /// Resolve a quality string from the UI to a QualityProfile.
@@ -95,32 +111,11 @@ impl CallEngine {
 
         let relay_addr: SocketAddr = relay.parse()?;
 
-        // Load or generate identity
-        let seed = {
-            let path = {
-                let home = std::env::var("HOME").unwrap_or_else(|_| ".".into());
-                std::path::PathBuf::from(home).join(".wzp").join("identity")
-            };
-            if path.exists() {
-                if let Ok(hex) = std::fs::read_to_string(&path) {
-                    if let Ok(s) = wzp_crypto::Seed::from_hex(hex.trim()) {
-                        s
-                    } else {
-                        wzp_crypto::Seed::generate()
-                    }
-                } else {
-                    wzp_crypto::Seed::generate()
-                }
-            } else {
-                let s = wzp_crypto::Seed::generate();
-                if let Some(p) = path.parent() {
-                    std::fs::create_dir_all(p).ok();
-                }
-                let hex: String = s.0.iter().map(|b| format!("{b:02x}")).collect();
-                std::fs::write(&path, hex).ok();
-                s
-            }
-        };
+        // Load or generate identity. Uses the same helper as the signaling
+        // commands so the desktop and the Android app both read from the
+        // platform-correct data dir (resolved via Tauri's path().app_data_dir()).
+        let seed = crate::load_or_create_seed()
+            .map_err(|e| anyhow::anyhow!("identity: {e}"))?;
 
         let fp = seed.derive_identity().public_identity().fingerprint;
         let fingerprint = fp.to_string();
@@ -144,12 +139,28 @@ impl CallEngine {
         info!("connected to relay, handshake complete");
         event_cb("connected", &format!("joined room {room}"));
 
-        // Audio I/O — VPIO (OS AEC) on macOS, plain CPAL otherwise.
-        // The audio handle must be stored in CallEngine to keep streams alive.
-        let (capture_ring, playout_ring, audio_handle): (_, _, Box<dyn std::any::Any + Send>) =
-            if _os_aec {
-                #[cfg(target_os = "macos")]
-                {
+        // Audio I/O — platform-dispatched.
+        //   macOS      VoiceProcessingIO (OS AEC) with CPAL fallback
+        //   Linux/Win  plain CPAL
+        //   Android    Oboe (AAudio / OpenSLES) via the C++ bridge
+        //
+        // The `audio_handle` must outlive the send/recv tasks so audio streams
+        // keep running — stored in the CallEngine below.
+        let (capture_ring, playout_ring, audio_handle): (
+            Arc<AudioRing>,
+            Arc<AudioRing>,
+            Box<dyn std::any::Any + Send>,
+        ) = {
+            #[cfg(target_os = "android")]
+            {
+                let _ = _os_aec; // AEC TBD on Android (step 6 polish)
+                let (cr, pr, handle) = OboeHandle::start()?;
+                info!("using Oboe backend (AAudio/OpenSLES)");
+                (cr, pr, Box::new(handle))
+            }
+            #[cfg(target_os = "macos")]
+            {
+                if _os_aec {
                     match wzp_client::audio_vpio::VpioAudio::start() {
                         Ok(v) => {
                             let cr = v.capture_ring().clone();
@@ -166,23 +177,25 @@ impl CallEngine {
                             (cr, pr, Box::new((capture, playback)))
                         }
                     }
-                }
-                #[cfg(not(target_os = "macos"))]
-                {
-                    info!("OS AEC not available on this platform, using CPAL");
+                } else {
                     let capture = AudioCapture::start()?;
                     let playback = AudioPlayback::start()?;
                     let cr = capture.ring().clone();
                     let pr = playback.ring().clone();
                     (cr, pr, Box::new((capture, playback)))
                 }
-            } else {
+            }
+            #[cfg(all(not(target_os = "macos"), not(target_os = "android")))]
+            {
+                let _ = _os_aec; // OS AEC not available on Linux/Windows here
+                info!("OS AEC not available on this platform, using CPAL");
                 let capture = AudioCapture::start()?;
                 let playback = AudioPlayback::start()?;
                 let cr = capture.ring().clone();
                 let pr = playback.ring().clone();
                 (cr, pr, Box::new((capture, playback)))
-            };
+            }
+        };
 
         let running = Arc::new(AtomicBool::new(true));
         let mic_muted = Arc::new(AtomicBool::new(false));

desktop/src-tauri/src/lib.rs

@@ -6,12 +6,12 @@
     windows_subsystem = "windows"
 )]
 
-// CPAL-backed audio engine — desktop only. On Android we'll plug in an
-// oboe/AAudio backend in a later step.
-#[cfg(not(target_os = "android"))]
+// Call engine — compiled on every platform. Audio backend is cfg-switched
+// inside engine.rs (CPAL/VPIO on desktop, Oboe on Android).
 mod engine;
+#[cfg(target_os = "android")]
+mod oboe_audio;
 
-#[cfg(not(target_os = "android"))]
 use engine::CallEngine;
 
 use serde::Serialize;
@@ -83,7 +83,6 @@ struct CallStatus {
 }
 
 struct AppState {
-    #[cfg(not(target_os = "android"))]
     engine: Mutex<Option<CallEngine>>,
     signal: Arc<Mutex<SignalState>>,
 }
@@ -152,7 +151,7 @@ async fn ping_relay(relay: String) -> Result<PingResult, String> {
 /// Falls back to `$HOME/.wzp` on the desktop side if the OnceLock hasn't been
 /// initialised yet (shouldn't happen in normal startup, but keeps the fn
 /// total).
-fn identity_dir() -> PathBuf {
+pub(crate) fn identity_dir() -> PathBuf {
     if let Some(dir) = APP_DATA_DIR.get() {
         return dir.clone();
     }
@@ -173,7 +172,7 @@ fn identity_path() -> std::path::PathBuf {
 }
 
 /// Load the persisted seed, or generate-and-persist a new one if missing.
-fn load_or_create_seed() -> Result<wzp_crypto::Seed, String> {
+pub(crate) fn load_or_create_seed() -> Result<wzp_crypto::Seed, String> {
     let path = identity_path();
     if path.exists() {
         let hex = std::fs::read_to_string(&path).map_err(|e| format!("read identity: {e}"))?;
@@ -221,7 +220,6 @@ fn get_app_info() -> Result<AppInfo, String> {
     })
 }
 
-#[cfg(not(target_os = "android"))]
 #[tauri::command]
 async fn connect(
     state: tauri::State<'_, Arc<AppState>>,
@@ -257,7 +255,6 @@ async fn connect(
     }
 }
 
-#[cfg(not(target_os = "android"))]
 #[tauri::command]
 async fn disconnect(state: tauri::State<'_, Arc<AppState>>) -> Result<String, String> {
     let mut engine_lock = state.engine.lock().await;
@@ -269,7 +266,6 @@ async fn disconnect(state: tauri::State<'_, Arc<AppState>>) -> Result<String, St
     }
 }
 
-#[cfg(not(target_os = "android"))]
 #[tauri::command]
 async fn toggle_mic(state: tauri::State<'_, Arc<AppState>>) -> Result<bool, String> {
     let engine_lock = state.engine.lock().await;
@@ -280,7 +276,6 @@ async fn toggle_mic(state: tauri::State<'_, Arc<AppState>>) -> Result<bool, Stri
     }
 }
 
-#[cfg(not(target_os = "android"))]
 #[tauri::command]
 async fn toggle_speaker(state: tauri::State<'_, Arc<AppState>>) -> Result<bool, String> {
     let engine_lock = state.engine.lock().await;
@@ -291,7 +286,6 @@ async fn toggle_speaker(state: tauri::State<'_, Arc<AppState>>) -> Result<bool,
     }
 }
 
-#[cfg(not(target_os = "android"))]
 #[tauri::command]
 async fn get_status(state: tauri::State<'_, Arc<AppState>>) -> Result<CallStatus, String> {
     let engine_lock = state.engine.lock().await;
@@ -335,62 +329,6 @@ async fn get_status(state: tauri::State<'_, Arc<AppState>>) -> Result<CallStatus
     }
 }
 
-// ─── Android stubs for engine-backed commands ────────────────────────────────
-//
-// Step 1 of the Android rewrite: signal-only. Audio is wired up in Step 3.
-// These keep the JS frontend happy (same `invoke` surface) without pulling
-// in CPAL, which doesn't support Android.
-
-#[cfg(target_os = "android")]
-#[tauri::command]
-async fn connect(
-    _state: tauri::State<'_, Arc<AppState>>,
-    _app: tauri::AppHandle,
-    _relay: String,
-    _room: String,
-    _alias: String,
-    _os_aec: bool,
-    _quality: String,
-) -> Result<String, String> {
-    Err("audio backend not yet wired on Android (step 3)".into())
-}
-
-#[cfg(target_os = "android")]
-#[tauri::command]
-async fn disconnect(_state: tauri::State<'_, Arc<AppState>>) -> Result<String, String> {
-    Ok("not connected".into())
-}
-
-#[cfg(target_os = "android")]
-#[tauri::command]
-async fn toggle_mic(_state: tauri::State<'_, Arc<AppState>>) -> Result<bool, String> {
-    Err("not connected".into())
-}
-
-#[cfg(target_os = "android")]
-#[tauri::command]
-async fn toggle_speaker(_state: tauri::State<'_, Arc<AppState>>) -> Result<bool, String> {
-    Err("not connected".into())
-}
-
-#[cfg(target_os = "android")]
-#[tauri::command]
-async fn get_status(_state: tauri::State<'_, Arc<AppState>>) -> Result<CallStatus, String> {
-    Ok(CallStatus {
-        active: false,
-        mic_muted: false,
-        spk_muted: false,
-        participants: vec![],
-        encode_fps: 0,
-        recv_fps: 0,
-        audio_level: 0,
-        call_duration_secs: 0.0,
-        fingerprint: String::new(),
-        tx_codec: String::new(),
-        rx_codec: String::new(),
-    })
-}
-
 // ─── Signaling commands — platform independent ───────────────────────────────
 
 struct SignalState {
@@ -508,7 +446,6 @@ pub fn run() {
     tracing_subscriber::fmt().init();
 
     let state = Arc::new(AppState {
-        #[cfg(not(target_os = "android"))]
         engine: Mutex::new(None),
         signal: Arc::new(Mutex::new(SignalState {
             transport: None, fingerprint: String::new(), signal_status: "idle".into(),

desktop/src-tauri/src/oboe_audio.rs

@@ -0,0 +1,220 @@
+//! Android audio backend for WarzonePhone Tauri mobile.
+//!
+//! Wraps the C++ Oboe bridge (cpp/oboe_bridge.cpp) — Oboe runs on high-priority
+//! AAudio/OpenSL callback threads and reads/writes two shared SPSC ring buffers.
+//! The Rust side drains the capture ring into the Opus encoder and fills the
+//! playout ring with decoded PCM — no locking, no allocations, no cross-thread
+//! channels on the hot path.
+//!
+//! Mirror of the proven implementation from `crates/wzp-android/src/audio_android.rs`
+//! but stripped of the JNI-centric bits — this crate is a pure Tauri mobile lib.
+
+#![cfg(target_os = "android")]
+
+use std::sync::atomic::{AtomicI32, Ordering};
+use std::sync::Arc;
+
+use tracing::info;
+
+/// 20 ms @ 48 kHz mono.
+pub const FRAME_SAMPLES: usize = 960;
+
+/// 8 frames × 960 samples = 160 ms headroom at 48 kHz.
+const RING_CAPACITY: usize = 7680;
+
+// ─── FFI to cpp/oboe_bridge.cpp ─────────────────────────────────────────────
+
+#[repr(C)]
+#[allow(non_snake_case)]
+struct WzpOboeConfig {
+    sample_rate: i32,
+    frames_per_burst: i32,
+    channel_count: i32,
+}
+
+#[repr(C)]
+#[allow(non_snake_case)]
+struct WzpOboeRings {
+    capture_buf: *mut i16,
+    capture_capacity: i32,
+    capture_write_idx: *mut AtomicI32,
+    capture_read_idx: *mut AtomicI32,
+    playout_buf: *mut i16,
+    playout_capacity: i32,
+    playout_write_idx: *mut AtomicI32,
+    playout_read_idx: *mut AtomicI32,
+}
+
+unsafe impl Send for WzpOboeRings {}
+unsafe impl Sync for WzpOboeRings {}
+
+unsafe extern "C" {
+    fn wzp_oboe_start(config: *const WzpOboeConfig, rings: *const WzpOboeRings) -> i32;
+    fn wzp_oboe_stop();
+    fn wzp_oboe_capture_latency_ms() -> f32;
+    fn wzp_oboe_playout_latency_ms() -> f32;
+    fn wzp_oboe_is_running() -> i32;
+}
+
+// ─── Lock-free SPSC ring buffer (shared with C++ via AtomicI32) ────────────
+
+/// Single-producer single-consumer ring buffer shared with the C++ Oboe callback.
+///
+/// The exposed method names (`available`, `read`, `write`) mirror
+/// `wzp_client::audio_ring::AudioRing` so the CallEngine code can treat both
+/// backends interchangeably via a cfg-switched type alias.
+pub struct AudioRing {
+    buf: Vec<i16>,
+    capacity: usize,
+    write_idx: AtomicI32,
+    read_idx: AtomicI32,
+}
+
+// SAFETY: SPSC — producer owns write_idx, consumer owns read_idx, atomics
+// provide acquire/release visibility between threads.
+unsafe impl Send for AudioRing {}
+unsafe impl Sync for AudioRing {}
+
+impl AudioRing {
+    pub fn new() -> Self {
+        Self {
+            buf: vec![0i16; RING_CAPACITY],
+            capacity: RING_CAPACITY,
+            write_idx: AtomicI32::new(0),
+            read_idx: AtomicI32::new(0),
+        }
+    }
+
+    /// Samples currently available to read.
+    pub fn available(&self) -> usize {
+        let w = self.write_idx.load(Ordering::Acquire);
+        let r = self.read_idx.load(Ordering::Relaxed);
+        let avail = w - r;
+        if avail < 0 {
+            (avail + self.capacity as i32) as usize
+        } else {
+            avail as usize
+        }
+    }
+
+    /// Samples that can still be written without overflowing.
+    pub fn available_write(&self) -> usize {
+        self.capacity.saturating_sub(1).saturating_sub(self.available())
+    }
+
+    /// Producer side: write `data.len()` samples if room permits, else as many
+    /// as fit. Returns the number of samples actually written.
+    pub fn write(&self, data: &[i16]) -> usize {
+        let avail = self.available_write();
+        let count = data.len().min(avail);
+        if count == 0 {
+            return 0;
+        }
+        let mut w = self.write_idx.load(Ordering::Relaxed) as usize;
+        let cap = self.capacity;
+        let buf_ptr = self.buf.as_ptr() as *mut i16;
+        for sample in &data[..count] {
+            unsafe { *buf_ptr.add(w) = *sample; }
+            w += 1;
+            if w >= cap { w = 0; }
+        }
+        self.write_idx.store(w as i32, Ordering::Release);
+        count
+    }
+
+    /// Consumer side: read up to `out.len()` samples. Returns count actually read.
+    pub fn read(&self, out: &mut [i16]) -> usize {
+        let avail = self.available();
+        let count = out.len().min(avail);
+        if count == 0 {
+            return 0;
+        }
+        let mut r = self.read_idx.load(Ordering::Relaxed) as usize;
+        let cap = self.capacity;
+        let buf_ptr = self.buf.as_ptr();
+        for slot in &mut out[..count] {
+            unsafe { *slot = *buf_ptr.add(r); }
+            r += 1;
+            if r >= cap { r = 0; }
+        }
+        self.read_idx.store(r as i32, Ordering::Release);
+        count
+    }
+
+    fn buf_ptr(&self) -> *mut i16 {
+        self.buf.as_ptr() as *mut i16
+    }
+    fn write_idx_ptr(&self) -> *mut AtomicI32 {
+        &self.write_idx as *const AtomicI32 as *mut AtomicI32
+    }
+    fn read_idx_ptr(&self) -> *mut AtomicI32 {
+        &self.read_idx as *const AtomicI32 as *mut AtomicI32
+    }
+}
+
+// ─── Owning handle: starts/stops the Oboe streams and holds the rings alive ──
+
+/// Owns both ring buffers and the active Oboe streams. Dropping this handle
+/// stops the streams; the rings cannot outlive it because they're owned inside.
+pub struct OboeHandle {
+    capture: Arc<AudioRing>,
+    playout: Arc<AudioRing>,
+    started: bool,
+}
+
+impl OboeHandle {
+    /// Allocate ring buffers and start the Oboe capture + playout streams.
+    /// Returns the handle plus cloned ring Arcs for the CallEngine's send/recv tasks.
+    pub fn start() -> Result<(Arc<AudioRing>, Arc<AudioRing>, Self), anyhow::Error> {
+        let capture = Arc::new(AudioRing::new());
+        let playout = Arc::new(AudioRing::new());
+
+        let config = WzpOboeConfig {
+            sample_rate: 48_000,
+            frames_per_burst: FRAME_SAMPLES as i32,
+            channel_count: 1,
+        };
+        let rings = WzpOboeRings {
+            capture_buf: capture.buf_ptr(),
+            capture_capacity: capture.capacity as i32,
+            capture_write_idx: capture.write_idx_ptr(),
+            capture_read_idx: capture.read_idx_ptr(),
+            playout_buf: playout.buf_ptr(),
+            playout_capacity: playout.capacity as i32,
+            playout_write_idx: playout.write_idx_ptr(),
+            playout_read_idx: playout.read_idx_ptr(),
+        };
+
+        let ret = unsafe { wzp_oboe_start(&config, &rings) };
+        if ret != 0 {
+            return Err(anyhow::anyhow!("wzp_oboe_start failed: code {ret}"));
+        }
+        info!(capture_latency_ms = unsafe { wzp_oboe_capture_latency_ms() },
+              playout_latency_ms = unsafe { wzp_oboe_playout_latency_ms() },
+              "oboe backend started");
+
+        Ok((
+            capture.clone(),
+            playout.clone(),
+            Self { capture, playout, started: true },
+        ))
+    }
+
+    #[allow(unused)]
+    pub fn is_running(&self) -> bool {
+        unsafe { wzp_oboe_is_running() != 0 }
+    }
+}
+
+impl Drop for OboeHandle {
+    fn drop(&mut self) {
+        if self.started {
+            unsafe { wzp_oboe_stop() };
+            info!("oboe backend stopped");
+            self.started = false;
+        }
+        // Rings live as long as their Arcs do — the C++ side has already
+        // stopped, so no more callbacks will touch the atomics.
+        let _ = (&self.capture, &self.playout);
+    }
+}

scripts/build-tauri-android.sh

@@ -179,6 +179,45 @@ if [ "${DO_INIT}" = "1" ] || [ ! -x gen/android/gradlew ]; then
     cargo tauri android init 2>&1 | tail -20
 fi
 
+# ── Post-init patches: runtime mic permission + jniLibs dir ─────────────────
+MANIFEST=gen/android/app/src/main/AndroidManifest.xml
+if ! grep -q "RECORD_AUDIO" "$MANIFEST"; then
+    echo ">>> injecting RECORD_AUDIO + MODIFY_AUDIO_SETTINGS into AndroidManifest"
+    sed -i "s|<uses-permission android:name=\"android.permission.INTERNET\" />|<uses-permission android:name=\"android.permission.INTERNET\" />\n    <uses-permission android:name=\"android.permission.RECORD_AUDIO\" />\n    <uses-permission android:name=\"android.permission.MODIFY_AUDIO_SETTINGS\" />|" "$MANIFEST"
+fi
+
+# Overwrite MainActivity to request the mic permission on launch. Idempotent —
+# Tauri re-init would reset it, and we re-write it here on every build.
+MAIN_ACTIVITY=gen/android/app/src/main/java/com/wzp/desktop/MainActivity.kt
+cat > "$MAIN_ACTIVITY" <<KOTLIN_EOF
+package com.wzp.desktop
+
+import android.Manifest
+import android.content.pm.PackageManager
+import android.os.Bundle
+import androidx.activity.enableEdgeToEdge
+import androidx.core.app.ActivityCompat
+
+class MainActivity : TauriActivity() {
+  override fun onCreate(savedInstanceState: Bundle?) {
+    enableEdgeToEdge()
+    super.onCreate(savedInstanceState)
+
+    // Auto-request RECORD_AUDIO + MODIFY_AUDIO_SETTINGS on first launch — Oboe
+    // capture fails silently without them.
+    val needed = arrayOf(
+      Manifest.permission.RECORD_AUDIO,
+      Manifest.permission.MODIFY_AUDIO_SETTINGS,
+    ).filter {
+      ActivityCompat.checkSelfPermission(this, it) != PackageManager.PERMISSION_GRANTED
+    }.toTypedArray()
+    if (needed.isNotEmpty()) {
+      ActivityCompat.requestPermissions(this, needed, 1337)
+    }
+  }
+}
+KOTLIN_EOF
+
 echo ">>> cargo tauri android build ${PROFILE_FLAG} --target aarch64 --apk"
 cargo tauri android build ${PROFILE_FLAG} --target aarch64 --apk