disable rust cache in linux ci

When `select!` drops a JoinHandle, it doesn't abort the spawned task - it detaches it. From tokio docs:

A JoinHandle detaches the associated task when it is dropped, which means that there is no
longer any handle to the task, and no way to join on it.

This means the spawn task is still spinning in the background:
  1. c2s completes (client disconnected)
  2. select! drops the s2c JoinHandle
  3. The s2c task continues running in the background, detached
  4. That task holds the Mumble server connection open

The fix is to hand the async calls directly to select! instead of
calling tokio::spawn.

.gitea/workflows/android-container-builds.yaml

@@ -0,0 +1,27 @@
+name: Build android container
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: "0 4 * * *"
+
+jobs:
+  android-release-builder-container-build:
+    runs-on: ubuntu-latest 
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Log in to container registry
+        uses: docker/login-action@v3
+        with:
+          registry: git.ohea.xyz
+          username: ${{ secrets.CI_REGISTRY_USER }}
+          password: ${{ secrets.CI_REGISTRY_PASSWORD }}
+
+      - name: Build Android builder image
+        shell: bash
+        run: |
+          docker pull "$(grep -m1 '^FROM' ./docker/android-release-builder.Dockerfile | awk '{print $2}')"
+          docker build -t git.ohea.xyz/mumble/mumble-web2/android-release-builder:latest -f ./docker/android-release-builder.Dockerfile .
+          docker push git.ohea.xyz/mumble/mumble-web2/android-release-builder:latest

.gitea/workflows/build-release.yaml

@@ -18,9 +18,9 @@ jobs:
         run: curl -L --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/cargo-bins/cargo-binstall/main/install-from-binstall-release.sh | bash
 
       - name: Install dioxus-cli
-        run: cargo binstall dioxus-cli --version 0.7.1
+        run: cargo binstall dioxus-cli --version 0.7.2
 
-      - uses: Swatinem/rust-cache@v2
+      #- uses: Swatinem/rust-cache@v2
 
       - name: Build dioxus project
         run: dx build --platform web --release -p mumble-web2-gui
@@ -83,3 +83,26 @@ jobs:
           name: mumble-web2-gui-windows
           path: gui/dist
           retention-days: 5
+
+  android_build:
+    runs-on: ubuntu-latest
+    container:
+      image: git.ohea.xyz/mumble/mumble-web2/android-release-builder:latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - uses: Swatinem/rust-cache@v2
+
+      - name: Build dioxus project (x86_64-linux-android)
+        run: dx build --platform android --target x86_64-linux-android --release -p mumble-web2-gui
+
+      - name: Build dioxus project (aarch64-linux-android)
+        run: dx build --platform android --target aarch64-linux-android --release -p mumble-web2-gui
+
+      - name: Upload mumble-web2-gui Android Artifact
+        uses: https://gitea.com/actions/gitea-upload-artifact@v4
+        with:
+          name: mumble-web2-android
+          path: target/dx/mumble-web2-gui/release/android/app/app/build/outputs/apk/debug/app-debug.apk
+          retention-days: 5

.gitea/workflows/windows-container-build.yaml

@@ -22,6 +22,6 @@ jobs:
       - name: Build Windows image
         shell: bash
         run: |
-          docker pull "$(grep -m1 '^FROM' Dockerfile | awk '{print $2}')"
+          docker pull "$(grep -m1 '^FROM' ./docker/windows-release-builder.Dockerfile | awk '{print $2}')"
           docker build -t git.ohea.xyz/mumble/mumble-web2/windows-release-builder:latest -f ./docker/windows-release-builder.Dockerfile .
           docker push git.ohea.xyz/mumble/mumble-web2/windows-release-builder:latest

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+    "rust-analyzer.cargo.features": ["desktop","web"],
+    "rust-analyzer.cargo.noDefaultFeatures": false
+}

common/src/lib.rs

@@ -3,7 +3,6 @@ use serde::{Deserialize, Serialize};
 #[derive(Debug, Clone, Deserialize, Serialize, Default)]
 pub struct ClientConfig {
     pub proxy_url: Option<String>,
-    pub status_url: Option<String>,
     pub cert_hash: Option<Vec<u8>>,
     pub any_server: bool,
 }

config.toml.example

@@ -1,4 +1,4 @@
-public_url = "https://127.0.0.1:4433"
+proxy_url = "https://127.0.0.1:4433/proxy"
 https_listen_address = "127.0.0.1:4433"
 http_listen_address = "127.0.0.1:8080"
 mumble_server_url = "[SERVER_URL_HERE]"

docker/android-release-builder.Dockerfile

@@ -0,0 +1,43 @@
+FROM rust:trixie
+
+ARG ANDROID_CLI_TOOLS_VERSION=13114758
+
+# Install android rust toolchains
+RUN rustup target add aarch64-linux-android armv7-linux-androideabi i686-linux-android x86_64-linux-android
+
+# Install debian dependencies
+RUN apt-get update && \
+    DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
+    nodejs \
+    ca-certificates \
+    curl \
+    unzip \
+    default-jdk
+
+# Install android commandline tools (required to install the sdk)
+RUN cd /tmp && \
+    curl -o commandlinetools-linux.zip "https://dl.google.com/android/repository/commandlinetools-linux-${ANDROID_CLI_TOOLS_VERSION}_latest.zip" && \
+    unzip commandlinetools-linux.zip && \
+    mkdir -p /opt/android-tools/cmdline-tools && \ 
+    cp -r cmdline-tools /opt/android-tools/cmdline-tools/latest
+
+
+# Install required android tools
+RUN yes | /opt/android-tools/cmdline-tools/latest/bin/sdkmanager --install "platform-tools" "platforms;android-36.1" "build-tools;36.1.0" "ndk;29.0.14206865" "cmake;3.31.6"
+
+# Install cargo binstall
+RUN curl -L --proto '=https' --tlsv1.2 -sSf https://raw.githubusercontent.com/cargo-bins/cargo-binstall/main/install-from-binstall-release.sh | bash
+
+# Install dioxus-cli
+RUN cargo binstall dioxus-cli@0.7.2
+
+# Install bindgen-cli
+RUN cargo binstall bindgen-cli
+
+# Set required env vars
+ENV ANDROID_HOME="/opt/android-tools/"
+ENV NDK_HOME="$ANDROID_HOME/ndk/29.0.14206865"
+ENV PATH="$PATH:$ANDROID_HOME/platform-tools"
+ENV PATH="$PATH:/opt/android-tools/cmake/3.31.6/bin/"
+ENV LLVM_CONFIG_PATH="/opt/android-tools/ndk/29.0.14206865/toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-config"
+

docker/docker-compose.yaml

@@ -5,7 +5,7 @@ services:
       - "64444:64444/tcp"
       - "64444:64444/udp"
     volumes:
-      - ./Caddyfile:/etc/caddy/Caddyfile
+      - ./Caddyfile:/etc/caddy/Caddyfile:z
       #- caddy_data:/data
       #- caddy_config:/config
     depends_on:
@@ -35,8 +35,8 @@ services:
     image: rust:latest
     working_dir: /app
     volumes:
-      - ..:/app
-      - ./proxy-config.toml:/app/config.toml
+      - ..:/app:z
+      - ./proxy-config.toml:/app/config.toml:z
     ports:
       - "4433:4433/tcp"
       - "4433:4433/udp"

docker/proxy-config.toml

@@ -1,4 +1,3 @@
-public_url = "https://localhost:64444"
 proxy_url = "https://127.0.0.1:4433/proxy"
 https_listen_address = "127.0.0.1:4433"
 http_listen_address = "127.0.0.1:4400"

docker/windows-release-builder.Dockerfile

@@ -44,10 +44,14 @@ RUN choco install rustup.install -y --no-progress
 RUN rustup toolchain install stable-x86_64-pc-windows-msvc
 RUN rustup default stable-x86_64-pc-windows-msvc
 
+# Install carog binstall
+RUN Set-ExecutionPolicy Unrestricted -Scope Process; `
+  iex (Invoke-WebRequest "https://raw.githubusercontent.com/cargo-bins/cargo-binstall/main/install-from-binstall-release.ps1" -UseBasicParsing).Content
+
 SHELL ["C:\\Program Files (x86)\\Microsoft Visual Studio\\2022\\BuildTools\\Common7\\Tools\\VsDevCmd.bat", "&&", "powershell.exe", "-NoLogo", "-ExecutionPolicy", "Bypass"]
 # Install dioxus-cli from git HEAD with cargo
 # This is to work around a bug in the windows builder upstream.
 # Dioxus has released 0.7.2, but it seems to be broken for now.
-RUN cargo install --git https://github.com/DioxusLabs/dioxus dioxus-cli
+RUN cargo binstall dioxus-cli
 
 ENTRYPOINT ["C:\\Program Files (x86)\\Microsoft Visual Studio\\2022\\BuildTools\\Common7\\Tools\\VsDevCmd.bat", "&&", "powershell.exe", "-NoLogo", "-ExecutionPolicy", "Bypass"]

gui/Cargo.toml

@@ -30,8 +30,6 @@ web-sys = { version = "^0.3.72", features = [
   "EncodedAudioChunkInit",
   "EncodedAudioChunkType",
   "CodecState",
-  "MediaStreamTrackGenerator",
-  "MediaStreamTrackGeneratorInit",
   "AudioContext",
   "AudioContextOptions",
   "MediaStream",
@@ -42,6 +40,7 @@ web-sys = { version = "^0.3.72", features = [
   "AudioWorkletNode",
   "AudioWorklet",
   "AudioWorkletProcessor",
+  "MessagePort",
   "MediaStreamConstraints",
   "WorkletOptions",
   "AudioEncoder",
@@ -64,10 +63,11 @@ tokio-rustls = { version = "^0.26.0", optional = true }
 opus = { version = "0.3.0", optional = true }
 cpal = { version = "0.15.3", optional = true }
 dasp_ring_buffer = { version = "0.11.0", optional = true }
+etcetera = { version = "0.10.0", optional = true }
 
 # Base Dependencies
 # ================
-dioxus = { version = "0.7.1" }
+dioxus = { version = "0.7.2" }
 once_cell = "1.19.0"
 asynchronous-codec = { workspace = true }
 futures = "^0.3.30"
@@ -88,18 +88,32 @@ tracing = "^0.1.40"
 color-eyre = "^0.6.3"
 crossbeam-queue = "^0.3.11"
 lol_html = "^2.2.0"
-rfd = { git = "https://github.com/samsartor/rfd.git", version = "^0.16.0", default-features = false } 
 base64 = "^0.22"
 mime_guess = "^2.0.5"
 async_cell = "^0.2.3"
 reqwest = { version = "^0.12.22", features = ["json"] }
-dioxus-asset-resolver = "0.7.1"
+dioxus-asset-resolver = "0.7.2"
+
 
 # Denoising
 # =========
-deep_filter = { git = "https://github.com/Rikorose/DeepFilterNet.git", rev = "d375b2d8309e0935d165700c91da9de862a99c31", features = ["tract"] }
+deep_filter = { git = "https://github.com/Rikorose/DeepFilterNet.git", rev = "d375b2d8309e0935d165700c91da9de862a99c31", features = [
+  "tract",
+] }
 crossbeam = "0.8.4"
 
+# Platform Integration
+# ====================
+# rfd only supports windows, macos, linux, and wasm32. No support for Android or iOS
+[target.'cfg(any(target_os = "linux", target_os = "windows", target_os = "macos", target_arch = "wasm32"))'.dependencies]
+rfd = { git = "https://github.com/PolyMeilex/rfd.git", version = "^0.16.0", default-features = false, optional = true }
+
+# Android dependencies for requesting permissions
+[target.'cfg(target_os = "android")'.dependencies]
+android-permissions = "0.1.2"
+jni = "0.21.1"
+ndk-context = "0.1.1"
+
 [patch.crates-io]
 tract-hir = "=0.12.4"
 tract-core = "=0.12.4"
@@ -119,6 +133,7 @@ web = [
   "gloo-timers",
   "tracing-web",
   "deep_filter/wasm",
+  "rfd",
 ]
 desktop = [
   "dioxus/desktop",
@@ -129,5 +144,15 @@ desktop = [
   "cpal",
   "dasp_ring_buffer",
   "rfd/xdg-portal",
-  "rfd/tokio",
+  "etcetera",
+]
+
+mobile = [
+  "dioxus/mobile",
+  "tokio",
+  "tokio-rustls",
+  "tracing-subscriber/env-filter",
+  "opus",
+  "cpal",
+  "dasp_ring_buffer",
 ]

gui/Dioxus.toml

@@ -8,6 +8,8 @@ out_dir = "dist"
 # resource (public) file folder
 asset_dir = "public"
 
+android_manifest = "build/AndroidManifest.xml"
+
 [web.app]
 # HTML title tag content
 title = "Mumble Web 2"
@@ -23,7 +25,7 @@ watch_path = ["src", "assets"]
 # CSS style file
 style = []
 # Javascript code file
-script = []
+script = ["loader.js"]
 
 [web.resource.dev]
 # serve: [dev-server] only
@@ -33,7 +35,7 @@ style = []
 script = []
 
 [bundle]
-identifier = "xyz.ohea.mumble-web-2"
+identifier = "xyz.ohea.mumble_web_2"
 publisher = "OheaCorp"
 icon = [
   "icons/32x32.png",

gui/assets/main.scss

@@ -168,26 +168,68 @@ a:visited {
   background-color: oklch(0.53 0.1431 264.18);
   border-radius: 50%;
   aspect-ratio: 1 / 1;
+  flex-shrink: 0;
+
+  .material-symbols-outlined {
+    font-variation-settings: 'FILL' 1, 'wght' 700, 'GRAD' 0, 'opsz' 48;
+  }
 }
 
 .button_row {
   display: flex;
-  gap: 10px;
+  gap: clamp(4px, 1vw, 10px);
+  align-items: center;
+  flex-wrap: nowrap;
+  min-height: 0;
 
   .spacer {
     flex-grow: 1;
+    flex-shrink: 1;
+    min-width: 0;
+  }
+
+  .connection_status {
+    display: flex;
+    flex-direction: column;
+    min-width: 0;
+    flex-shrink: 1;
+
+    .material-symbols-outlined {
+      font-variation-settings: 'FILL' 1, 'wght' 700, 'GRAD' 0, 'opsz' 48;
+      vertical-align: middle;
+    }
+  }
+
+  .user_info {
+    display: flex;
+    flex-direction: column;
+    min-width: 0;
+    overflow: hidden;
+    flex-shrink: 1;
+
+    .user_name {
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
+
+    .user_data {
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+    }
   }
 }
 
 .toggle_button {
-  padding: 8px;
-  height: 100%;
+  padding: clamp(4px, 0.5vw, 8px);
   aspect-ratio: 1 / 1;
+  flex-shrink: 0;
 
   background-color: unset;
 
-  border: solid rgb(255 255 255 / 0.1) 3px;
-  border-radius: 10px;
+  border: solid rgb(255 255 255 / 0.1) clamp(1px, 0.3vw, 3px);
+  border-radius: clamp(4px, 0.8vw, 10px);
   color: rgb(255 255 255 / 50%);
 
   transition: all 0.5s ease-in-out;
@@ -200,7 +242,6 @@ a:visited {
   .material-symbols-outlined {
     font-variation-settings: 'FILL' 1, 'wght' 700, 'GRAD' 0, 'opsz' 48;
     vertical-align: middle;
-    font-size: 35px;
   }
 }
 
@@ -245,16 +286,60 @@ a:visited {
   }
 
   &_control_box {
-    padding: 16px;
-    margin: 16px;
+    padding: clamp(6px, 0.8vw, 12px);
+    margin: clamp(6px, 0.8vw, 12px);
     background-color: var(--light-bg-color);
-    border-radius: 10px;
+    border-radius: clamp(6px, 1vw, 10px);
     overflow: hidden;
     grid-area: control;
 
     display: flex;
-    gap: 10px;
+    gap: clamp(4px, 0.8vw, 8px);
     flex-direction: column;
+
+    // Dynamic font sizing for control elements
+    --control-icon-size: clamp(16px, 2.5vw, 30px);
+    --control-text-size: clamp(12px, 2vw, 25px);
+    --control-small-text-size: clamp(10px, 1.5vw, 20px);
+    --user-icon-size: clamp(24px, 4vw, 45px);
+    --toggle-icon-size: clamp(18px, 3vw, 35px);
+
+    .connection_status {
+      .material-symbols-outlined {
+        font-size: var(--control-icon-size);
+      }
+      .status_text {
+        font-size: var(--control-text-size);
+      }
+      .channel_text {
+        font-size: var(--control-small-text-size);
+      }
+    }
+
+    .user_edit_button {
+      .material-symbols-outlined {
+        font-size: var(--user-icon-size);
+      }
+    }
+
+    .user_info {
+      .user_name {
+        font-size: var(--control-text-size);
+      }
+      .user_data {
+        font-size: var(--control-small-text-size);
+      }
+    }
+
+    .toggle_button {
+      .material-symbols-outlined {
+        font-size: var(--toggle-icon-size);
+      }
+    }
+
+    hr {
+      margin: 0;
+    }
   }
 }
 
@@ -279,6 +364,11 @@ a:visited {
     color: #b3c6b4;
   }
 
+  &_version {
+    color: var(--txt-color);
+    font-weight: normal;
+  }
+
   &_bttn {
     font-weight: bold;
     font-size: large;

gui/assets/rust_audio_worklet.js

@@ -1,7 +1,7 @@
 const SAMPLE_RATE = 48000;
 const PACKET_SAMPLES = 960;
 
-class RustWorklet extends AudioWorkletProcessor {
+class RustMicWorklet extends AudioWorkletProcessor {
   constructor(options) {
     super();
     this.module = options.processorOptions;
@@ -60,4 +60,44 @@ class RustWorklet extends AudioWorkletProcessor {
   }
 };
 
-registerProcessor("rust_mic_worklet", RustWorklet);
+
+class RustSpeakerWorklet extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.queue = [];
+    this.readIndex = 0;
+
+    this.port.onmessage = (event) => {
+      this.queue.push(event.data)
+    };
+  }
+
+  process(inputs, outputs) {
+    if (this.queue.length) {
+      console.log(this.queue[0].samples.length, outputs[0][0].length);
+    }
+
+    const output = outputs[0];
+
+    for (let i = 0; i < output[0].length; i++) {
+      if (!this.queue.length) {
+        return true;
+      }
+      const current = this.queue[0];
+      for (let ch = 0; ch < output.length; ch++) {
+        output[ch][i] = current.samples[this.readIndex];
+      }
+      this.readIndex++;
+      if (this.readIndex >= current.samples.length) {
+        this.queue.shift();
+        this.readIndex = 0;
+      }
+    }
+    return true;
+  }
+};
+
+
+
+registerProcessor("rust_mic_worklet", RustMicWorklet);
+registerProcessor("rust_speaker_worklet", RustSpeakerWorklet);

gui/build.rs

@@ -1,7 +1,39 @@
+use std::env;
 use std::path::Path;
 use std::process::Command;
 
-fn main() {
+fn version_env() -> Option<()> {
+    if env::var("MUMBLE_WEB2_VERSION").is_ok() {
+        return Some(());
+    }
+
+    let output = Command::new("git")
+        .args(["rev-parse", "--short", "HEAD"])
+        .output()
+        .ok()?;
+
+    let git_hash = String::from_utf8(output.stdout).ok()?;
+    let git_hash = git_hash.trim(); // drop trailing newline
+
+    let status = Command::new("git")
+        .args(["status", "--porcelain"])
+        .output()
+        .ok()?;
+    let dirty = match status.stdout.is_empty() {
+        true => "",
+        false => "-dirty",
+    };
+
+    // Expose it as a compile-time env var
+    println!("cargo::rustc-env=MUMBLE_WEB2_VERSION=git-{git_hash}{dirty}");
+
+    // Optional: rebuild when HEAD changes
+    println!("cargo::rerun-if-changed=.git/HEAD");
+
+    Some(())
+}
+
+fn download_deepfilternet() {
     // Define the target directory and file
     let assets_dir = "assets";
     let target_file = format!("{}/DeepFilterNet3_ll_onnx.tar.gz", assets_dir);
@@ -9,11 +41,17 @@ fn main() {
 
     // Check if the file already exists
     if target_path.exists() {
-        println!("cargo:warning=DeepFilterNet model already exists at {}", target_file);
+        println!(
+            "cargo::warning=DeepFilterNet model already exists at {}",
+            target_file
+        );
         return;
     }
 
-    println!("cargo:warning=Downloading DeepFilterNet model to {}...", target_file);
+    println!(
+        "cargo::warning=Downloading DeepFilterNet model to {}...",
+        target_file
+    );
 
     // Download the file using curl
     let url = "https://github.com/Rikorose/DeepFilterNet/raw/refs/heads/main/models/DeepFilterNet3_ll_onnx.tar.gz";
@@ -21,18 +59,28 @@ fn main() {
     let status = Command::new("curl")
         .args([
             "-L", // Follow redirects
-            "-o", &target_file,  // Output file
+            "-o",
+            &target_file, // Output file
             url,
         ])
         .status()
         .expect("Failed to execute curl command. Make sure curl is installed.");
 
     if !status.success() {
-        panic!("Failed to download DeepFilterNet model from {}", url);
+        println!("cargo::error=Failed to download DeepFilterNet model from {url}");
+        return;
     }
 
-    println!("cargo:warning=Successfully downloaded DeepFilterNet model to {}", target_file);
+    println!(
+        "cargo::warning=Successfully downloaded DeepFilterNet model to {}",
+        target_file
+    );
 
     // Rerun this build script if the target file is deleted
-    println!("cargo:rerun-if-changed={}", target_file);
+    println!("cargo::rerun-if-changed={}", target_file);
+}
+
+fn main() {
+    version_env();
+    download_deepfilternet();
 }

gui/build/AndroidManifest.xml

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8" ?>
+
+<!--
+Borrowed from https://github.com/irh/audio-app/blob/main/apps/dioxus/AndroidManifest.xml 
+--> 
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+
+    <uses-feature android:name="android.hardware.audio.low_latency" android:required="false" />
+    <uses-feature android:name="android.hardware.audio.output" android:required="false" />
+    <uses-feature android:name="android.hardware.audio.pro" android:required="false" />
+    <uses-feature android:name="android.hardware.microphone" android:required="false" />
+
+    <application android:hasCode="true" android:supportsRtl="true" android:icon="@mipmap/ic_launcher"
+        android:extractNativeLibs="true"
+        android:allowNativeHeapPointerTagging="false"
+        android:label="@string/app_name"
+        android:theme="@style/AppTheme"
+        android:networkSecurityConfig="@xml/network_security_config">
+        <activity android:configChanges="orientation|screenLayout|screenSize|keyboardHidden" android:exported="true"
+            android:label="@string/app_name" android:name="dev.dioxus.main.MainActivity">
+            <meta-data android:name="android.app.lib_name" android:value="dioxusmain" />
+            <meta-data android:name="android.app.func_name" android:value="ANativeActivity_onCreate" />
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>

gui/public/loader.js

@@ -0,0 +1,68 @@
+// Loading screen that displays while WASM loads
+(function() {
+  // Create and inject loader styles immediately (head exists)
+  var style = document.createElement('style');
+  style.textContent =
+    '.wasm-loader {' +
+      'position: fixed;' +
+      'top: 0;' +
+      'left: 0;' +
+      'width: 100%;' +
+      'height: 100%;' +
+      'background-color: oklch(0.15 0.01 338.64);' +
+      'display: flex;' +
+      'align-items: center;' +
+      'justify-content: center;' +
+      'z-index: 9999;' +
+      'transition: opacity 0.3s ease-out;' +
+    '}' +
+    '.wasm-loader.hidden {' +
+      'opacity: 0;' +
+      'pointer-events: none;' +
+    '}' +
+    '.wasm-spinner {' +
+      'width: 48px;' +
+      'height: 48px;' +
+      'border: 4px solid rgba(123, 173, 159, 0.2);' +
+      'border-top-color: #7bad9f;' +
+      'border-radius: 50%;' +
+      'animation: wasm-spin 1s linear infinite;' +
+    '}' +
+    '@keyframes wasm-spin {' +
+      'to { transform: rotate(360deg); }' +
+    '}' +
+    '#main {' +
+      'background-color: oklch(0.15 0.01 338.64);' +
+    '}';
+  document.head.appendChild(style);
+
+  function init() {
+    // Create loader element
+    var loader = document.createElement('div');
+    loader.className = 'wasm-loader';
+    loader.innerHTML = '<div class="wasm-spinner"></div>';
+    document.body.appendChild(loader);
+
+    // Watch for Dioxus to mount content in #main
+    var observer = new MutationObserver(function(mutations, obs) {
+      var main = document.getElementById('main');
+      if (main && main.children.length > 0) {
+        loader.classList.add('hidden');
+        setTimeout(function() { loader.remove(); }, 300);
+        obs.disconnect();
+      }
+    });
+
+    observer.observe(document.body, {
+      childList: true,
+      subtree: true
+    });
+  }
+
+  // Wait for body to exist
+  if (document.body) {
+    init();
+  } else {
+    document.addEventListener('DOMContentLoaded', init);
+  }
+})();

gui/src/app.rs

@@ -68,16 +68,21 @@ pub struct UserState {
     pub channel: ChannelId,
     pub deaf: bool,
     pub mute: bool,
+    pub suppress: bool,
     pub self_deaf: bool,
     pub self_mute: bool,
 }
 
 impl UserState {
     pub fn icon(&self) -> UserIcon {
-        match (self.mute || self.self_mute, self.deaf || self.self_deaf) {
-            (false, false) => UserIcon::Normal,
-            (true, false) => UserIcon::Muted,
-            (_, true) => UserIcon::Deafened,
+        if self.deaf || self.self_deaf {
+            UserIcon::Deafened
+        } else if self.mute || self.self_mute {
+            UserIcon::Muted
+        } else if self.suppress {
+            UserIcon::Suppressed
+        } else {
+            UserIcon::Normal
         }
     }
 }
@@ -117,6 +122,7 @@ pub enum UserIcon {
     Normal,
     Muted,
     Deafened,
+    Suppressed,
     None,
 }
 
@@ -128,7 +134,7 @@ impl UserIcon {
         use UserIcon::*;
         Some(match self {
             Normal => asset!("assets/mic-svgrepo-com.svg"),
-            Muted => asset!("assets/mic-off-svgrepo-com.svg"),
+            Muted | Suppressed => asset!("assets/mic-off-svgrepo-com.svg"),
             Deafened => asset!("assets/speaker-muted-svgrepo-com.svg"),
             None => return Option::None,
         })
@@ -140,7 +146,7 @@ pub fn UserPill(name: String, icon: UserIcon, isself: bool) -> Element {
     let color = match icon {
         UserIcon::Normal => "var(--accent-normal)",
         UserIcon::Muted => "var(--accent-muted)",
-        UserIcon::Deafened => "var(--accent-deafened)",
+        UserIcon::Suppressed | UserIcon::Deafened => "var(--accent-deafened)",
         UserIcon::None => "var(--accent-normal)",
     };
 
@@ -210,6 +216,7 @@ pub fn Channel(id: ChannelId) -> Element {
     )
 }
 
+#[cfg(any(feature = "desktop", feature = "web"))]
 pub fn pick_and_send_file(net: &Coroutine<Command>) {
     let channels = if let Some(user) = STATE.server.read().this_user() {
         vec![user.channel]
@@ -231,6 +238,8 @@ pub fn pick_and_send_file(net: &Coroutine<Command>) {
         });
     });
 }
+#[cfg(not(any(feature = "desktop", feature = "web")))]
+pub fn pick_and_send_file(net: &Coroutine<Command>) {}
 
 #[component]
 pub fn ChatView() -> Element {
@@ -317,6 +326,7 @@ pub fn ControlView(config: Resource<ClientConfig>) -> Element {
         deaf,
         self_deaf,
         mute,
+        suppress,
         self_mute,
         ref name,
         channel,
@@ -341,81 +351,71 @@ pub fn ControlView(config: Resource<ClientConfig>) -> Element {
     let connection_status = match &*status.read() {
         Connecting => rsx! {
             div {
-                style: "color: \"{connecting_color}\";",
+                class: "connection_status",
+                style: "color: {connecting_color};",
+                div {
                     span {
                         class: "material-symbols-outlined",
-                    style: "vertical-align: middle; font-size: 30px;",
                         "signal_cellular_alt_2_bar"
                     }
                     span {
-                    style: "width: 5px; display: inline-block;"
-                }
-                span {
-                    style: "vertical-align: middle; font-size: 30px;",
+                        class: "status_text",
                         " Connecting"
                     }
                 }
+            }
         },
         Connected => rsx! {
             div {
+                class: "connection_status",
                 div {
-                    style: "color: \"{connected_color}\";",
+                    style: "color: {connected_color};",
                     span {
                         class: "material-symbols-outlined",
-                        style: "vertical-align: middle; font-size: 30px;",
                         "signal_cellular_alt"
                     }
                     span {
-                        style: "width: 5px; display: inline-block;"
-                    }
-                    span {
-                        style: "vertical-align: middle; font-size: 25px;",
+                        class: "status_text",
                         " Connected"
                     }
                 }
                 div {
-                    span { style: "width: 3px; display: inline-block;"}
+                    class: "channel_text",
                     span { "{current_channel_name}" }
-                    if let Some(proxy_url) = proxy_url {
-                        span { " — " }
-                        span { "{proxy_url}" }
-                    }
                 }
             }
         },
         Disconnected => rsx! {
             div {
-                style: "color: \"{disconnected_color}\";",
+                class: "connection_status",
+                style: "color: {disconnected_color};",
+                div {
                     span {
                         class: "material-symbols-outlined",
-                    style: "vertical-align: middle;",
                         "signal_disconnected"
                     }
                     span {
-                    style: "width: 5px; display: inline-block;"
-                }
-                span {
-                    style: "vertical-align: middle;",
+                        class: "status_text",
                         " Disconnected"
                     }
                 }
+            }
         },
         Failed(_) => rsx! {
             div {
-                style: "color: \"{failed_color}\";",
+                class: "connection_status",
+                style: "color: {failed_color};",
+                div {
                     span {
                         class: "material-symbols-outlined",
-                    style: "vertical-align: middle;",
                         "error"
                     }
                     span {
-                    style: "width: 5px; display: inline-block;"
-                }
-                span {
-                    style: "vertical-align: middle;",
+                        class: "status_text",
                         " Failed"
                     }
                 }
+            }
         },
     };
 
@@ -445,16 +445,17 @@ pub fn ControlView(config: Resource<ClientConfig>) -> Element {
                 class: "user_edit_button",
                 span {
                     class: "material-symbols-outlined",
-                    style: "color: oklch(0.65 0.2245 28.06); font-size: 45px; font-variation-settings: 'FILL' 1, 'wght' 700, 'GRAD' 0, 'opsz' 48;",
+                    style: "color: oklch(0.65 0.2245 28.06);",
                     "person_edit"
                 }
             }
             div {
+                class: "user_info",
                 div {
-                    span { style: "font-size: 25px;", "{name}" }
+                    span { class: "user_name", "{name}" }
                 }
                 div {
-                    span { style: "font-size: 20px; color: gray;", "some data" }
+                    span { class: "user_data", "some data" }
                 }
             }
             span { class: "spacer" }
@@ -476,15 +477,15 @@ pub fn ControlView(config: Resource<ClientConfig>) -> Element {
                 }
             }
             button {
-                class: match mute || self_mute {
+                class: match mute || suppress || self_mute {
                     true => "toggle_button is_on",
                     false => "toggle_button",
                 },
                 role: "switch",
-                aria_checked: mute || self_mute,
-                disabled: mute,
+                aria_checked: mute || suppress || self_mute,
+                disabled: mute || suppress,
                 onclick: move |_| net.send(SetMute { mute: !self_mute }),
-                match mute || self_mute {
+                match mute || suppress || self_mute {
                     true => rsx!(span { class: "material-symbols-outlined", "mic_off"}),
                     false => rsx!(span { class: "material-symbols-outlined", "mic"}),
                 }
@@ -545,38 +546,20 @@ pub fn ServerView(config: Resource<ClientConfig>) -> Element {
     )
 }
 
-async fn get_status(
-    client: &reqwest::Client,
-    status_url: &str,
-) -> color_eyre::Result<ServerStatus> {
-    Ok(client
-        .get(status_url)
-        .send()
-        .await?
-        .json::<ServerStatus>()
-        .await?)
-}
-
 #[component]
 pub fn LoginView(config: Resource<ClientConfig>) -> Element {
     let net: Coroutine<Command> = use_coroutine_handle();
 
     let last_status = use_signal(|| None::<color_eyre::Result<ServerStatus>>);
     use_resource(move || async move {
-        let Some(config) = config.read().clone() else {
-            return;
-        };
-        let Some(status_url) = config.status_url else {
-            return;
-        };
         let client = reqwest::Client::new();
         loop {
-            *last_status.write_unchecked() = Some(get_status(&client, &status_url).await);
+            *last_status.write_unchecked() = Some(imp::get_status(&client).await);
             imp::sleep(std::time::Duration::from_secs_f32(1.0)).await;
         }
     });
 
-    let mut address_input = use_signal(|| None::<String>);
+    let mut address_input = use_signal(|| imp::load_server_url());
     let address = use_memo(move || {
         if let Some(addr) = address_input() {
             addr.clone()
@@ -593,6 +576,9 @@ pub fn LoginView(config: Resource<ClientConfig>) -> Element {
     let do_connect = move |_| {
         //let _ = set_default_username(&username.read());
         let _ = imp::set_default_username(&username.read());
+        if config.read().as_ref().is_some_and(|cfg| cfg.any_server) {
+            imp::set_default_server(&address.read());
+        }
         net.send(Connect {
             address: address.read().clone(),
             username: username.read().clone(),
@@ -630,11 +616,16 @@ pub fn LoginView(config: Resource<ClientConfig>) -> Element {
         ),
         Connected => unreachable!(),
     };
+    let version = option_env!("MUMBLE_WEB2_VERSION");
     rsx!(
         div {
             class: "login",
             h1 {
                 "Mumble Web"
+                match version {
+                    Some(v) => rsx!(" " span { class: "login_version", "({v})" }),
+                    None => rsx!(),
+                }
             }
             if config.read().as_ref().is_some_and(|cfg| cfg.any_server) {
                 div {
@@ -739,6 +730,8 @@ pub fn app() -> Element {
         }
     });
 
+    imp::request_permissions();
+
     rsx!(
         document::Link{ rel: "stylesheet", href: "https://fonts.googleapis.com/css2?family=Nunito:ital,wght@0,200..1000;1,200..1000&display=swap" }
         document::Link{ rel: "stylesheet", href: "https://fonts.googleapis.com/css2?family=Material+Symbols+Outlined:opsz,wght,FILL,GRAD@20..48,100..700,0..1,-50..200" }

gui/src/effects.rs

@@ -10,6 +10,21 @@ use tracing::{error, info};
 use crate::imp;
 
 static DF_MODEL: Asset = asset!("/assets/DeepFilterNet3_ll_onnx.tar.gz");
+// TODO: make this user configurable.
+static DEFAULT_NOISE_FLOOR: f32 = 0.001;
+// 200ms hold at 48kHz sample rate
+static HOLD_SAMPLES_MAX: usize = 48000 / 5; // 9600 samples = 200ms
+
+/// Indicates the transmission state after processing audio.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TransmitState {
+    /// Audio is above threshold, or below but within hold period - transmit normally
+    Transmitting,
+    /// Hold period expired - send this frame as terminator (end_bit = true)
+    Terminator,
+    /// Silent and not transmitting - don't send anything
+    Silent,
+}
 
 enum DenoisingModelState {
     Nothing,
@@ -76,6 +91,11 @@ pub struct AudioProcessor {
     denoise: bool,
     spawn: imp::SpawnHandle,
     buffer: Vec<f32>,
+    noise_floor: f32,
+    /// Whether we were transmitting in the previous frame
+    was_transmitting: bool,
+    /// Number of samples we've been below threshold (for hold period)
+    hold_samples: usize,
 }
 
 impl AudioProcessor {
@@ -84,6 +104,9 @@ impl AudioProcessor {
             denoise: false,
             spawn: imp::SpawnHandle::current(),
             buffer: Vec::new(),
+            noise_floor: DEFAULT_NOISE_FLOOR,
+            was_transmitting: false,
+            hold_samples: 0,
         }
     }
 
@@ -92,18 +115,21 @@ impl AudioProcessor {
             denoise: true,
             spawn: imp::SpawnHandle::current(),
             buffer: Vec::new(),
+            noise_floor: DEFAULT_NOISE_FLOOR,
+            was_transmitting: false,
+            hold_samples: 0,
         }
     }
 }
 
 impl AudioProcessor {
-    pub fn process(&mut self, audio: &[f32], output: &mut Vec<f32>) {
+    pub fn process(&mut self, audio: &[f32], channels: usize, output: &mut Vec<f32>) -> TransmitState {
         let mut include_raw = true;
         if self.denoise {
             with_denoising_model(&self.spawn, |df| {
                 include_raw = false;
 
-                self.buffer.extend_from_slice(audio);
+                self.buffer.extend(audio.iter().step_by(channels).copied());
                 output.reserve(audio.len());
 
                 let hop = df.hop_size;
@@ -130,8 +156,40 @@ impl AudioProcessor {
         }
 
         if include_raw {
-            output.extend_from_slice(audio);
+            output.extend(audio.iter().step_by(channels).copied());
         }
+
+        // Calculate average amplitude for VAD
+        let avg: f32 = if output.is_empty() {
+            0.0
+        } else {
+            output.iter().map(|x| x.abs()).sum::<f32>() / output.len() as f32
+        };
+
+        let above_threshold = avg >= self.noise_floor;
+        let samples_in_frame = output.len();
+
+        let state = if above_threshold {
+            // Above threshold - reset hold counter and transmit
+            self.hold_samples = 0;
+            self.was_transmitting = true;
+            TransmitState::Transmitting
+        } else if self.was_transmitting && self.hold_samples < HOLD_SAMPLES_MAX {
+            // Below threshold but in hold period - keep transmitting
+            self.hold_samples += samples_in_frame;
+            TransmitState::Transmitting
+        } else if self.was_transmitting {
+            // Hold period expired - send terminator
+            self.was_transmitting = false;
+            self.hold_samples = 0;
+            TransmitState::Terminator
+        } else {
+            // Not transmitting and below threshold - stay silent
+            output.clear(); // Don't accumulate stale audio during silence
+            TransmitState::Silent
+        };
+
+        state
     }
 }
 

gui/src/imp/connect.rs

@@ -0,0 +1,110 @@
+use crate::app::Command;
+use color_eyre::eyre::{bail, Error};
+use dioxus::hooks::UnboundedReceiver;
+use mumble_protocol::control::ClientControlCodec;
+use std::net::ToSocketAddrs;
+use std::sync::Arc;
+use tokio::net::TcpStream;
+use tokio_rustls::rustls;
+use tokio_rustls::rustls::client::danger::{HandshakeSignatureValid, ServerCertVerifier};
+use tokio_rustls::rustls::pki_types::{CertificateDer, ServerName, UnixTime};
+use tokio_rustls::rustls::ClientConfig as RlsClientConfig;
+use tokio_rustls::rustls::DigitallySignedStruct;
+use tokio_rustls::TlsConnector;
+use tokio_util::compat::{TokioAsyncReadCompatExt as _, TokioAsyncWriteCompatExt as _};
+use tracing::{info, instrument};
+
+use mumble_web2_common::{ClientConfig, ServerStatus};
+
+#[derive(Debug)]
+struct NoCertificateVerification;
+
+impl ServerCertVerifier for NoCertificateVerification {
+    fn verify_server_cert(
+        &self,
+        _end_entity: &CertificateDer<'_>,
+        _intermediates: &[CertificateDer<'_>],
+        _server_name: &ServerName<'_>,
+        _ocsp: &[u8],
+        _now: UnixTime,
+    ) -> Result<rustls::client::danger::ServerCertVerified, rustls::Error> {
+        Ok(rustls::client::danger::ServerCertVerified::assertion())
+    }
+
+    fn verify_tls12_signature(
+        &self,
+        _message: &[u8],
+        _cert: &CertificateDer<'_>,
+        _dss: &DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, rustls::Error> {
+        Ok(HandshakeSignatureValid::assertion())
+    }
+
+    fn verify_tls13_signature(
+        &self,
+        _message: &[u8],
+        _cert: &CertificateDer<'_>,
+        _dss: &DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, rustls::Error> {
+        Ok(HandshakeSignatureValid::assertion())
+    }
+
+    fn supported_verify_schemes(&self) -> Vec<rustls::SignatureScheme> {
+        vec![
+            rustls::SignatureScheme::RSA_PKCS1_SHA1,
+            rustls::SignatureScheme::ECDSA_SHA1_Legacy,
+            rustls::SignatureScheme::RSA_PKCS1_SHA256,
+            rustls::SignatureScheme::ECDSA_NISTP256_SHA256,
+            rustls::SignatureScheme::RSA_PKCS1_SHA384,
+            rustls::SignatureScheme::ECDSA_NISTP384_SHA384,
+            rustls::SignatureScheme::RSA_PKCS1_SHA512,
+            rustls::SignatureScheme::ECDSA_NISTP521_SHA512,
+            rustls::SignatureScheme::RSA_PSS_SHA256,
+            rustls::SignatureScheme::RSA_PSS_SHA384,
+            rustls::SignatureScheme::RSA_PSS_SHA512,
+            rustls::SignatureScheme::ED25519,
+            rustls::SignatureScheme::ED448,
+        ]
+    }
+}
+
+#[instrument]
+pub async fn network_connect(
+    address: String,
+    username: String,
+    event_rx: &mut UnboundedReceiver<Command>,
+    gui_config: &ClientConfig,
+) -> Result<(), Error> {
+    info!("connecting");
+
+    let config = RlsClientConfig::builder()
+        .dangerous()
+        .with_custom_certificate_verifier(Arc::new(NoCertificateVerification))
+        .with_no_client_auth();
+
+    let connector = TlsConnector::from(Arc::new(config));
+
+    let addr = format!("{}:{}", address, 64738)
+        .to_socket_addrs()?
+        .next()
+        .unwrap();
+
+    let server_tcp = TcpStream::connect(addr).await?;
+    let server_stream = connector
+        //.connect("127.0.0.1".try_into()?, server_tcp)
+        .connect(address.try_into()?, server_tcp)
+        .await?;
+    let (read_server, write_server) = tokio::io::split(server_stream);
+
+    let read_codec = ClientControlCodec::new();
+    let write_codec = ClientControlCodec::new();
+
+    let reader = asynchronous_codec::FramedRead::new(read_server.compat(), read_codec);
+    let writer = asynchronous_codec::FramedWrite::new(write_server.compat_write(), write_codec);
+
+    crate::network_loop(username, event_rx, reader, writer).await
+}
+
+pub async fn get_status(client: &reqwest::Client) -> color_eyre::Result<ServerStatus> {
+    bail!("status not supported on desktop yet")
+}

gui/src/imp/desktop.rs

@@ -1,297 +1,66 @@
-use crate::app::Command;
-use crate::effects::{AudioProcessor, AudioProcessorSender};
-use color_eyre::eyre::{eyre, Context, Error};
-use cpal::traits::{DeviceTrait, HostTrait};
-use dioxus::hooks::UnboundedReceiver;
-use futures::io::{AsyncRead, AsyncWrite};
-use mumble_protocol::control::ClientControlCodec;
+use etcetera::{choose_app_strategy, AppStrategy, AppStrategyArgs};
 use mumble_web2_common::ClientConfig;
-use std::mem::replace;
-use std::net::ToSocketAddrs;
-use std::sync::Arc;
-use std::sync::Mutex;
-use tokio::net::TcpStream;
-use tokio_rustls::rustls;
-use tokio_rustls::rustls::client::danger::{HandshakeSignatureValid, ServerCertVerifier};
-use tokio_rustls::rustls::pki_types::{CertificateDer, ServerName, UnixTime};
-use tokio_rustls::rustls::ClientConfig as RlsClientConfig;
-use tokio_rustls::rustls::DigitallySignedStruct;
-use tokio_rustls::TlsConnector;
-use tokio_util::compat::{TokioAsyncReadCompatExt as _, TokioAsyncWriteCompatExt as _};
-use tracing::{error, info, instrument, warn};
-
+use std::collections::HashMap;
 pub use tokio::runtime::Handle as SpawnHandle;
 pub use tokio::task::spawn;
 pub use tokio::time::sleep;
 
-pub trait ImpRead: AsyncRead + Unpin + Send + 'static {}
-impl<T: AsyncRead + Unpin + Send + 'static> ImpRead for T {}
+pub use super::connect::*;
+pub use super::native_audio::*;
 
-pub trait ImpWrite: AsyncWrite + Unpin + Send + 'static {}
-impl<T: AsyncWrite + Unpin + Send + 'static> ImpWrite for T {}
-
-pub struct AudioSystem {
-    output: cpal::Device,
-    input: cpal::Device,
-    processors: AudioProcessorSender,
-    recording_stream: Option<cpal::Stream>,
-}
-
-const SAMPLE_RATE: u32 = 48_000;
-const PACKET_SAMPLES: u32 = 960;
-
-type Buffer = Arc<Mutex<dasp_ring_buffer::Bounded<Vec<i16>>>>;
-
-impl AudioSystem {
-    pub fn new() -> Result<Self, Error> {
-        // TODO
-        let host = cpal::default_host();
-        let name = host.id();
-        let processors = AudioProcessorSender::default();
-        Ok(AudioSystem {
-            output: host
-                .default_output_device()
-                .ok_or(eyre!("no output devices from {name:?}"))?,
-            input: host
-                .default_input_device()
-                .ok_or(eyre!("no input devices from {name:?}"))?,
-            processors,
-            recording_stream: None,
+fn get_config_path() -> std::path::PathBuf {
+    let strategy = choose_app_strategy(AppStrategyArgs {
+        top_level_domain: "com".to_string(),
+        author: "Ohea Corp".to_string(),
+        app_name: "Mumble Web2".to_string(),
     })
+    .expect("failed to choose app strategy");
+    strategy.config_dir().join("config.json")
 }
 
-    pub fn set_processor(&self, processor: AudioProcessor) {
-        self.processors.store(Some(processor))
+fn load_config_map() -> HashMap<String, String> {
+    let config_path = get_config_path();
+    match std::fs::read_to_string(&config_path) {
+        Ok(contents) => serde_json::from_str(&contents).unwrap_or_default(),
+        Err(_) => HashMap::new(),
+    }
 }
 
-    pub fn start_recording(
-        &mut self,
-        mut each: impl FnMut(Vec<u8>) + Send + 'static,
-    ) -> Result<(), Error> {
-        let mut encoder =
-            opus::Encoder::new(SAMPLE_RATE, opus::Channels::Mono, opus::Application::Voip)?;
-        let mut current_processor = AudioProcessor::new_plain();
-        let mut output_buffer = Vec::new();
-        let processors = self.processors.clone();
-        let error_callback = move |e: cpal::StreamError| error!("error recording: {e:?}");
-        let data_callback = move |frame: &[f32], _: &cpal::InputCallbackInfo| {
-            if let Some(new_processor) = processors.take() {
-                current_processor = new_processor;
+fn save_config_map(config: &HashMap<String, String>) -> color_eyre::Result<()> {
+    let config_path = get_config_path();
+    if let Some(parent) = config_path.parent() {
+        std::fs::create_dir_all(parent)?;
     }
-            current_processor.process(frame, &mut output_buffer);
-            if output_buffer.len() < PACKET_SAMPLES as usize {
-                return;
-            }
-            let remainder = output_buffer.split_off(PACKET_SAMPLES as usize);
-            let frame = replace(&mut output_buffer, remainder);
-            match encoder.encode_vec_float(&frame, frame.len() * 2) {
-                Ok(buf) => {
-                    each(buf);
-                }
-                Err(e) => {
-                    error!("error encoding {} samples: {e:?}", frame.len());
-                }
-            }
-        };
-
-        match self.input.build_input_stream(
-            &cpal::StreamConfig {
-                channels: 1,
-                sample_rate: cpal::SampleRate(SAMPLE_RATE),
-                buffer_size: cpal::BufferSize::Fixed(PACKET_SAMPLES),
-            },
-            data_callback,
-            error_callback,
-            None,
-        ) {
-            Ok(stream) => {
-                self.recording_stream = Some(stream);
+    let contents = serde_json::to_string_pretty(config)?;
+    std::fs::write(&config_path, contents)?;
     Ok(())
 }
-            Err(err) => {
-                self.recording_stream = None;
-                Err(err.into())
-            }
-        }
-    }
-
-    pub fn create_player(&mut self) -> Result<AudioPlayer, Error> {
-        let buffer = Arc::new(Mutex::new(dasp_ring_buffer::Bounded::from_raw_parts(
-            0,
-            0,
-            vec![
-            0;
-            SAMPLE_RATE as usize/4 // 250ms of buffer
-        ],
-        )));
-        let decoder = opus::Decoder::new(SAMPLE_RATE, opus::Channels::Mono)?;
-        let stream = {
-            let buffer = buffer.clone();
-            self.output.build_output_stream(
-                &cpal::StreamConfig {
-                    channels: 1,
-                    sample_rate: cpal::SampleRate(SAMPLE_RATE),
-                    buffer_size: cpal::BufferSize::Fixed(480), // 10ms playback delay
-                },
-                move |frame, info| {
-                    let mut buffer = buffer.lock().unwrap();
-                    for x in frame.iter_mut() {
-                        match buffer.pop() {
-                            Some(y) => {
-                                *x = y;
-                            }
-                            None => {
-                                *x = 0;
-                            }
-                        }
-                    }
-                },
-                move |err| error!("could not create output stream {err:?}"),
-                None,
-            )?
-        };
-        Ok(AudioPlayer {
-            decoder,
-            stream,
-            buffer,
-            tmp: vec![0; 2400],
-        })
-    }
-}
-
-pub struct AudioPlayer {
-    decoder: opus::Decoder,
-    stream: cpal::Stream,
-    buffer: Buffer,
-    tmp: Vec<i16>,
-}
-
-impl AudioPlayer {
-    pub fn play_opus(&mut self, payload: &[u8]) {
-        let len = loop {
-            match self.decoder.decode(payload, &mut self.tmp, false) {
-                Ok(l) => break l,
-                Err(e) => {
-                    error!("opus decode error {e:?}");
-                    return;
-                }
-            }
-        };
-
-        let mut buffer = self.buffer.lock().unwrap();
-        let mut overrun = 0;
-        for x in &self.tmp[..len] {
-            if let Some(_) = buffer.push(*x) {
-                overrun += 1;
-            }
-        }
-        if overrun > 0 {
-            warn!("playback overrun by {overrun} samples");
-        }
-    }
-}
-
-#[derive(Debug)]
-struct NoCertificateVerification;
-
-impl ServerCertVerifier for NoCertificateVerification {
-    fn verify_server_cert(
-        &self,
-        _end_entity: &CertificateDer<'_>,
-        _intermediates: &[CertificateDer<'_>],
-        _server_name: &ServerName<'_>,
-        _ocsp: &[u8],
-        _now: UnixTime,
-    ) -> Result<rustls::client::danger::ServerCertVerified, rustls::Error> {
-        Ok(rustls::client::danger::ServerCertVerified::assertion())
-    }
-
-    fn verify_tls12_signature(
-        &self,
-        _message: &[u8],
-        _cert: &CertificateDer<'_>,
-        _dss: &DigitallySignedStruct,
-    ) -> Result<HandshakeSignatureValid, rustls::Error> {
-        Ok(HandshakeSignatureValid::assertion())
-    }
-
-    fn verify_tls13_signature(
-        &self,
-        _message: &[u8],
-        _cert: &CertificateDer<'_>,
-        _dss: &DigitallySignedStruct,
-    ) -> Result<HandshakeSignatureValid, rustls::Error> {
-        Ok(HandshakeSignatureValid::assertion())
-    }
-
-    fn supported_verify_schemes(&self) -> Vec<rustls::SignatureScheme> {
-        vec![
-            rustls::SignatureScheme::RSA_PKCS1_SHA1,
-            rustls::SignatureScheme::ECDSA_SHA1_Legacy,
-            rustls::SignatureScheme::RSA_PKCS1_SHA256,
-            rustls::SignatureScheme::ECDSA_NISTP256_SHA256,
-            rustls::SignatureScheme::RSA_PKCS1_SHA384,
-            rustls::SignatureScheme::ECDSA_NISTP384_SHA384,
-            rustls::SignatureScheme::RSA_PKCS1_SHA512,
-            rustls::SignatureScheme::ECDSA_NISTP521_SHA512,
-            rustls::SignatureScheme::RSA_PSS_SHA256,
-            rustls::SignatureScheme::RSA_PSS_SHA384,
-            rustls::SignatureScheme::RSA_PSS_SHA512,
-            rustls::SignatureScheme::ED25519,
-            rustls::SignatureScheme::ED448,
-        ]
-    }
-}
-
-#[instrument]
-pub async fn network_connect(
-    address: String,
-    username: String,
-    event_rx: &mut UnboundedReceiver<Command>,
-    gui_config: &ClientConfig,
-) -> Result<(), Error> {
-    info!("connecting");
-
-    let config = RlsClientConfig::builder()
-        .dangerous()
-        .with_custom_certificate_verifier(Arc::new(NoCertificateVerification))
-        .with_no_client_auth();
-
-    let connector = TlsConnector::from(Arc::new(config));
-
-    let addr = format!("{}:{}", address, 64738)
-        .to_socket_addrs()?
-        .next()
-        .unwrap();
-
-    let server_tcp = TcpStream::connect(addr).await?;
-    let server_stream = connector
-        //.connect("127.0.0.1".try_into()?, server_tcp)
-        .connect(address.try_into()?, server_tcp)
-        .await?;
-    let (read_server, write_server) = tokio::io::split(server_stream);
-
-    let read_codec = ClientControlCodec::new();
-    let write_codec = ClientControlCodec::new();
-
-    let reader = asynchronous_codec::FramedRead::new(read_server.compat(), read_codec);
-    let writer = asynchronous_codec::FramedWrite::new(write_server.compat_write(), write_codec);
-
-    crate::network_loop(username, event_rx, reader, writer).await
-}
 
 pub fn set_default_username(username: &str) -> Option<()> {
-    None
+    let mut config = load_config_map();
+    config.insert("username".to_string(), username.to_string());
+    save_config_map(&config).ok()
+}
+
+pub fn set_default_server(server: &str) -> Option<()> {
+    let mut config = load_config_map();
+    config.insert("server".to_string(), server.to_string());
+    save_config_map(&config).ok()
 }
 
 pub fn load_username() -> Option<String> {
-    return None;
+    let config = load_config_map();
+    config.get("username").cloned()
+}
+
+pub fn load_server_url() -> Option<String> {
+    let config = load_config_map();
+    config.get("server").cloned()
 }
 
 pub async fn load_config() -> color_eyre::Result<ClientConfig> {
     Ok(ClientConfig {
         proxy_url: None,
-        status_url: None,
         cert_hash: None,
         any_server: true,
     })

gui/src/imp/mobile.rs

@@ -0,0 +1,67 @@
+use android_permissions::{PermissionManager, RECORD_AUDIO};
+use jni::{objects::JObject, JavaVM};
+use mumble_web2_common::ClientConfig;
+
+use std::collections::HashMap;
+pub use tokio::runtime::Handle as SpawnHandle;
+pub use tokio::task::spawn;
+pub use tokio::time::sleep;
+
+pub use super::connect::*;
+pub use super::native_audio::*;
+
+pub fn set_default_username(username: &str) -> Option<()> {
+    None
+}
+
+pub fn set_default_server(server: &str) -> Option<()> {
+    None
+}
+
+pub fn load_username() -> Option<String> {
+    None
+}
+
+pub fn load_server_url() -> Option<String> {
+    None
+}
+
+pub async fn load_config() -> color_eyre::Result<ClientConfig> {
+    Ok(ClientConfig {
+        proxy_url: None,
+        cert_hash: None,
+        any_server: true,
+    })
+}
+
+pub fn init_logging() {
+    use tracing::level_filters::LevelFilter;
+    use tracing_subscriber::filter::EnvFilter;
+
+    let env_filter = EnvFilter::builder()
+        .with_default_directive(LevelFilter::INFO.into())
+        .from_env_lossy();
+
+    tracing_subscriber::fmt()
+        .with_target(true)
+        .with_level(true)
+        .with_env_filter(env_filter)
+        .init();
+}
+
+#[cfg(feature = "mobile")]
+pub fn request_permissions() {
+    request_recording_permission();
+}
+
+#[cfg(target_os = "android")]
+pub fn request_recording_permission() {
+    let ctx = ndk_context::android_context();
+    let vm = unsafe { JavaVM::from_raw(ctx.vm().cast()).unwrap() };
+    let activity = unsafe { JObject::from_raw(ctx.context().cast()) };
+
+    let manager = PermissionManager::create(vm, activity).unwrap();
+    if !manager.check(&RECORD_AUDIO).unwrap() {
+        manager.request(&[&RECORD_AUDIO]).unwrap();
+    }
+}

gui/src/imp/mod.rs

@@ -1,11 +1,29 @@
 #[cfg(feature = "web")]
 mod web;
 
+#[cfg(any(feature = "desktop", feature = "mobile"))]
+mod connect;
+#[cfg(any(feature = "desktop", feature = "mobile"))]
+mod native_audio;
+
 #[cfg(feature = "desktop")]
 mod desktop;
-
-#[cfg(all(feature = "web", not(feature = "desktop")))]
-pub use web::*;
+#[cfg(feature = "mobile")]
+mod mobile;
 
 #[cfg(feature = "desktop")]
 pub use desktop::*;
+#[cfg(feature = "mobile")]
+pub use mobile::*;
+
+#[cfg(feature = "mobile")]
+pub use mobile::request_permissions;
+
+#[cfg(any(feature = "desktop", feature = "web"))]
+pub fn request_permissions() {}
+
+#[cfg(all(feature = "web", not(any(feature = "desktop", feature = "mobile"))))]
+pub use web::*;
+
+#[cfg(any(feature = "desktop"))]
+pub use desktop::*;

gui/src/imp/native_audio.rs

@@ -0,0 +1,222 @@
+use crate::effects::{AudioProcessor, AudioProcessorSender, TransmitState};
+use color_eyre::eyre::{eyre, Error};
+use cpal::traits::{DeviceTrait, HostTrait, StreamTrait as _};
+use futures::io::{AsyncRead, AsyncWrite};
+use std::mem::replace;
+use std::sync::Arc;
+use std::sync::Mutex;
+use tracing::{error, info, warn};
+
+pub trait ImpRead: AsyncRead + Unpin + Send + 'static {}
+impl<T: AsyncRead + Unpin + Send + 'static> ImpRead for T {}
+
+pub trait ImpWrite: AsyncWrite + Unpin + Send + 'static {}
+impl<T: AsyncWrite + Unpin + Send + 'static> ImpWrite for T {}
+
+pub struct AudioSystem {
+    output: cpal::Device,
+    input: cpal::Device,
+    processors: AudioProcessorSender,
+    recording_stream: Option<cpal::Stream>,
+}
+
+const SAMPLE_RATE: u32 = 48_000;
+const PACKET_SAMPLES: u32 = 960;
+
+fn encode_and_send(
+    state: TransmitState,
+    output_buffer: &mut Vec<f32>,
+    encoder: &mut opus::Encoder,
+    each: &mut impl FnMut(Vec<u8>, bool),
+) {
+    let (is_terminator, should_encode) = match state {
+        TransmitState::Silent => return,
+        TransmitState::Transmitting => (false, output_buffer.len() >= PACKET_SAMPLES as usize),
+        TransmitState::Terminator => {
+            output_buffer.resize(PACKET_SAMPLES as usize, 0.0);
+            (true, true)
+        }
+    };
+
+    if should_encode {
+        let remainder = output_buffer.split_off(PACKET_SAMPLES as usize);
+        let frame = replace(output_buffer, remainder);
+        match encoder.encode_vec_float(&frame, frame.len() * 2) {
+            Ok(encoded) => each(encoded, is_terminator),
+            Err(e) => error!("error encoding {} samples: {e:?}", frame.len()),
+        }
+    }
+}
+
+type Buffer = Arc<Mutex<dasp_ring_buffer::Bounded<Vec<i16>>>>;
+
+impl AudioSystem {
+    pub async fn new() -> Result<Self, Error> {
+        // TODO
+        let host = cpal::default_host();
+        let name = host.id();
+        let processors = AudioProcessorSender::default();
+        Ok(AudioSystem {
+            output: host
+                .default_output_device()
+                .ok_or(eyre!("no output devices from {name:?}"))?,
+            input: host
+                .default_input_device()
+                .ok_or(eyre!("no input devices from {name:?}"))?,
+            processors,
+            recording_stream: None,
+        })
+    }
+
+    pub fn set_processor(&self, processor: AudioProcessor) {
+        self.processors.store(Some(processor))
+    }
+
+    fn choose_config(
+        &self,
+        configs: impl Iterator<Item = cpal::SupportedStreamConfigRange>,
+    ) -> Result<cpal::StreamConfig, Error> {
+        let mut supported_configs: Vec<_> = configs
+            .filter_map(|cfg| cfg.try_with_sample_rate(cpal::SampleRate(SAMPLE_RATE)))
+            .filter(|cfg| cfg.sample_format() == cpal::SampleFormat::I16)
+            .map(|cfg| cpal::StreamConfig {
+                buffer_size: cpal::BufferSize::Fixed(match *cfg.buffer_size() {
+                    cpal::SupportedBufferSize::Range { min, max } => 480.clamp(min, max),
+                    cpal::SupportedBufferSize::Unknown => 480,
+                }),
+                ..cfg.config()
+            })
+            .collect();
+        supported_configs.sort_by(|a, b| {
+            let cpal::BufferSize::Fixed(a_buf) = a.buffer_size else {
+                unreachable!()
+            };
+            let cpal::BufferSize::Fixed(b_buf) = b.buffer_size else {
+                unreachable!()
+            };
+            Ord::cmp(&a.channels, &b.channels).then(Ord::cmp(&a_buf, &b_buf))
+        });
+        supported_configs
+            .get(0)
+            .cloned()
+            .ok_or(eyre!("no supported stream configs"))
+    }
+
+    pub fn start_recording(
+        &mut self,
+        mut each: impl FnMut(Vec<u8>, bool) + Send + 'static,
+    ) -> Result<(), Error> {
+        let config = self.choose_config(self.input.supported_input_configs()?)?;
+        info!(
+            "creating recording on {:?} with {:#?}",
+            self.input.name()?,
+            config
+        );
+        let mut encoder =
+            opus::Encoder::new(SAMPLE_RATE, opus::Channels::Mono, opus::Application::Voip)?;
+        let mut current_processor = AudioProcessor::new_plain();
+        let mut output_buffer = Vec::new();
+        let processors = self.processors.clone();
+        let error_callback = move |e: cpal::StreamError| error!("error recording: {e:?}");
+        let data_callback = move |frame: &[f32], _: &cpal::InputCallbackInfo| {
+            if let Some(new_processor) = processors.take() {
+                current_processor = new_processor;
+            }
+            let state = current_processor.process(frame, config.channels as usize, &mut output_buffer);
+            encode_and_send(state, &mut output_buffer, &mut encoder, &mut each);
+        };
+
+        match self
+            .input
+            .build_input_stream(&config, data_callback, error_callback, None)
+        {
+            Ok(stream) => {
+                stream.play()?;
+                self.recording_stream = Some(stream);
+                Ok(())
+            }
+            Err(err) => {
+                self.recording_stream = None;
+                Err(err.into())
+            }
+        }
+    }
+
+    pub fn create_player(&mut self) -> Result<AudioPlayer, Error> {
+        let config = self.choose_config(self.output.supported_output_configs()?)?;
+        info!(
+            "creating player on {:?} with {:#?}",
+            self.output.name().ok(),
+            &config
+        );
+        let buffer = Arc::new(Mutex::new(dasp_ring_buffer::Bounded::from_raw_parts(
+            0,
+            0,
+            vec![
+            0;
+            SAMPLE_RATE as usize/4 // 250ms of buffer
+        ],
+        )));
+        let decoder = opus::Decoder::new(SAMPLE_RATE, opus::Channels::Mono)?;
+        let stream = {
+            let buffer = buffer.clone();
+            self.output.build_output_stream(
+                &config,
+                move |frame, _info| {
+                    let mut buffer = buffer.lock().unwrap();
+                    for x in frame.chunks_mut(config.channels as usize) {
+                        match buffer.pop() {
+                            Some(y) => {
+                                x.fill(y);
+                            }
+                            None => {
+                                x.fill(0);
+                            }
+                        }
+                    }
+                },
+                move |err| error!("could not create output stream {err:?}"),
+                None,
+            )?
+        };
+        stream.play()?;
+        Ok(AudioPlayer {
+            decoder,
+            stream,
+            buffer,
+            tmp: vec![0; 2400],
+        })
+    }
+}
+
+pub struct AudioPlayer {
+    decoder: opus::Decoder,
+    stream: cpal::Stream,
+    buffer: Buffer,
+    tmp: Vec<i16>,
+}
+
+impl AudioPlayer {
+    pub fn play_opus(&mut self, payload: &[u8]) {
+        let len = loop {
+            match self.decoder.decode(payload, &mut self.tmp, false) {
+                Ok(l) => break l,
+                Err(e) => {
+                    error!("opus decode error {e:?}");
+                    return;
+                }
+            }
+        };
+
+        let mut buffer = self.buffer.lock().unwrap();
+        let mut overrun = 0;
+        for x in &self.tmp[..len] {
+            if let Some(_) = buffer.push(*x) {
+                overrun += 1;
+            }
+        }
+        if overrun > 0 {
+            warn!("playback overrun by {overrun} samples");
+        }
+    }
+}

gui/src/imp/web.rs

@@ -1,21 +1,22 @@
 use crate::app::Command;
-use crate::effects::{AudioProcessor, AudioProcessorSender};
+use crate::effects::{AudioProcessor, AudioProcessorSender, TransmitState};
 use color_eyre::eyre::{bail, eyre, Error};
+use crossbeam::atomic::AtomicCell;
 use dioxus::prelude::*;
 use futures::{AsyncRead, AsyncWrite};
 use gloo_timers::future::TimeoutFuture;
 use js_sys::Float32Array;
 use mumble_protocol::control::ClientControlCodec;
-use mumble_web2_common::ClientConfig;
+use mumble_web2_common::{ClientConfig, ServerStatus};
 use reqwest::Url;
 use std::future::Future;
+use std::sync::Arc;
 use std::time::Duration;
 use tracing::level_filters::LevelFilter;
 use tracing::{debug, error, info, instrument};
 use wasm_bindgen::prelude::*;
 use wasm_bindgen_futures::JsFuture;
 use web_sys::js_sys::{Promise, Reflect, Uint8Array};
-use web_sys::AudioContext;
 use web_sys::AudioContextOptions;
 use web_sys::AudioData;
 use web_sys::AudioDecoder;
@@ -30,14 +31,13 @@ use web_sys::EncodedAudioChunkInit;
 use web_sys::EncodedAudioChunkType;
 use web_sys::MediaStream;
 use web_sys::MediaStreamConstraints;
-use web_sys::MediaStreamTrackGenerator;
-use web_sys::MediaStreamTrackGeneratorInit;
 use web_sys::MessageEvent;
 use web_sys::WebTransport;
 use web_sys::WebTransportBidirectionalStream;
 use web_sys::WebTransportOptions;
 use web_sys::WorkletOptions;
 use web_sys::{console, window};
+use web_sys::{AudioContext, AudioDataCopyToOptions};
 
 pub use wasm_bindgen_futures::spawn_local as spawn;
 
@@ -78,12 +78,41 @@ pub struct AudioSystem {
     processors: AudioProcessorSender,
 }
 
+async fn attach_worklet(audio_context: &AudioContext) -> Result<(), Error> {
+    // Create worklets to process mic and speaker audio
+    // Speaker audio processing worklet only required on
+    // browsers that don't support MediaStreamTrackGenerator
+
+    let options = WorkletOptions::new();
+    Reflect::set(
+        &options,
+        &"processorOptions".into(),
+        &wasm_bindgen::module(),
+    )
+    .ey()?;
+
+    let module = asset!("assets/rust_audio_worklet.js").to_string();
+    info!("loading mic worklet from {module:?}");
+    audio_context
+        .audio_worklet()
+        .ey()?
+        .add_module_with_options(&module, &options)
+        .ey()?
+        .into_future()
+        .await
+        .ey()?;
+    Ok(())
+}
+
 impl AudioSystem {
-    pub fn new() -> Result<Self, Error> {
+    pub async fn new() -> Result<Self, Error> {
         // Create MediaStreams to playback decoded audio
         // The audio context is used to reproduce audio.
         let webctx = configure_audio_context();
+        attach_worklet(&webctx).await?;
+
         let processors = AudioProcessorSender::default();
+
         Ok(AudioSystem { webctx, processors })
     }
 
@@ -91,7 +120,10 @@ impl AudioSystem {
         self.processors.store(Some(processor))
     }
 
-    pub fn start_recording(&mut self, each: impl FnMut(Vec<u8>) + 'static) -> Result<(), Error> {
+    pub fn start_recording(
+        &mut self,
+        each: impl FnMut(Vec<u8>, bool) + 'static,
+    ) -> Result<(), Error> {
         let audio_context_worklet = self.webctx.clone();
         let processors = self.processors.clone();
         spawn(async move {
@@ -104,18 +136,10 @@ impl AudioSystem {
     }
 
     pub fn create_player(&mut self) -> Result<AudioPlayer, Error> {
-        let audio_stream_generator =
-            MediaStreamTrackGenerator::new(&MediaStreamTrackGeneratorInit::new("audio")).ey()?;
+        let sink_node = AudioWorkletNode::new(&self.webctx, "rust_speaker_worklet").ey()?;
 
-        // Create MediaStream from MediaStreamTrackGenerator
-        let js_tracks = web_sys::js_sys::Array::new();
-        js_tracks.push(&audio_stream_generator);
-        let media_stream = MediaStream::new_with_tracks(&js_tracks).ey()?;
-
-        // Create MediaStreamAudioSourceNode
-        let audio_source = self.webctx.create_media_stream_source(&media_stream).ey()?;
-        // Connect output of audio_source to audio_context (browser audio)
-        audio_source
+        // Connect worklet to destination
+        sink_node
             .connect_with_audio_node(&self.webctx.destination())
             .ey()?;
 
@@ -124,28 +148,31 @@ impl AudioSystem {
             error!("error decoding audio {:?}", e);
         }) as Box<dyn FnMut(JsValue)>);
 
-        // This knows what MediaStreamTrackGenerator to use as it closes around it
+        let sink_port = sink_node.port().ey()?;
+
         let output = Closure::wrap(Box::new(move |audio_data: AudioData| {
-            let writable = audio_stream_generator.writable();
-            if writable.locked() {
-                return;
-            }
-            if let Err(e) = writable.get_writer().map(|writer| {
-                spawn(async move {
-                    if let Err(e) = JsFuture::from(writer.ready()).await.ey() {
-                        error!("write chunk ready error {:?}", e);
-                    }
-                    if let Err(e) = JsFuture::from(writer.write_with_chunk(&audio_data))
-                        .await
-                        .ey()
+            // Extract planar PCM from AudioData into an ArrayBuffer or Float32Array
+            // Here we assume f32 samples, 1 channel for brevity.
+            let number_of_frames = audio_data.number_of_frames();
+
+            let js_buffer = Float32Array::new_with_length(number_of_frames);
+
+            let audio_data_copy_to_options = &AudioDataCopyToOptions::new(0);
+            audio_data_copy_to_options.set_format(web_sys::AudioSampleFormat::F32);
+
+            if let Err(e) = audio_data
+                .copy_to_with_buffer_source(&js_buffer.buffer(), &audio_data_copy_to_options)
             {
-                        error!("write chunk error {:?}", e);
-                    };
-                    writer.release_lock();
-                });
-            }) {
-                error!("error writing audio data {:?}", e);
+                error!("could not copy audio data to array {:?}", e);
             }
+
+            // Post to the worklet; include sampleRate and channel count if needed.
+            let msg = js_sys::Object::new();
+            js_sys::Reflect::set(&msg, &"samples".into(), &js_buffer).unwrap();
+
+            sink_port.post_message(&msg).unwrap();
+
+            audio_data.close();
         }) as Box<dyn FnMut(AudioData)>);
 
         let audio_decoder = AudioDecoder::new(&AudioDecoderInit::new(
@@ -200,22 +227,26 @@ impl PromiseExt for Promise {
     }
 }
 
-fn process_audio(frame: &JsValue, processor: &mut AudioProcessor) {
+fn process_audio(frame: &JsValue, processor: &mut AudioProcessor) -> TransmitState {
     let Ok(samples) = Reflect::get(&frame, &"data".into()) else {
-        return;
+        return TransmitState::Silent;
     };
     let Ok(samples) = samples.dyn_into::<Float32Array>() else {
-        return;
+        return TransmitState::Silent;
     };
     let input = samples.to_vec();
     let mut output = Vec::with_capacity(input.len());
-    processor.process(&input, &mut output);
+    let state = processor.process(&input, 1, &mut output);
+    if !output.is_empty() {
         samples.copy_from(&output);
     }
 
+    state
+}
+
 async fn run_encoder_worklet(
     audio_context: &AudioContext,
-    mut each: impl FnMut(Vec<u8>) + 'static,
+    mut each: impl FnMut(Vec<u8>, bool) + 'static,
     processors: AudioProcessorSender,
 ) -> Result<AudioWorkletNode, Error> {
     let constraints = MediaStreamConstraints::new();
@@ -234,37 +265,25 @@ async fn run_encoder_worklet(
         .map_err(|e| JsError::new(&format!("not a stream: {e:?}")))
         .ey()?;
 
-    let options = WorkletOptions::new();
-    Reflect::set(
-        &options,
-        &"processorOptions".into(),
-        &wasm_bindgen::module(),
-    )
-    .ey()?;
-
-    let module = asset!("assets/rust_mic_worklet.js").to_string();
-    info!("loading mic worklet from {module:?}");
-    audio_context
-        .audio_worklet()
-        .ey()?
-        .add_module_with_options(&module, &options)
-        .ey()?
-        .into_future()
-        .await
-        .ey()?;
-
     let source = audio_context.create_media_stream_source(&stream).ey()?;
     let worklet_node = AudioWorkletNode::new(audio_context, "rust_mic_worklet").ey()?;
 
     let encoder_error: Closure<dyn FnMut(JsValue)> =
         Closure::new(|e| error!("error encoding audio {:?}", e));
 
+    // Shared state to signal terminator between onmessage and output closures
+    // The output closure runs asynchronously after encoding completes
+    let pending_terminator = Arc::new(AtomicCell::new(false));
+    let pending_terminator_output = pending_terminator.clone();
+
     // This knows what MediaStreamTrackGenerator to use as it closes around it
     let output: Closure<dyn FnMut(EncodedAudioChunk)> =
         Closure::new(move |audio_data: EncodedAudioChunk| {
             let mut array = vec![0u8; audio_data.byte_length() as usize];
             audio_data.copy_to_with_u8_slice(&mut array);
-            each(array);
+            // Check if this frame was marked as a terminator
+            let is_terminator = pending_terminator_output.swap(false);
+            each(array, is_terminator);
         });
 
     let audio_encoder = AudioEncoder::new(&AudioEncoderInit::new(
@@ -291,8 +310,19 @@ async fn run_encoder_worklet(
         }
 
         let frame = event.data();
-        process_audio(&frame, &mut current_processor);
+        let state = process_audio(&frame, &mut current_processor);
 
+        match state {
+            TransmitState::Silent => {
+                // Don't encode or send anything
+                return;
+            }
+            TransmitState::Transmitting => (), // Normal transmission
+            TransmitState::Terminator => {
+                // Mark this as a terminator before encoding
+                pending_terminator.store(true);
+            }
+        }
         match AudioData::new(frame.unchecked_ref()) {
             Ok(data) => {
                 let _ = audio_encoder.encode(&data);
@@ -396,6 +426,10 @@ pub fn set_default_username(username: &str) -> Option<()> {
         .ok()
 }
 
+pub fn set_default_server(username: &str) -> Option<()> {
+    None
+}
+
 pub fn load_username() -> Option<String> {
     web_sys::window()
         .unwrap()
@@ -405,6 +439,10 @@ pub fn load_username() -> Option<String> {
         .ok()?
 }
 
+pub fn load_server_url() -> Option<String> {
+    None
+}
+
 pub fn absolute_url(path: &str) -> Result<Url, Error> {
     let window: web_sys::Window = web_sys::window().expect("no global `window` exists");
     let location = window.location();
@@ -426,6 +464,15 @@ pub async fn load_config() -> color_eyre::Result<ClientConfig> {
     Ok(config)
 }
 
+pub async fn get_status(client: &reqwest::Client) -> color_eyre::Result<ServerStatus> {
+    Ok(client
+        .get(absolute_url("status")?)
+        .send()
+        .await?
+        .json::<ServerStatus>()
+        .await?)
+}
+
 pub fn init_logging() {
     // copied from tracing_web example usage
 

gui/src/lib.rs

@@ -20,12 +20,9 @@ use mumble_protocol::voice::VoicePacket;
 use mumble_protocol::voice::VoicePacketPayload;
 use mumble_protocol::Clientbound;
 use mumble_protocol::Serverbound;
-use mumble_web2_common::ClientConfig;
-use once_cell::sync::Lazy;
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
 use std::time::Duration;
-use tracing::debug;
 use tracing::error;
 use tracing::info;
 
@@ -113,18 +110,18 @@ pub async fn network_loop<R: imp::ImpRead, W: imp::ImpWrite>(
         });
     }
 
-    let mut audio = imp::AudioSystem::new()?;
+    let mut audio = imp::AudioSystem::new().await?;
     {
         let send_chan = send_chan.clone();
         let mut sequence_num = 0;
-        audio.start_recording(move |opus_frame| {
+        audio.start_recording(move |opus_frame, is_terminator| {
             let _ =
                 send_chan.unbounded_send(ControlPacket::UDPTunnel(Box::new(VoicePacket::Audio {
                     _dst: std::marker::PhantomData,
                     target: 0,
                     session_id: (),
                     seq_num: sequence_num,
-                    payload: VoicePacketPayload::Opus(opus_frame.into(), false),
+                    payload: VoicePacketPayload::Opus(opus_frame.into(), is_terminator),
                     position_info: None,
                 })));
             sequence_num = sequence_num.wrapping_add(2);
@@ -407,6 +404,9 @@ fn accept_packet(
             if u.has_deaf() {
                 state.deaf = u.get_deaf();
             }
+            if u.has_suppress() {
+                state.suppress = u.get_suppress();
+            }
             if u.has_self_mute() {
                 state.self_mute = u.get_self_mute();
             }

proxy/src/main.rs

@@ -1,10 +1,6 @@
 use color_eyre::eyre::{anyhow, bail, Context, Result};
-use color_eyre::owo_colors::OwoColorize;
 use mumble_web2_common::{ClientConfig, ServerStatus};
-use once_cell::sync::OnceCell;
 use rand::Rng;
-use rcgen::date_time_ymd;
-use rustls::server;
 use salvo::conn::rustls::{Keycert, RustlsConfig};
 use salvo::cors::{AllowOrigin, Cors};
 use salvo::logging::Logger;
@@ -38,7 +34,6 @@ fn default_cert_alt_names() -> Vec<String> {
 
 #[derive(Debug, Deserialize, Serialize)]
 struct Config {
-    public_url: Url,
     proxy_url: Option<Url>,
     https_listen_address: SocketAddr,
     http_listen_address: Option<SocketAddr>,
@@ -85,9 +80,8 @@ async fn main() -> Result<()> {
     let mut client_config = ClientConfig {
         proxy_url: match &server_config.proxy_url {
             Some(url) => Some(url.to_string()),
-            None => Some(server_config.public_url.join("proxy")?.to_string()),
+            None => None,
         },
-        status_url: Some(server_config.public_url.join("status")?.to_string()),
         cert_hash: None,
         any_server: false,
     };
@@ -341,19 +335,13 @@ async fn connect_proxy_impl(
 
     info!("connected to Mumble server");
 
-    // Spawn tasks to handle transmitting data between the WebTransport client and Mumble TCP Server
-    let c2s = tokio::spawn(
-        pass_bytes_loop(incoming, write_server)
-            .instrument(info_span!("Handler", "Client to server")),
-    );
-    let s2c = tokio::spawn(
-        pass_bytes_loop(read_server, outgoing)
-            .instrument(info_span!("Handler", "Server to client")),
-    );
-
+    // Handle transmitting data between the WebTransport client and Mumble TCP Server
+    // When one direction completes/fails, the other is dropped and its streams are closed
     tokio::select! {
-        res = c2s => res??,
-        res = s2c => res??,
+        res = pass_bytes_loop(incoming, write_server)
+            .instrument(info_span!("Handler", "Client to server")) => res?,
+        res = pass_bytes_loop(read_server, outgoing)
+            .instrument(info_span!("Handler", "Server to client")) => res?,
     };
     Ok(())
 }