Add some Trait doc comments

Added comments to Audio(System|Player)Interface traits.

.dockerignore

@@ -1 +0,0 @@
-target

.gitea/workflows/build-release.yaml

@@ -42,47 +42,6 @@ jobs:
           path: target/release/mumble-web2-proxy
           retention-days: 5
 
-  macos_build:
-    runs-on: macos
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Restore Rust cache
-        uses: actions/cache/restore@v4
-        with:
-          path: |
-            ~/.cargo
-            ./target
-          key: rust-${{ runner.os }}-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            rust-${{ runner.os }}-
-
-      - name: 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
-
-      - name: Install dioxus-cli
-        run: cargo binstall dioxus-cli --version 0.7.3 --no-confirm
-
-      - name: Build dioxus project
-        run: dx bundle --platform macos --release -p mumble-web2-gui
-
-      - name: Save Rust cache
-        if: always()
-        uses: actions/cache/save@v4
-        with:
-          path: |
-            ~/.cargo
-            ./target
-          key: rust-${{ runner.os }}-${{ hashFiles('**/Cargo.lock') }}
-
-      - name: Upload mumble-web2-gui Artifact
-        uses: https://gitea.com/actions/gitea-upload-artifact@v4
-        with:
-          name: mumble-web2-gui-macos-arm64
-          path: gui/dist
-          retention-days: 5
-
   windows_build:
     runs-on: windows
     steps:

common/src/lib.rs

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

docker/Caddyfile

@@ -1,12 +1,14 @@
 localhost:64444 {
-	tls internal
+    tls internal
 
-	# Proxy /config path to mumble-web2-proxy
-	reverse_proxy /overrides http://127.0.0.1:4400
+    # Proxy /config path to mumble-web2-proxy
+    reverse_proxy /config http://127.0.0.1:4400
 
-	# Proxy /status path to mumble-web2-proxy
-	reverse_proxy /status http://127.0.0.1:4400
+    # Proxy /status path to mumble-web2-proxy
+    reverse_proxy /status http://127.0.0.1:4400
+
+
+    # Proxy root path to dx-serve
+    reverse_proxy http://127.0.0.1:8080
 
-	# Proxy root path to dx-serve
-	reverse_proxy http://127.0.0.1:8080
 }

docker/docker-compose.yaml

@@ -20,7 +20,7 @@ services:
   #  volumes:
   #    - ..:/app
   #  environment:
-  #    - MUMBLE_WEB2_PROXY_OVERRIDES_URL=https://localhost:64444/overrides
+  #    - MUMBLE_WEB2_GUI_CONFIG_URL=https://localhost:64444/config
   #  stdin_open: true
   #  tty: true
   #  command: >

gui/assets/main.scss

@@ -16,7 +16,6 @@ body {
 }
 
 #main {
-  visibility: visible;
   height: 100vh;
   display: flex;
   flex-direction: column;

gui/src/app.rs

@@ -2,17 +2,15 @@
 
 use dioxus::prelude::*;
 use mime_guess::Mime;
-use mumble_web2_common::{ProxyOverrides, ServerStatus};
+use mumble_web2_common::{ClientConfig, ServerStatus};
 use ordermap::OrderSet;
 use std::collections::{HashMap, HashSet};
-use std::{fmt, sync::Arc};
 
-use crate::imp::{ConfigSystem, ConfigSystemInterface as _, Platform, PlatformInterface as _};
+use crate::imp::{Platform, PlatformInterface as _};
 
 pub type ChannelId = u32;
 pub type UserId = u32;
 
-#[derive(Debug)]
 pub enum ConnectionState {
     Disconnected,
     Connecting,
@@ -20,17 +18,12 @@ pub enum ConnectionState {
     Failed(String),
 }
 
-#[derive(Debug, Clone)]
-pub struct AudioSettings {
-    pub denoise: bool,
-}
-
 #[derive(Debug)]
 pub enum Command {
     Connect {
         address: String,
         username: String,
-        config: ProxyOverrides,
+        config: ClientConfig,
     },
     SendChat {
         markdown: String,
@@ -52,14 +45,16 @@ pub enum Command {
         channel: ChannelId,
         user: UserId,
     },
-    UpdateAudioSettings(AudioSettings),
+    UpdateMicEffects {
+        denoise: bool,
+    },
     Disconnect,
 }
 
 use Command::*;
 use ConnectionState::*;
 
-#[derive(Default, Debug)]
+#[derive(Default)]
 pub struct UserState {
     pub name: String,
     pub channel: ChannelId,
@@ -84,14 +79,13 @@ impl UserState {
     }
 }
 
-#[derive(Debug)]
 pub struct Chat {
     pub raw: String,
     pub dangerous_html: String,
     pub sender: Option<UserId>,
 }
 
-#[derive(Default, Debug)]
+#[derive(Default)]
 pub struct ChannelState {
     pub name: String,
     pub children: OrderSet<ChannelId>,
@@ -117,7 +111,7 @@ impl ChannelState {
     }
 }
 
-#[derive(Default, Debug)]
+#[derive(Default)]
 pub struct ChannelsState {
     pub channels: HashMap<ChannelId, ChannelState>,
 }
@@ -204,7 +198,7 @@ impl ChannelsState {
     }
 }
 
-#[derive(Default, Debug)]
+#[derive(Default)]
 pub struct ServerState {
     pub channels_state: ChannelsState,
     pub users: HashMap<UserId, UserState>,
@@ -219,21 +213,14 @@ impl ServerState {
 }
 
 pub struct State {
-    pub status: Signal<ConnectionState>,
-    pub server: Signal<ServerState>,
-    pub audio: Signal<AudioSettings>,
+    pub status: GlobalSignal<ConnectionState>,
+    pub server: GlobalSignal<ServerState>,
 }
 
-impl fmt::Debug for State {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("State")
-            .field("status", &self.status.read())
-            .field("server", &self.server.read())
-            .finish()
-    }
-}
-
-pub type SharedState = Arc<State>;
+pub static STATE: State = State {
+    status: Signal::global(|| Disconnected),
+    server: Signal::global(|| Default::default()),
+};
 
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub enum UserIcon {
@@ -280,8 +267,7 @@ pub fn UserPill(name: String, icon: UserIcon, isself: bool) -> Element {
 
 #[component]
 pub fn User(id: UserId) -> Element {
-    let state = use_context::<SharedState>();
-    let server = state.server.read();
+    let server = STATE.server.read();
     match server.users.get(&id) {
         Some(state) => rsx!(UserPill {
             name: state.name.clone(),
@@ -299,8 +285,7 @@ pub fn User(id: UserId) -> Element {
 #[component]
 pub fn Channel(id: ChannelId) -> Element {
     let net: Coroutine<Command> = use_coroutine_handle();
-    let state = use_context::<SharedState>();
-    let server = state.server.read();
+    let server = STATE.server.read();
     let user = server.session.unwrap();
     let Some(state) = server.channels_state.channels.get(&id) else {
         return rsx!("missing channel {id}");
@@ -369,8 +354,7 @@ pub fn Channel(id: ChannelId) -> Element {
 
 #[cfg(any(feature = "desktop", feature = "web"))]
 pub fn pick_and_send_file(net: &Coroutine<Command>) {
-    let state = use_context::<SharedState>();
-    let channels = if let Some(user) = state.server.read().this_user() {
+    let channels = if let Some(user) = STATE.server.read().this_user() {
         vec![user.channel]
     } else {
         return;
@@ -396,14 +380,11 @@ pub fn pick_and_send_file(net: &Coroutine<Command>) {}
 #[component]
 pub fn ChatView() -> Element {
     let net: Coroutine<Command> = use_coroutine_handle();
-    let state = use_context::<SharedState>();
-    let server = state.server.read();
+    let server = STATE.server.read();
     let mut draft = use_signal(|| "".to_string());
 
     let mut do_send = move || {
-        let state = use_context::<SharedState>();
-        let server = state.server.read();
-        if let Some(user) = server.this_user() {
+        if let Some(user) = STATE.server.read().this_user() {
             net.send(SendChat {
                 markdown: draft.write().split_off(0),
                 channels: vec![user.channel],
@@ -473,12 +454,10 @@ pub fn ChatView() -> Element {
 }
 
 #[component]
-pub fn ControlView(overrides: Resource<ProxyOverrides>) -> Element {
+pub fn ControlView(config: Resource<ClientConfig>) -> Element {
     let net: Coroutine<Command> = use_coroutine_handle();
-    let state = use_context::<SharedState>();
-    let status = &state.status;
-    let server = state.server.read();
-    let audio = state.audio.read();
+    let status = &STATE.status;
+    let server = STATE.server.read();
     let Some(&UserState {
         deaf,
         self_deaf,
@@ -495,10 +474,10 @@ pub fn ControlView(overrides: Resource<ProxyOverrides>) -> Element {
 
     let current_channel_name = server.channels_state.channels[&channel].name.clone();
 
-    let proxy_url = overrides
+    let proxy_url = config
         .read_unchecked()
         .as_ref()
-        .and_then(|overrides| overrides.proxy_url.clone());
+        .and_then(|gui_config| gui_config.proxy_url.clone());
 
     let connecting_color = "yellow";
     let connected_color = "oklch(0.55 0.1184 141.35)";
@@ -576,6 +555,7 @@ pub fn ControlView(overrides: Resource<ProxyOverrides>) -> Element {
         },
     };
 
+    let denoise = use_signal(|| false);
     rsx!(
         // Server control
         div {
@@ -616,23 +596,18 @@ pub fn ControlView(overrides: Resource<ProxyOverrides>) -> Element {
             }
             span { class: "spacer" }
             button {
-                class: match audio.denoise {
+                class: match denoise() {
                     true => "toggle_button is_on",
                     false => "toggle_button",
                 },
                 role: "switch",
-                aria_checked: audio.denoise,
+                aria_checked: denoise(),
                 onclick: move |_| {
-                    let state = use_context::<SharedState>();
-                    let mut audio = state.audio.read().clone();
-                    audio.denoise = !audio.denoise;
-                    let denoise = audio.denoise;
-                    *state.audio.write_unchecked() = audio;
-                    net.send(UpdateAudioSettings(AudioSettings { denoise: denoise }));
-                    let user_config = use_context::<ConfigSystem>();
-                    user_config.config_set::<bool>("denoise", &denoise);
+                    let new_denoise = !denoise();
+                    *denoise.write_unchecked() = new_denoise;
+                    net.send(UpdateMicEffects { denoise: new_denoise })
                 },
-                match audio.denoise {
+                match denoise() {
                     true => rsx!(span { class: "material-symbols-outlined", "cadence"}),
                     false => rsx!(span { class: "material-symbols-outlined", "graphic_eq"}),
                 }
@@ -670,10 +645,9 @@ pub fn ControlView(overrides: Resource<ProxyOverrides>) -> Element {
 }
 
 #[component]
-pub fn ServerView(overrides: Resource<ProxyOverrides>) -> Element {
+pub fn ServerView(config: Resource<ClientConfig>) -> Element {
     let net: Coroutine<Command> = use_coroutine_handle();
-    let state = use_context::<SharedState>();
-    let server = state.server.read();
+    let server = STATE.server.read();
     let Some(&UserState {
         deaf,
         self_deaf,
@@ -702,15 +676,14 @@ pub fn ServerView(overrides: Resource<ProxyOverrides>) -> Element {
             }
             div {
                 class: "server_control_box",
-                ControlView { overrides }
+                ControlView { config }
             }
         }
     )
 }
 
 #[component]
-pub fn LoginView(overrides: Resource<ProxyOverrides>) -> Element {
-    let user_config = use_context::<ConfigSystem>();
+pub fn LoginView(config: Resource<ClientConfig>) -> Element {
     let net: Coroutine<Command> = use_coroutine_handle();
 
     let last_status = use_signal(|| None::<color_eyre::Result<ServerStatus>>);
@@ -722,36 +695,33 @@ pub fn LoginView(overrides: Resource<ProxyOverrides>) -> Element {
         }
     });
 
-    let mut address_input = use_signal(|| user_config.config_get::<String>("server_url"));
+    let mut address_input = use_signal(|| Platform::load_server_url());
     let address = use_memo(move || {
         if let Some(addr) = address_input() {
             addr.clone()
         } else {
-            overrides()
+            config()
                 .and_then(|c| c.proxy_url.clone())
                 .unwrap_or_default()
         }
     });
 
-    let mut username = use_signal(|| {
-        user_config
-            .config_get::<String>("username")
-            .unwrap_or(String::new())
-    });
+    let previous_username = Platform::load_username();
+    let mut username = use_signal(|| previous_username.unwrap_or(String::new()));
 
     let do_connect = move |_| {
-        let _ = user_config.config_set::<String>("username", &username.read());
-        if overrides.read().as_ref().is_some_and(|cfg| cfg.any_server) {
-            user_config.config_set::<String>("server_url", &address.read());
+        //let _ = set_default_username(&username.read());
+        let _ = Platform::set_default_username(&username.read());
+        if config.read().as_ref().is_some_and(|cfg| cfg.any_server) {
+            Platform::set_default_server(&address.read());
         }
         net.send(Connect {
             address: address.read().clone(),
             username: username.read().clone(),
-            config: overrides.read().clone().unwrap_or_default(),
+            config: config.read().clone().unwrap_or_default(),
         })
     };
-    let state = use_context::<SharedState>();
-    let status = &state.status;
+    let status = &STATE.status;
     let bottom = match &*status.read() {
         Disconnected => rsx! {
             button {
@@ -793,7 +763,7 @@ pub fn LoginView(overrides: Resource<ProxyOverrides>) -> Element {
                     None => rsx!(),
                 }
             }
-            if overrides.read().as_ref().is_some_and(|cfg| cfg.any_server) {
+            if config.read().as_ref().is_some_and(|cfg| cfg.any_server) {
                 div {
                     label {
                         for: "address-entry",
@@ -885,44 +855,27 @@ pub fn LoginView(overrides: Resource<ProxyOverrides>) -> Element {
     //    )
 }
 
-#[component]
 pub fn app() -> Element {
     static STYLE: Asset = asset!("/assets/main.scss");
 
-    use_effect(|| {
-        Platform::request_permissions();
-    });
-
-    let user_config = use_root_context(|| ConfigSystem::new().unwrap());
-    let state = use_root_context(|| {
-        SharedState::new(State {
-            status: Signal::new(Disconnected),
-            server: Signal::new(Default::default()),
-            audio: Signal::new(AudioSettings {
-                denoise: user_config.config_get::<bool>("denoise").unwrap_or(true),
-            }),
-        })
-    });
-
-    let network_state = state.clone();
-    use_coroutine(move |rx: UnboundedReceiver<Command>| {
-        super::network_entrypoint(rx, network_state.clone())
-    });
-    let overrides = use_resource(|| async move {
-        match Platform::load_proxy_overrides().await {
-            Ok(overrides) => overrides,
-            Err(_) => ProxyOverrides::default(),
+    use_coroutine(|rx: UnboundedReceiver<Command>| super::network_entrypoint(rx));
+    let config = use_resource(|| async move {
+        match Platform::load_config().await {
+            Ok(config) => config,
+            Err(_) => ClientConfig::default(),
         }
     });
 
+    Platform::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" }
         document::Link{ rel: "stylesheet", href: STYLE }
 
-        match *state.status.read() {
-            Connected => rsx!(ServerView { overrides }),
-            _ => rsx!(LoginView { overrides }),
+        match *STATE.status.read() {
+            Connected => rsx!(ServerView { config }),
+            _ => rsx!(LoginView { config }),
         }
     )
 }

gui/src/imp/android.rs

@@ -1,91 +0,0 @@
-use crate::app::Command;
-use color_eyre::eyre::Error;
-use dioxus::hooks::UnboundedReceiver;
-use mumble_web2_common::{ClientConfig, ServerStatus};
-use std::future::Future;
-use std::time::Duration;
-
-/// Mobile platform implementation using Tokio, native audio, and Android permissions.
-pub struct MobilePlatform;
-
-impl super::PlatformInterface for MobilePlatform {
-    type AudioSystem = super::native_audio::NativeAudioSystem;
-
-    async fn load_config() -> color_eyre::Result<ClientConfig> {
-        Ok(ClientConfig {
-            proxy_url: None,
-            cert_hash: None,
-            any_server: true,
-        })
-    }
-
-    fn load_username() -> Option<String> {
-        None
-    }
-
-    fn load_server_url() -> Option<String> {
-        None
-    }
-
-    fn set_default_username(_username: &str) -> Option<()> {
-        None
-    }
-
-    fn set_default_server(server: &str) -> Option<()> {
-        None
-    }
-
-    async fn network_connect(
-        address: String,
-        username: String,
-        event_rx: &mut UnboundedReceiver<Command>,
-        gui_config: &ClientConfig,
-    ) -> Result<(), Error> {
-        super::connect::network_connect(address, username, event_rx, gui_config).await
-    }
-
-    async fn get_status(client: &reqwest::Client) -> color_eyre::Result<ServerStatus> {
-        super::connect::get_status(client).await
-    }
-
-    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();
-    }
-
-    fn request_permissions() {
-        request_recording_permission();
-    }
-
-    async fn sleep(duration: Duration) {
-        tokio::time::sleep(duration).await;
-    }
-}
-
-#[cfg(not(target_os = "android"))]
-pub fn request_recording_permission() {}
-
-#[cfg(target_os = "android")]
-pub fn request_recording_permission() {
-    use android_permissions::{PermissionManager, RECORD_AUDIO};
-    use jni::{objects::JObject, JavaVM};
-
-    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/connect.rs

@@ -1,4 +1,4 @@
-use crate::app::{Command, SharedState};
+use crate::app::Command;
 use color_eyre::eyre::{bail, Error};
 use dioxus::hooks::UnboundedReceiver;
 use mumble_protocol::control::ClientControlCodec;
@@ -8,13 +8,13 @@ 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;
+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::{ProxyOverrides, ServerStatus};
+use mumble_web2_common::{ClientConfig, ServerStatus};
 
 #[derive(Debug)]
 struct NoCertificateVerification;
@@ -73,12 +73,11 @@ pub async fn network_connect(
     address: String,
     username: String,
     event_rx: &mut UnboundedReceiver<Command>,
-    overrides: &ProxyOverrides,
-    state: SharedState,
+    gui_config: &ClientConfig,
 ) -> Result<(), Error> {
     info!("connecting");
 
-    let config = ClientConfig::builder()
+    let config = RlsClientConfig::builder()
         .dangerous()
         .with_custom_certificate_verifier(Arc::new(NoCertificateVerification))
         .with_no_client_auth();
@@ -103,7 +102,7 @@ pub async fn network_connect(
     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, state, event_rx, reader, writer).await
+    crate::network_loop(username, event_rx, reader, writer).await
 }
 
 pub async fn get_status(client: &reqwest::Client) -> color_eyre::Result<ServerStatus> {

gui/src/imp/desktop.rs

@@ -1,7 +1,9 @@
-use crate::app::{Command, SharedState};
+use crate::app::Command;
 use color_eyre::eyre::Error;
 use dioxus::hooks::UnboundedReceiver;
-use mumble_web2_common::{ProxyOverrides, ServerStatus};
+use etcetera::{choose_app_strategy, AppStrategy, AppStrategyArgs};
+use mumble_web2_common::{ClientConfig, ServerStatus};
+use std::collections::HashMap;
 use std::time::Duration;
 
 /// Desktop platform implementation using Tokio and native audio.
@@ -9,28 +11,48 @@ pub struct DesktopPlatform;
 
 impl super::PlatformInterface for DesktopPlatform {
     type AudioSystem = super::native_audio::NativeAudioSystem;
-    type ConfigSystem = super::native_config::NativeConfigSystem;
 
     async fn sleep(duration: Duration) {
         tokio::time::sleep(duration).await;
     }
 
-    async fn load_proxy_overrides() -> color_eyre::Result<ProxyOverrides> {
-        Ok(ProxyOverrides {
+    async fn load_config() -> color_eyre::Result<ClientConfig> {
+        Ok(ClientConfig {
             proxy_url: None,
             cert_hash: None,
             any_server: true,
         })
     }
 
+    fn load_username() -> Option<String> {
+        let config = load_config_map();
+        config.get("username").cloned()
+    }
+
+    fn load_server_url() -> Option<String> {
+        let config = load_config_map();
+        config.get("server").cloned()
+    }
+
+    fn set_default_username(username: &str) -> Option<()> {
+        let mut config = load_config_map();
+        config.insert("username".to_string(), username.to_string());
+        save_config_map(&config).ok()
+    }
+
+    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()
+    }
+
     async fn network_connect(
         address: String,
         username: String,
         event_rx: &mut UnboundedReceiver<Command>,
-        overrides: &ProxyOverrides,
-        state: SharedState,
+        gui_config: &ClientConfig,
     ) -> Result<(), Error> {
-        super::connect::network_connect(address, username, event_rx, overrides, state).await
+        super::connect::network_connect(address, username, event_rx, gui_config).await
     }
 
     async fn get_status(client: &reqwest::Client) -> color_eyre::Result<ServerStatus> {
@@ -56,3 +78,31 @@ impl super::PlatformInterface for DesktopPlatform {
         // No-op on desktop
     }
 }
+
+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")
+}
+
+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(),
+    }
+}
+
+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)?;
+    }
+    let contents = serde_json::to_string_pretty(config)?;
+    std::fs::write(&config_path, contents)?;
+    Ok(())
+}

gui/src/imp/mobile.rs

@@ -1,7 +1,8 @@
-use crate::app::{Command, SharedState};
+use crate::app::Command;
 use color_eyre::eyre::Error;
 use dioxus::hooks::UnboundedReceiver;
-use mumble_web2_common::{ProxyOverrides, ServerStatus};
+use mumble_web2_common::{ClientConfig, ServerStatus};
+use std::future::Future;
 use std::time::Duration;
 
 /// Mobile platform implementation using Tokio, native audio, and Android permissions.
@@ -9,24 +10,38 @@ pub struct MobilePlatform;
 
 impl super::PlatformInterface for MobilePlatform {
     type AudioSystem = super::native_audio::NativeAudioSystem;
-    type ConfigSystem = super::native_config::NativeConfigSystem;
 
-    async fn load_proxy_overrides() -> color_eyre::Result<ProxyOverrides> {
-        Ok(ProxyOverrides {
+    async fn load_config() -> color_eyre::Result<ClientConfig> {
+        Ok(ClientConfig {
             proxy_url: None,
             cert_hash: None,
             any_server: true,
         })
     }
 
+    fn load_username() -> Option<String> {
+        None
+    }
+
+    fn load_server_url() -> Option<String> {
+        None
+    }
+
+    fn set_default_username(_username: &str) -> Option<()> {
+        None
+    }
+
+    fn set_default_server(server: &str) -> Option<()> {
+        None
+    }
+
     async fn network_connect(
         address: String,
         username: String,
         event_rx: &mut UnboundedReceiver<Command>,
-        overrides: &ProxyOverrides,
-        state: SharedState,
+        gui_config: &ClientConfig,
     ) -> Result<(), Error> {
-        super::connect::network_connect(address, username, event_rx, overrides, state).await
+        super::connect::network_connect(address, username, event_rx, gui_config).await
     }
 
     async fn get_status(client: &reqwest::Client) -> color_eyre::Result<ServerStatus> {

gui/src/imp/mod.rs

@@ -4,12 +4,10 @@
 //! The traits make the platform boundary explicit and provide compile-time verification.
 #![allow(async_fn_in_trait)]
 
-use crate::app::{Command, SharedState};
-use crate::effects::AudioProcessor;
+use crate::{app::Command, effects::AudioProcessor};
 use color_eyre::eyre::Error;
 use dioxus::hooks::UnboundedReceiver;
-use mumble_web2_common::{ProxyOverrides, ServerStatus};
-use std::collections::HashMap;
+use mumble_web2_common::{ClientConfig, ServerStatus};
 use std::future::Future;
 use std::time::Duration;
 
@@ -52,24 +50,11 @@ pub trait AudioPlayerInterface {
     fn play_opus(&mut self, payload: &[u8]);
 }
 
-pub trait ConfigSystemInterface: Sized + Clone {
-    fn new() -> Result<Self, Error>;
-
-    fn config_get<T>(&self, key: &str) -> Option<T>
-    where
-        T: serde::de::DeserializeOwned;
-
-    fn config_set<T>(&self, key: &str, value: &T)
-    where
-        T: serde::Serialize;
-}
-
 /// This is the main trait that each platform must implement. It combines all
 /// platform-specific functionality into a single interface, providing compile-time
 /// verification that all platforms implement the required functionality.
 pub trait PlatformInterface {
     type AudioSystem: AudioSystemInterface;
-    type ConfigSystem: ConfigSystemInterface;
 
     /// Initialize logging for the platform.
     fn init_logging();
@@ -82,8 +67,7 @@ pub trait PlatformInterface {
         address: String,
         username: String,
         event_rx: &mut UnboundedReceiver<Command>,
-        proxy_overrides: &ProxyOverrides,
-        state: SharedState,
+        gui_config: &ClientConfig,
     ) -> impl Future<Output = Result<(), Error>>;
 
     /// Get server status (user count, version, etc.).
@@ -92,7 +76,19 @@ pub trait PlatformInterface {
     ) -> impl Future<Output = color_eyre::Result<ServerStatus>>;
 
     /// Load the proxy overrides (proxy URL, cert hash, etc.).
-    fn load_proxy_overrides() -> impl Future<Output = color_eyre::Result<ProxyOverrides>>;
+    fn load_config() -> impl Future<Output = color_eyre::Result<ClientConfig>>;
+
+    /// Load saved username.
+    fn load_username() -> Option<String>;
+
+    /// Load saved server URL.
+    fn load_server_url() -> Option<String>;
+
+    /// Save the default username.
+    fn set_default_username(username: &str) -> Option<()>;
+
+    /// Save the default server URL.
+    fn set_default_server(server: &str) -> Option<()>;
 
     /// Async sleep for the given duration.
     fn sleep(duration: Duration) -> impl Future<Output = ()>;
@@ -102,21 +98,15 @@ pub trait PlatformInterface {
 // Platform Modules
 // ============================================================================
 
-mod stub;
-
 #[cfg(any(feature = "desktop", feature = "mobile"))]
 mod connect;
-#[cfg(any(feature = "desktop", feature = "mobile"))]
-mod native_audio;
-#[cfg(any(feature = "desktop", feature = "mobile"))]
-mod native_config;
-
 #[cfg(feature = "desktop")]
 mod desktop;
-
 #[cfg(feature = "mobile")]
 mod mobile;
-
+#[cfg(any(feature = "desktop", feature = "mobile"))]
+mod native_audio;
+mod stub;
 #[cfg(feature = "web")]
 mod web;
 
@@ -143,8 +133,6 @@ pub type Platform = stub::StubPlatform;
 pub type AudioSystem = <Platform as PlatformInterface>::AudioSystem;
 pub type AudioPlayer = <AudioSystem as AudioSystemInterface>::AudioPlayer;
 
-pub type ConfigSystem = <Platform as PlatformInterface>::ConfigSystem;
-
 // ========================
 // Platform Async Runtime
 // ========================
@@ -176,12 +164,3 @@ const _: () = {
     let _ = assert_platform::<mobile::MobilePlatform>;
     let _ = assert_platform::<stub::StubPlatform>;
 };
-
-fn global_default_config() -> HashMap<String, serde_json::Value> {
-    serde_json::json!({})
-        .as_object()
-        .unwrap()
-        .clone()
-        .into_iter()
-        .collect()
-}

gui/src/imp/native_config.rs

@@ -1,117 +0,0 @@
-use color_eyre::eyre::Error;
-use std::collections::HashMap;
-use tracing::info;
-
-#[derive(Clone, PartialEq)]
-pub struct NativeConfigSystem {
-    config_path: std::path::PathBuf,
-}
-
-impl super::ConfigSystemInterface for NativeConfigSystem {
-    fn new() -> color_eyre::Result<Self, Error> {
-        return Ok(NativeConfigSystem {
-            config_path: get_config_path()?,
-        });
-    }
-
-    fn config_get<T>(&self, key: &str) -> Option<T>
-    where
-        T: serde::de::DeserializeOwned,
-    {
-        let config = load_config_map(&self.config_path);
-
-        let Some(value_untyped) = config.get(key).cloned().or_else(|| config_get_default(key))
-        else {
-            return None;
-        };
-
-        match serde_json::from_value::<T>(value_untyped) {
-            Ok(v) => Some(v),
-            Err(_) => {
-                let default_value = config_get_default(key)
-                    .expect("Default value required after config parse failure");
-                Some(
-                    serde_json::from_value::<T>(default_value)
-                        .expect("Default value could not be parsed"),
-                )
-            }
-        }
-    }
-
-    fn config_set<T>(&self, key: &str, value: &T)
-    where
-        T: serde::Serialize,
-    {
-        let mut config = load_config_map(&self.config_path);
-        let json_value = serde_json::to_value(value).expect("failed to serialize config value");
-        config.insert(key.to_string(), json_value);
-        save_config_map(&config).expect("failed to set config")
-    }
-}
-
-#[cfg(any(feature = "desktop"))]
-fn get_config_path() -> color_eyre::Result<std::path::PathBuf> {
-    use etcetera::{choose_app_strategy, AppStrategy, AppStrategyArgs};
-
-    let strategy = choose_app_strategy(AppStrategyArgs {
-        top_level_domain: "xyz".to_string(),
-        author: "ohea".to_string(),
-        app_name: "Mumble Web2".to_string(),
-    })
-    .expect("failed to choose app strategy");
-    Ok(strategy.config_dir().join("config.json"))
-}
-
-#[cfg(target_os = "android")]
-fn get_config_path() -> color_eyre::Result<std::path::PathBuf> {
-    let ctx = ndk_context::android_context();
-    let vm = unsafe { jni::JavaVM::from_raw(ctx.vm().cast()) }?;
-    let mut env = vm.attach_current_thread()?;
-    let ctx = unsafe { jni::objects::JObject::from_raw(ctx.context().cast()) };
-    let cache_dir = env
-        .call_method(ctx, "getFilesDir", "()Ljava/io/File;", &[])?
-        .l()?;
-    let cache_dir: jni::objects::JString = env
-        .call_method(&cache_dir, "toString", "()Ljava/lang/String;", &[])?
-        .l()?
-        .try_into()?;
-    let cache_dir = env.get_string(&cache_dir)?;
-    let cache_dir = cache_dir.to_str()?;
-    Ok(std::path::PathBuf::from(cache_dir).join("config.json"))
-}
-
-fn load_config_map(config_path: &std::path::PathBuf) -> HashMap<String, serde_json::Value> {
-    match std::fs::read_to_string(config_path) {
-        Ok(contents) => serde_json::from_str(&contents).unwrap_or_default(),
-        Err(_) => HashMap::new(),
-    }
-}
-
-fn save_config_map(config: &HashMap<String, serde_json::Value>) -> color_eyre::Result<()> {
-    let config_path = get_config_path().expect("Could not get config file path.");
-    if let Some(parent) = config_path.parent() {
-        info!("Creating config directory: {}", parent.display());
-        std::fs::create_dir_all(parent)?;
-    }
-    let contents = serde_json::to_string_pretty(config)?;
-    info!("Writing config to {}", config_path.display());
-    std::fs::write(&config_path, contents)?;
-    Ok(())
-}
-
-fn config_get_default(key: &str) -> Option<serde_json::Value> {
-    let default_config = platform_default_config();
-    default_config
-        .get(key)
-        .cloned()
-        .or(super::global_default_config().get(key).cloned())
-}
-
-fn platform_default_config() -> HashMap<String, serde_json::Value> {
-    serde_json::json!({})
-        .as_object()
-        .unwrap()
-        .clone()
-        .into_iter()
-        .collect()
-}

gui/src/imp/stub.rs

@@ -1,16 +1,15 @@
 /// Stub implementation of the platform interface, so that we can
 /// `cargo check` without any --feature flags.
-use crate::{app::SharedState, effects::AudioProcessor};
+use crate::effects::AudioProcessor;
 use color_eyre::eyre::Error;
 use dioxus::hooks::UnboundedReceiver;
-use mumble_web2_common::{ProxyOverrides, ServerStatus};
+use mumble_web2_common::{ClientConfig, ServerStatus};
 use std::future::Future;
 
 pub struct StubPlatform;
 
 impl super::PlatformInterface for StubPlatform {
     type AudioSystem = StubAudioSystem;
-    type ConfigSystem = StubConfigSystem;
 
     fn init_logging() {
         panic!("stubbed platform")
@@ -24,8 +23,7 @@ impl super::PlatformInterface for StubPlatform {
         _address: String,
         _username: String,
         _event_rx: &mut UnboundedReceiver<crate::app::Command>,
-        _overrides: &ProxyOverrides,
-        _state: SharedState,
+        _gui_config: &ClientConfig,
     ) -> impl Future<Output = Result<(), Error>> {
         async { panic!("stubbed platform") }
     }
@@ -36,10 +34,26 @@ impl super::PlatformInterface for StubPlatform {
         async { panic!("stubbed platform") }
     }
 
-    fn load_proxy_overrides() -> impl Future<Output = color_eyre::Result<ProxyOverrides>> {
+    fn load_config() -> impl Future<Output = color_eyre::Result<ClientConfig>> {
         async { panic!("stubbed platform") }
     }
 
+    fn load_username() -> Option<String> {
+        panic!("stubbed platform")
+    }
+
+    fn load_server_url() -> Option<String> {
+        panic!("stubbed platform")
+    }
+
+    fn set_default_username(_username: &str) -> Option<()> {
+        panic!("stubbed platform")
+    }
+
+    fn set_default_server(_server: &str) -> Option<()> {
+        panic!("stubbed platform")
+    }
+
     fn sleep(_duration: std::time::Duration) -> impl Future<Output = ()> {
         async { panic!("stubbed platform") }
     }
@@ -78,29 +92,6 @@ impl super::AudioPlayerInterface for StubAudioPlayer {
     }
 }
 
-#[derive(Clone)]
-pub struct StubConfigSystem;
-
-impl super::ConfigSystemInterface for StubConfigSystem {
-    fn new() -> Result<Self, Error> {
-        panic!("stubbed platform")
-    }
-
-    fn config_get<T>(&self, key: &str) -> Option<T>
-    where
-        T: serde::de::DeserializeOwned,
-    {
-        panic!("stubbed platform")
-    }
-
-    fn config_set<T>(&self, key: &str, value: &T)
-    where
-        T: serde::Serialize,
-    {
-        panic!("stubbed platform")
-    }
-}
-
 #[allow(unused)]
 pub struct SpawnHandle;
 

gui/src/imp/web.rs

@@ -1,4 +1,4 @@
-use crate::app::{Command, SharedState};
+use crate::app::Command;
 use crate::effects::{AudioProcessor, AudioProcessorSender, TransmitState};
 use color_eyre::eyre::{bail, eyre, Error};
 use crossbeam::atomic::AtomicCell;
@@ -6,9 +6,8 @@ use dioxus::prelude::*;
 use gloo_timers::future::TimeoutFuture;
 use js_sys::Float32Array;
 use mumble_protocol::control::ClientControlCodec;
-use mumble_web2_common::{ProxyOverrides, ServerStatus};
+use mumble_web2_common::{ClientConfig, ServerStatus};
 use reqwest::Url;
-use std::collections::HashMap;
 use std::future::Future;
 use std::sync::Arc;
 use std::time::Duration;
@@ -63,7 +62,6 @@ pub struct WebPlatform;
 
 impl super::PlatformInterface for WebPlatform {
     type AudioSystem = WebAudioSystem;
-    type ConfigSystem = WebConfigSystem;
 
     fn init_logging() {
         // copied from tracing_web example usage
@@ -91,29 +89,53 @@ impl super::PlatformInterface for WebPlatform {
         // No-op on web
     }
 
-    async fn load_proxy_overrides() -> color_eyre::Result<ProxyOverrides> {
-        let overrides = match option_env!("MUMBLE_WEB2_PROXY_OVERRIDES_URL") {
+    async fn load_config() -> color_eyre::Result<ClientConfig> {
+        let config_url = match option_env!("MUMBLE_WEB2_GUI_CONFIG_URL") {
             Some(url) => Url::parse(url)?,
-            None => absolute_url("overrides")?,
+            None => absolute_url("config")?,
         };
-        info!("loading config from {}", overrides);
+        info!("loading config from {}", config_url);
 
-        let config = reqwest::get(overrides)
+        let config = reqwest::get(config_url)
             .await?
-            .json::<ProxyOverrides>()
+            .json::<ClientConfig>()
             .await?;
 
         Ok(config)
     }
 
+    fn load_username() -> Option<String> {
+        web_sys::window()
+            .unwrap()
+            .local_storage()
+            .ok()??
+            .get_item("username")
+            .ok()?
+    }
+
+    fn load_server_url() -> Option<String> {
+        None
+    }
+
+    fn set_default_username(username: &str) -> Option<()> {
+        web_sys::window()?
+            .local_storage()
+            .ok()??
+            .set_item("username", username)
+            .ok()
+    }
+
+    fn set_default_server(_server: &str) -> Option<()> {
+        None
+    }
+
     async fn network_connect(
         address: String,
         username: String,
         event_rx: &mut UnboundedReceiver<Command>,
-        overrides: &ProxyOverrides,
-        state: SharedState,
+        gui_config: &ClientConfig,
     ) -> Result<(), Error> {
-        network_connect(address, username, event_rx, overrides, state).await
+        network_connect(address, username, event_rx, gui_config).await
     }
 
     async fn get_status(client: &reqwest::Client) -> color_eyre::Result<ServerStatus> {
@@ -434,8 +456,7 @@ pub async fn network_connect(
     address: String,
     username: String,
     event_rx: &mut UnboundedReceiver<Command>,
-    overrides: &ProxyOverrides,
-    state: SharedState,
+    gui_config: &ClientConfig,
 ) -> Result<(), Error> {
     info!("connecting");
 
@@ -448,7 +469,7 @@ pub async fn network_connect(
     )
     .ey()?;
 
-    if let Some(server_hash) = &overrides.cert_hash {
+    if let Some(server_hash) = &gui_config.cert_hash {
         let hash = web_sys::js_sys::Uint8Array::from(server_hash.as_slice());
         web_sys::js_sys::Reflect::set(&object, &"value".into(), &hash).ey()?;
     }
@@ -494,7 +515,7 @@ pub async fn network_connect(
     let writer =
         asynchronous_codec::FramedWrite::new(wasm_stream_writable.into_async_write(), write_codec);
 
-    crate::network_loop(username, state, event_rx, reader, writer).await
+    crate::network_loop(username, event_rx, reader, writer).await
 }
 
 pub fn absolute_url(path: &str) -> Result<Url, Error> {
@@ -502,64 +523,3 @@ pub fn absolute_url(path: &str) -> Result<Url, Error> {
     let location = window.location();
     Ok(Url::parse(&location.href().ey()?)?.join(path)?)
 }
-
-#[derive(Clone, PartialEq)]
-pub struct WebConfigSystem {}
-
-impl super::ConfigSystemInterface for WebConfigSystem {
-    fn new() -> Result<Self, Error> {
-        return Ok(WebConfigSystem {});
-    }
-
-    fn config_get<T>(&self, key: &str) -> Option<T>
-    where
-        T: serde::de::DeserializeOwned,
-    {
-        // Get Storage
-        let storage = web_sys::window()?.local_storage().ok()??;
-
-        // Try localStorage first
-        if let Ok(Some(raw)) = storage.get_item(key) {
-            if let Ok(parsed) = serde_json::from_str::<T>(&raw) {
-                return Some(parsed);
-            }
-        }
-
-        // Fallback to default if deserialization fails or key missing
-        let default_value = config_get_default(key)?;
-        serde_json::from_value::<T>(default_value).ok()
-    }
-
-    fn config_set<T>(&self, key: &str, value: &T)
-    where
-        T: serde::Serialize,
-    {
-        let storage = window()
-            .and_then(|w| w.local_storage().ok().flatten())
-            .expect("localStorage not available");
-
-        let json_value =
-            serde_json::to_string(value).expect("failed to serialize config value to JSON string");
-
-        storage
-            .set_item(key, &json_value)
-            .expect("failed to write to localStorage");
-    }
-}
-
-fn config_get_default(key: &str) -> Option<serde_json::Value> {
-    let default_config = platform_default_config();
-    default_config
-        .get(key)
-        .cloned()
-        .or(super::global_default_config().get(key).cloned())
-}
-
-fn platform_default_config() -> HashMap<String, serde_json::Value> {
-    serde_json::json!({})
-        .as_object()
-        .unwrap()
-        .clone()
-        .into_iter()
-        .collect()
-}

gui/src/lib.rs

@@ -1,6 +1,7 @@
 use app::Chat;
 use app::Command;
 use app::ConnectionState;
+use app::STATE;
 use asynchronous_codec::FramedRead;
 use asynchronous_codec::FramedWrite;
 use color_eyre::eyre::{bail, Error};
@@ -26,9 +27,6 @@ use std::time::Duration;
 use tracing::error;
 use tracing::info;
 
-use crate::app::AudioSettings;
-use crate::app::SharedState;
-use crate::app::State;
 use crate::effects::AudioProcessor;
 use crate::imp::{
     AudioPlayer, AudioPlayerInterface as _, AudioSystem, AudioSystemInterface as _, Platform,
@@ -40,7 +38,7 @@ mod effects;
 pub mod imp;
 mod msghtml;
 
-pub async fn network_entrypoint(mut event_rx: UnboundedReceiver<Command>, state: SharedState) {
+pub async fn network_entrypoint(mut event_rx: UnboundedReceiver<Command>) {
     loop {
         let Some(Command::Connect {
             address,
@@ -51,29 +49,25 @@ pub async fn network_entrypoint(mut event_rx: UnboundedReceiver<Command>, state:
             panic!("did not receive connect command")
         };
 
-        *state.server.write_unchecked() = Default::default();
-        *state.status.write_unchecked() = ConnectionState::Connecting;
+        *STATE.server.write() = Default::default();
+        *STATE.status.write() = ConnectionState::Connecting;
         if let Err(error) =
-            Platform::network_connect(address, username, &mut event_rx, &config, state.clone())
-                .await
+            Platform::network_connect(address, username, &mut event_rx, &config).await
         {
             error!("could not connect {:?}", error);
-            *state.status.write_unchecked() = ConnectionState::Failed(error.to_string());
+            *STATE.status.write() = ConnectionState::Failed(error.to_string());
         } else {
-            *state.status.write_unchecked() = ConnectionState::Disconnected;
+            *STATE.status.write() = ConnectionState::Disconnected;
         }
     }
 }
 
 pub async fn network_loop<R: AsyncRead + Unpin + 'static, W: AsyncWrite + Unpin + 'static>(
     username: String,
-    state: SharedState,
     event_rx: &mut UnboundedReceiver<Command>,
     mut reader: FramedRead<R, ControlCodec<Serverbound, Clientbound>>,
     mut writer: FramedWrite<W, ControlCodec<Serverbound, Clientbound>>,
 ) -> Result<(), Error> {
-    let audio_settings = state.audio.read().clone();
-
     let (mut send_chan, mut writer_recv_chan) = futures_channel::mpsc::unbounded();
     spawn(async move {
         while let Some(msg) = writer_recv_chan.next().await {
@@ -123,13 +117,10 @@ pub async fn network_loop<R: AsyncRead + Unpin + 'static, W: AsyncWrite + Unpin
     }
 
     let mut audio = AudioSystem::new().await?;
-    if audio_settings.denoise {
-        audio.set_processor(AudioProcessor::new_denoising());
-    }
     {
         let send_chan = send_chan.clone();
         let mut sequence_num = 0;
-        if let Err(err) = audio.start_recording(move |opus_frame, is_terminator| {
+        audio.start_recording(move |opus_frame, is_terminator| {
             let _ =
                 send_chan.unbounded_send(ControlPacket::UDPTunnel(Box::new(VoicePacket::Audio {
                     _dst: std::marker::PhantomData,
@@ -140,9 +131,7 @@ pub async fn network_loop<R: AsyncRead + Unpin + 'static, W: AsyncWrite + Unpin
                     position_info: None,
                 })));
             sequence_num = sequence_num.wrapping_add(2);
-        }) {
-            error!("could not begin recording: {err:?}")
-        }
+        });
     }
 
     // Create map of session_id -> AudioDecoder
@@ -160,7 +149,7 @@ pub async fn network_loop<R: AsyncRead + Unpin + 'static, W: AsyncWrite + Unpin
                         if !matches!(msg, ControlPacket::UDPTunnel(_) | ControlPacket::Ping(_)) {
                             info!("receiving packet {:#?}", msg);
                         }
-                        let res = accept_packet(msg, &mut audio, &mut decoder_map, &state);
+                        let res = accept_packet(msg, &mut audio, &mut decoder_map);
                         if let Err(err) = res {
                             error!("error accepting packet {:?}", err)
                         }
@@ -179,7 +168,7 @@ pub async fn network_loop<R: AsyncRead + Unpin + 'static, W: AsyncWrite + Unpin
                 match command {
                     Some(Command::Disconnect) => break,
                     Some(command) => {
-                        let res = accept_command(command, &mut send_chan, &mut audio, &state);
+                        let res = accept_command(command, &mut send_chan, &mut audio);
                         if let Err(err) = res {
                             info!("error accepting command {:?}", err)
                         }
@@ -198,10 +187,9 @@ fn accept_command(
     command: Command,
     send_chan: &mut UnboundedSender<ControlPacket<mumble_protocol::Serverbound>>,
     audio: &mut AudioSystem,
-    state: &State,
 ) -> Result<(), Error> {
     use Command::*;
-    let Some(session) = state.server.read().session else {
+    let Some(session) = STATE.server.read().session else {
         bail!("no session id")
     };
 
@@ -224,7 +212,7 @@ fn accept_command(
             };
 
             {
-                let mut server = state.server.write_unchecked();
+                let mut server = STATE.server.write();
                 let Some(me) = server.session else {
                     bail!("not signed in with a session id")
                 };
@@ -265,7 +253,7 @@ fn accept_command(
             };
 
             {
-                let mut server = state.server.write_unchecked();
+                let mut server = STATE.server.write();
                 let Some(me) = server.session else {
                     bail!("not signed in with a session id")
                 };
@@ -300,7 +288,7 @@ fn accept_command(
             let _ = send_chan.unbounded_send(u.into());
         }
         Connect { .. } | Disconnect => (),
-        UpdateAudioSettings(AudioSettings { denoise }) => {
+        UpdateMicEffects { denoise } => {
             if denoise {
                 audio.set_processor(AudioProcessor::new_denoising());
             } else {
@@ -316,7 +304,6 @@ fn accept_packet(
     msg: ControlPacket<mumble_protocol::Clientbound>,
     audio_context: &mut AudioSystem,
     player_map: &mut HashMap<u32, AudioPlayer>,
-    state: &State,
 ) -> Result<(), Error> {
     match msg {
         ControlPacket::UDPTunnel(u) => {
@@ -353,15 +340,15 @@ fn accept_packet(
             }
         }
         ControlPacket::ChannelState(u) => {
-            let mut server = state.server.write_unchecked();
+            let mut server = STATE.server.write();
             server.channels_state.update_from_channel_state(&u);
         }
         ControlPacket::ChannelRemove(u) => {
-            let mut server = state.server.write_unchecked();
+            let mut server = STATE.server.write();
             server.channels_state.update_from_channel_remove(&u);
         }
         ControlPacket::UserState(u) => {
-            let mut server = state.server.write_unchecked();
+            let mut server = STATE.server.write();
             let server = &mut *server;
             let id = u.get_session();
 
@@ -405,7 +392,7 @@ fn accept_packet(
             }
         }
         ControlPacket::UserRemove(u) => {
-            let mut server = state.server.write_unchecked();
+            let mut server = STATE.server.write();
             let id = u.get_session();
             if let Some(state) = server.users.remove(&id) {
                 if let Some(parent) = server.channels_state.channels.get_mut(&state.channel) {
@@ -414,7 +401,7 @@ fn accept_packet(
             }
         }
         ControlPacket::TextMessage(u) => {
-            let mut server = state.server.write_unchecked();
+            let mut server = STATE.server.write();
             if u.has_message() {
                 let text = u.get_message().to_string();
                 server.chat.push(Chat {
@@ -429,8 +416,8 @@ fn accept_packet(
             }
         }
         ControlPacket::ServerSync(u) => {
-            *state.status.write_unchecked() = ConnectionState::Connected;
-            let mut server = state.server.write_unchecked();
+            *STATE.status.write() = ConnectionState::Connected;
+            let mut server = STATE.server.write();
             if u.has_welcome_text() {
                 let text = u.get_welcome_text().to_string();
                 server.chat.push(Chat {

gui/src/main.rs

@@ -1,22 +1,6 @@
-use dioxus::prelude::*;
 use mumble_web2_gui::{app, imp::Platform, imp::PlatformInterface as _};
 
 pub fn main() {
     Platform::init_logging();
-    dioxus::LaunchBuilder::new()
-        .with_cfg(desktop! {
-            dioxus::desktop::Config::new()
-            // Reduce white flash on startup by setting background color and hiding main element
-            .with_background_color((0, 0, 0, 255))
-            .with_custom_head("<style>html, body { background: black; } #main { visibility: hidden; }</style>".into())
-            .with_disable_context_menu(cfg!(not(debug_assertions)))
-            .with_window(
-                dioxus::desktop::WindowBuilder::new()
-                    .with_title("Mumble Web 2")
-                    .with_min_inner_size(dioxus::desktop::LogicalSize::new(600.0, 300.0))
-                    .with_inner_size(dioxus::desktop::LogicalSize::new(900.0, 700.0))
-                    .with_maximized(false),
-            )
-        })
-        .launch(app::app);
+    dioxus::launch(app::app);
 }

proxy/src/main.rs

@@ -1,5 +1,5 @@
 use color_eyre::eyre::{anyhow, bail, Context, Result};
-use mumble_web2_common::{ProxyOverrides, ServerStatus};
+use mumble_web2_common::{ClientConfig, ServerStatus};
 use rand::Rng;
 use salvo::conn::rustls::{Keycert, RustlsConfig};
 use salvo::cors::{AllowOrigin, Cors};
@@ -16,7 +16,7 @@ use tokio::net::TcpStream;
 use tokio::pin;
 use tokio_rustls::rustls::client::danger::{HandshakeSignatureValid, ServerCertVerifier};
 use tokio_rustls::rustls::pki_types::{CertificateDer, ServerName, UnixTime};
-use tokio_rustls::rustls::{ClientConfig, DigitallySignedStruct};
+use tokio_rustls::rustls::{ClientConfig as RlsClientConfig, DigitallySignedStruct};
 use tokio_rustls::{rustls, TlsConnector};
 use tracing::info;
 use tracing::info_span;
@@ -77,7 +77,7 @@ async fn main() -> Result<()> {
         .install_default()
         .map_err(|e| anyhow!("could not install crypto provider {e:?}"))?;
 
-    let mut overrides = ProxyOverrides {
+    let mut client_config = ClientConfig {
         proxy_url: match &server_config.proxy_url {
             Some(url) => Some(url.to_string()),
             None => None,
@@ -102,7 +102,7 @@ async fn main() -> Result<()> {
             let cert = cert_params.self_signed(&key_pair)?;
 
             let hash = hmac_sha256::Hash::hash(cert.der().as_ref());
-            overrides.cert_hash = Some(hash.into());
+            client_config.cert_hash = Some(hash.into());
 
             (cert.pem().into(), key_pair.serialize_pem().into())
         }
@@ -122,11 +122,14 @@ async fn main() -> Result<()> {
     };
     let rustls_config = RustlsConfig::new(Keycert::new().cert(cert.as_slice()).key(key.as_slice()));
 
-    info!("proxy overrides:\n{}", toml::to_string_pretty(&overrides)?);
+    info!(
+        "client config:\n{}",
+        toml::to_string_pretty(&client_config)?
+    );
 
     let config_craft = ConfigCraft {
         server_config: server_config.clone(),
-        overrides,
+        client_config,
     };
 
     let status_craft = StatusCraft {
@@ -136,7 +139,7 @@ async fn main() -> Result<()> {
     // Server routing
     let mut router = Router::new()
         .push(Router::with_path("/proxy").goal(config_craft.connect_proxy()))
-        .push(Router::with_path("/overrides").get(config_craft.get_overrides()))
+        .push(Router::with_path("/config").get(config_craft.get_config()))
         .push(Router::with_path("/status").get(status_craft.get_status()))
         .hoop(Logger::new());
     if let Some(gui_path) = server_config.gui_path.clone() {
@@ -249,14 +252,14 @@ impl StatusCraft {
 #[derive(Clone)]
 pub struct ConfigCraft {
     server_config: Arc<Config>,
-    overrides: ProxyOverrides,
+    client_config: ClientConfig,
 }
 
 #[craft]
 impl ConfigCraft {
     #[craft(handler)]
-    async fn get_overrides(&self) -> Json<ProxyOverrides> {
-        Json(self.overrides.clone())
+    async fn get_config(&self) -> Json<ClientConfig> {
+        Json(self.client_config.clone())
     }
 
     #[craft(handler)]
@@ -317,7 +320,7 @@ async fn connect_proxy_impl(
 ) -> Result<()> {
     info!("connecting to Mumble server...");
 
-    let config = ClientConfig::builder()
+    let config = RlsClientConfig::builder()
         .dangerous()
         .with_custom_certificate_verifier(Arc::new(NoCertificateVerification))
         .with_no_client_auth();