disable rust cache in linux ci

.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.3
+        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

docker/android-release-builder.Dockerfile

@@ -29,7 +29,7 @@ RUN yes | /opt/android-tools/cmdline-tools/latest/bin/sdkmanager --install "plat
 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.3
+RUN cargo binstall dioxus-cli@0.7.2
 
 # Install bindgen-cli
 RUN cargo binstall bindgen-cli

docker/windows-release-builder.Dockerfile

@@ -44,12 +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 cargo binstall
+# 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
-RUN cargo binstall dioxus-cli@0.7.3
+# 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 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

@@ -146,6 +146,7 @@ desktop = [
   "rfd/xdg-portal",
   "etcetera",
 ]
+
 mobile = [
   "dioxus/mobile",
   "tokio",

gui/assets/main.scss

@@ -83,44 +83,6 @@ a:visited {
   }
 }
 
-
-.channel_header {
-    display: flex;
-    flex-direction: row;
-    align-items: center;
-}
-
-.channel_arrow {
-    width: 1em;
-    text-align: center;
-    margin-right: 0.25rem;
-}
-
-.channel_arrow--placeholder {
-    pointer-events: none;
-    visibility: hidden;
-}
-
-/* The whole right side of the row is the dblclick target */
-.channel_row_click {
-    flex: 1;
-    padding: 0.1rem 0.25rem 0.1rem 0.5rem;
-    cursor: pointer;
-}
-
-/* Hover highlight for whole row area (title + blank space) */
-.channel_row_click:hover {
-    background-color: var(--channel-hover-bg, #222); /* pick your color */
-}
-
-
-/* still keep text non-selectable if desired */
-.channel_details {
-    -webkit-user-select: none;
-    -ms-user-select: none;
-    user-select: none;
-}
-
 .channel {
   &_details {
     flex: 0 0 100%;
@@ -430,4 +392,4 @@ a:visited {
       color: red;
     }
   }
-}
+}

gui/src/app.rs

@@ -4,9 +4,9 @@ use dioxus::prelude::*;
 use mime_guess::Mime;
 use mumble_web2_common::{ClientConfig, ServerStatus};
 use ordermap::OrderSet;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 
-use crate::imp::{Platform, PlatformInterface as _};
+use crate::imp;
 
 pub type ChannelId = u32;
 pub type UserId = u32;
@@ -54,6 +54,14 @@ pub enum Command {
 use Command::*;
 use ConnectionState::*;
 
+#[derive(Default)]
+pub struct ChannelState {
+    pub name: String,
+    pub children: OrderSet<ChannelId>,
+    pub users: OrderSet<UserId>,
+    pub parent: Option<ChannelId>,
+}
+
 #[derive(Default)]
 pub struct UserState {
     pub name: String,
@@ -85,122 +93,9 @@ pub struct Chat {
     pub sender: Option<UserId>,
 }
 
-#[derive(Default)]
-pub struct ChannelState {
-    pub name: String,
-    pub children: OrderSet<ChannelId>,
-    pub users: OrderSet<UserId>,
-    pub parent: Option<ChannelId>,
-    pub position: i32,
-}
-
-impl ChannelState {
-    pub fn update_from_channel_state(
-        &mut self,
-        channel_state: &mumble_protocol::control::msgs::ChannelState,
-    ) {
-        if channel_state.has_position() {
-            self.position = channel_state.get_position();
-        }
-        if channel_state.has_parent() {
-            self.parent = Some(channel_state.get_parent());
-        }
-        if channel_state.has_name() {
-            self.name = channel_state.get_name().to_string();
-        }
-    }
-}
-
-#[derive(Default)]
-pub struct ChannelsState {
-    pub channels: HashMap<ChannelId, ChannelState>,
-}
-
-impl ChannelsState {
-    pub fn update_from_channel_state(
-        &mut self,
-        channel_state: &mumble_protocol::control::msgs::ChannelState,
-    ) {
-        self.channels
-            .entry(channel_state.get_channel_id())
-            .or_default()
-            .update_from_channel_state(channel_state);
-
-        self.update_channel_parents();
-    }
-
-    pub fn update_from_channel_remove(
-        &mut self,
-        channel_remove: &mumble_protocol::control::msgs::ChannelRemove,
-    ) {
-        self.channels.remove(&channel_remove.get_channel_id());
-        self.update_channel_parents();
-    }
-
-    pub fn update_channel_parents(&mut self) {
-        // Zero out existing children
-        for state in self.channels.values_mut() {
-            state.children.clear();
-        }
-
-        let mut to_sort: Vec<(ChannelId, Option<ChannelId>, i32, String)> = Vec::new();
-        for (id, state) in self.channels.iter() {
-            // Handle channels with no parent (the root channel)
-            let Some(parent_id) = state.parent else {
-                to_sort.push((*id, None, 0, state.name.clone()));
-                continue;
-            };
-
-            // If a channel has a parent that we haven't gotten a channel
-            // state packet for, ignore it
-            if !self.channels.contains_key(&parent_id) {
-                continue;
-            }
-
-            to_sort.push((*id, Some(parent_id), state.position, state.name.clone()));
-        }
-
-        let pos_name: HashMap<ChannelId, (i32, String)> = self
-            .channels
-            .iter()
-            .map(|(&id, state)| (id, (state.position, state.name.clone())))
-            .collect();
-
-        let mut updated: HashSet<ChannelId> = HashSet::new();
-
-        while updated.len() < to_sort.len() {
-            for &(id, ref parent_id, position, ref name) in &to_sort {
-                let Some(parent_id) = parent_id else {
-                    updated.insert(id);
-                    continue;
-                };
-
-                if updated.contains(&id) || !updated.contains(&parent_id) {
-                    continue;
-                }
-
-                // Unwrap should never fail here since we pre filter
-                let parent = self.channels.get_mut(&parent_id).unwrap();
-
-                let mut insert_index = parent.children.len();
-                for (i, &child) in parent.children.iter().enumerate() {
-                    let (p, ref n) = pos_name[&child];
-                    if (position == p && name < n) || p > position {
-                        insert_index = i;
-                        break;
-                    }
-                }
-
-                parent.children.insert_before(insert_index, id);
-                updated.insert(id);
-            }
-        }
-    }
-}
-
 #[derive(Default)]
 pub struct ServerState {
-    pub channels_state: ChannelsState,
+    pub channels: HashMap<ChannelId, ChannelState>,
     pub users: HashMap<UserId, UserState>,
     pub chat: Vec<Chat>,
     pub session: Option<UserId>,
@@ -287,57 +182,26 @@ pub fn Channel(id: ChannelId) -> Element {
     let net: Coroutine<Command> = use_coroutine_handle();
     let server = STATE.server.read();
     let user = server.session.unwrap();
-    let Some(state) = server.channels_state.channels.get(&id) else {
+    let Some(state) = server.channels.get(&id) else {
         return rsx!("missing channel {id}");
     };
 
-    let mut open = use_signal(|| true);
-
-    let has_children = !state.users.is_empty() || !state.children.is_empty();
-
     rsx!(
-        div {
+        details {
             class: "channel_details",
-
-            div {
-                class: "channel_header",
-                // Arrow: only toggles open
-                if has_children {
-                    span {
-                        class: "channel_arrow",
-                        onclick: move |evt| {
-                            evt.stop_propagation();
-                            evt.prevent_default();
-                            let mut w = open.write();
-                            *w = !*w;
-                        },
-                        if *open.read() { "▾" } else { "▸" }
-                    }
-                } else {
-                    span {
-                        class: "channel_arrow channel_arrow--placeholder",
-                        " "
-                    }
-                }
-
-                // Clickable row area (everything except the arrow)
-                div {
-                    class: "channel_row_click",
-                    ondblclick: move |evt| {
+            open: true,
+            summary {
+                span {
+                    role: "button",
+                    ondoubleclick: move |evt| {
                         evt.stop_propagation();
                         evt.prevent_default();
                         net.send(EnterChannel { channel: id, user })
                     },
-                    // remove dblclick from the inner span
-                    span {
-                        class: "channel_title",
-                        "{state.name}"
-                    }
-                    // if you add icons/badges later, put them here too
+                    "{state.name}"
                 }
             }
-
-            if *open.read() && has_children {
+            if state.users.len() + state.children.len() > 0 {
                 div {
                     class: "channel_children",
                     for id in state.users.iter() {
@@ -472,7 +336,7 @@ pub fn ControlView(config: Resource<ClientConfig>) -> Element {
         return rsx!();
     };
 
-    let current_channel_name = server.channels_state.channels[&channel].name.clone();
+    let current_channel_name = server.channels[&channel].name.clone();
 
     let proxy_url = config
         .read_unchecked()
@@ -664,7 +528,7 @@ pub fn ServerView(config: Resource<ClientConfig>) -> Element {
             class: "server_grid",
             div {
                 class: "server_channel_box",
-                for (id, state) in server.channels_state.channels.iter() {
+                for (id, state) in server.channels.iter() {
                     if state.parent.is_none() {
                         Channel { id: *id }
                     }
@@ -690,12 +554,12 @@ pub fn LoginView(config: Resource<ClientConfig>) -> Element {
     use_resource(move || async move {
         let client = reqwest::Client::new();
         loop {
-            *last_status.write_unchecked() = Some(Platform::get_status(&client).await);
-            Platform::sleep(std::time::Duration::from_secs_f32(1.0)).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(|| Platform::load_server_url());
+    let mut address_input = use_signal(|| imp::load_server_url());
     let address = use_memo(move || {
         if let Some(addr) = address_input() {
             addr.clone()
@@ -706,14 +570,14 @@ pub fn LoginView(config: Resource<ClientConfig>) -> Element {
         }
     });
 
-    let previous_username = Platform::load_username();
+    let previous_username = imp::load_username();
     let mut username = use_signal(|| previous_username.unwrap_or(String::new()));
 
     let do_connect = move |_| {
         //let _ = set_default_username(&username.read());
-        let _ = Platform::set_default_username(&username.read());
+        let _ = imp::set_default_username(&username.read());
         if config.read().as_ref().is_some_and(|cfg| cfg.any_server) {
-            Platform::set_default_server(&address.read());
+            imp::set_default_server(&address.read());
         }
         net.send(Connect {
             address: address.read().clone(),
@@ -860,13 +724,13 @@ pub fn app() -> Element {
 
     use_coroutine(|rx: UnboundedReceiver<Command>| super::network_entrypoint(rx));
     let config = use_resource(|| async move {
-        match Platform::load_config().await {
+        match imp::load_config().await {
             Ok(config) => config,
             Err(_) => ClientConfig::default(),
         }
     });
 
-    Platform::request_permissions();
+    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" }

gui/src/effects.rs

@@ -7,7 +7,7 @@ use std::cell::RefCell;
 use std::sync::Arc;
 use tracing::{error, info};
 
-use crate::imp::SpawnHandle;
+use crate::imp;
 
 static DF_MODEL: Asset = asset!("/assets/DeepFilterNet3_ll_onnx.tar.gz");
 // TODO: make this user configurable.
@@ -32,7 +32,10 @@ enum DenoisingModelState {
     Availible(Box<DfTract>),
 }
 
-fn with_denoising_model<O>(spawn: &SpawnHandle, func: impl FnOnce(&mut DfTract) -> O) -> Option<O> {
+fn with_denoising_model<O>(
+    spawn: &imp::SpawnHandle,
+    func: impl FnOnce(&mut DfTract) -> O,
+) -> Option<O> {
     // Using a thread local is super gross, but DfTract is not Send (so it can never leave the current
     // thread) while AudioProcessing itself might change threads whenever.
     thread_local! {
@@ -86,7 +89,7 @@ fn with_denoising_model<O>(spawn: &SpawnHandle, func: impl FnOnce(&mut DfTract)
 
 pub struct AudioProcessor {
     denoise: bool,
-    spawn: SpawnHandle,
+    spawn: imp::SpawnHandle,
     buffer: Vec<f32>,
     noise_floor: f32,
     /// Whether we were transmitting in the previous frame
@@ -99,7 +102,7 @@ impl AudioProcessor {
     pub fn new_plain() -> Self {
         AudioProcessor {
             denoise: false,
-            spawn: SpawnHandle::current(),
+            spawn: imp::SpawnHandle::current(),
             buffer: Vec::new(),
             noise_floor: DEFAULT_NOISE_FLOOR,
             was_transmitting: false,
@@ -110,7 +113,7 @@ impl AudioProcessor {
     pub fn new_denoising() -> Self {
         AudioProcessor {
             denoise: true,
-            spawn: SpawnHandle::current(),
+            spawn: imp::SpawnHandle::current(),
             buffer: Vec::new(),
             noise_floor: DEFAULT_NOISE_FLOOR,
             was_transmitting: false,
@@ -120,12 +123,7 @@ impl AudioProcessor {
 }
 
 impl AudioProcessor {
-    pub fn process(
-        &mut self,
-        audio: &[f32],
-        channels: usize,
-        output: &mut Vec<f32>,
-    ) -> TransmitState {
+    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| {

gui/src/imp/connect.rs

@@ -108,8 +108,3 @@ pub async fn network_connect(
 pub async fn get_status(client: &reqwest::Client) -> color_eyre::Result<ServerStatus> {
     bail!("status not supported on desktop yet")
 }
-
-#[allow(unused)]
-pub use tokio::spawn;
-#[allow(unused)]
-pub type SpawnHandle = tokio::runtime::Handle;

gui/src/imp/desktop.rs

@@ -1,83 +1,12 @@
-use crate::app::Command;
-use color_eyre::eyre::Error;
-use dioxus::hooks::UnboundedReceiver;
 use etcetera::{choose_app_strategy, AppStrategy, AppStrategyArgs};
-use mumble_web2_common::{ClientConfig, ServerStatus};
+use mumble_web2_common::ClientConfig;
 use std::collections::HashMap;
-use std::time::Duration;
+pub use tokio::runtime::Handle as SpawnHandle;
+pub use tokio::task::spawn;
+pub use tokio::time::sleep;
 
-/// Desktop platform implementation using Tokio and native audio.
-pub struct DesktopPlatform;
-
-impl super::PlatformInterface for DesktopPlatform {
-    type AudioSystem = super::native_audio::NativeAudioSystem;
-
-    async fn sleep(duration: Duration) {
-        tokio::time::sleep(duration).await;
-    }
-
-    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>,
-        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() {
-        // No-op on desktop
-    }
-}
+pub use super::connect::*;
+pub use super::native_audio::*;
 
 fn get_config_path() -> std::path::PathBuf {
     let strategy = choose_app_strategy(AppStrategyArgs {
@@ -106,3 +35,48 @@ fn save_config_map(config: &HashMap<String, String>) -> color_eyre::Result<()> {
     std::fs::write(&config_path, contents)?;
     Ok(())
 }
+
+pub 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()
+}
+
+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> {
+    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,
+        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();
+}

gui/src/imp/mobile.rs

@@ -1,85 +1,61 @@
-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;
+use android_permissions::{PermissionManager, RECORD_AUDIO};
+use jni::{objects::JObject, JavaVM};
+use mumble_web2_common::ClientConfig;
 
-/// Mobile platform implementation using Tokio, native audio, and Android permissions.
-pub struct MobilePlatform;
+use std::collections::HashMap;
+pub use tokio::runtime::Handle as SpawnHandle;
+pub use tokio::task::spawn;
+pub use tokio::time::sleep;
 
-impl super::PlatformInterface for MobilePlatform {
-    type AudioSystem = super::native_audio::NativeAudioSystem;
+pub use super::connect::*;
+pub use super::native_audio::*;
 
-    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;
-    }
+pub fn set_default_username(username: &str) -> Option<()> {
+    None
 }
 
-#[cfg(not(target_os = "android"))]
-pub fn request_recording_permission() {}
+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() {
-    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()) };

gui/src/imp/mod.rs

@@ -1,166 +1,29 @@
-//! Platform abstraction layer
-//!
-//! This module defines traits that each platform (web, desktop, mobile) must implement.
-//! The traits make the platform boundary explicit and provide compile-time verification.
-#![allow(async_fn_in_trait)]
-
-use crate::{app::Command, effects::AudioProcessor};
-use color_eyre::eyre::Error;
-use dioxus::hooks::UnboundedReceiver;
-use mumble_web2_common::{ClientConfig, ServerStatus};
-use std::future::Future;
-use std::time::Duration;
-
-// ============================================================================
-// Trait Definitions
-// ============================================================================
-
-/// Platform-specific audio subsystem for capturing microphone input and creating playback streams.
-///
-/// The audio system handles Opus encoding internally - callers receive encoded frames
-/// ready for network transmission.
-pub trait AudioSystemInterface: Sized {
-    /// The player type returned by [`create_player`](Self::create_player).
-    type AudioPlayer: AudioPlayerInterface;
-
-    /// Initialize the audio system.
-    async fn new() -> Result<Self, Error>;
-
-    /// Set the processor for the microphone input, mainly noise cancellation settings.
-    fn set_processor(&self, processor: AudioProcessor);
-
-    /// Begin listening to microphone input, calling the `each` function with
-    /// encoded opus frames.
-    fn start_recording(
-        &mut self,
-        each: impl FnMut(Vec<u8>, bool) + Send + 'static,
-    ) -> Result<(), Error>;
-
-    /// Begin playback of an audio stream, returning an object that can be passed  opus frames.
-    fn create_player(&mut self) -> Result<Self::AudioPlayer, Error>;
-}
-
-/// A handle to an active audio playback stream for a single remote user.
-///
-/// Each connected user gets their own `AudioPlayer` instance, which decodes
-/// incoming Opus frames and outputs PCM audio to the platform's audio device.
-/// The player manages its own decoder state and output buffer.
-pub trait AudioPlayerInterface {
-    /// Decode and play an Opus-encoded audio frame.
-    fn play_opus(&mut self, payload: &[u8]);
-}
-
-/// 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;
-
-    /// Initialize logging for the platform.
-    fn init_logging();
-
-    /// Request runtime permissions (Android audio recording, etc.).
-    fn request_permissions();
-
-    /// Establish a connection to the Mumble server and run the network loop.
-    fn network_connect(
-        address: String,
-        username: String,
-        event_rx: &mut UnboundedReceiver<Command>,
-        gui_config: &ClientConfig,
-    ) -> impl Future<Output = Result<(), Error>>;
-
-    /// Get server status (user count, version, etc.).
-    fn get_status(
-        client: &reqwest::Client,
-    ) -> impl Future<Output = color_eyre::Result<ServerStatus>>;
-
-    /// Load the proxy overrides (proxy URL, cert hash, etc.).
-    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 = ()>;
-}
-
-// ============================================================================
-// Platform Modules
-// ============================================================================
+#[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(feature = "mobile")]
 mod mobile;
-#[cfg(any(feature = "desktop", feature = "mobile"))]
-mod native_audio;
-mod stub;
-#[cfg(feature = "web")]
-mod web;
 
-// ============================================================================
-// Platform Type Alias
-// ============================================================================
+#[cfg(feature = "desktop")]
+pub use desktop::*;
+#[cfg(feature = "mobile")]
+pub use mobile::*;
 
-#[cfg(feature = "web")]
-pub type Platform = web::WebPlatform;
+#[cfg(feature = "mobile")]
+pub use mobile::request_permissions;
 
-#[cfg(all(feature = "desktop", not(feature = "web")))]
-pub type Platform = desktop::DesktopPlatform;
+#[cfg(any(feature = "desktop", feature = "web"))]
+pub fn request_permissions() {}
 
-#[cfg(all(feature = "mobile", not(feature = "web"), not(feature = "desktop")))]
-pub type Platform = mobile::MobilePlatform;
+#[cfg(all(feature = "web", not(any(feature = "desktop", feature = "mobile"))))]
+pub use web::*;
 
-#[cfg(all(
-    not(feature = "mobile"),
-    not(feature = "web"),
-    not(feature = "desktop")
-))]
-pub type Platform = stub::StubPlatform;
-
-pub type AudioSystem = <Platform as PlatformInterface>::AudioSystem;
-pub type AudioPlayer = <AudioSystem as AudioSystemInterface>::AudioPlayer;
-
-// ========================
-// Platform Async Runtime
-// ========================
-
-// Note: these can not be part of the Platform because they differ in Send requiremets
-#[cfg(all(any(feature = "desktop", feature = "mobile"), not(feature = "web")))]
-pub use connect::{spawn, SpawnHandle};
-#[cfg(all(
-    not(feature = "desktop"),
-    not(feature = "mobile"),
-    not(feature = "web")
-))]
-pub use stub::{spawn, SpawnHandle};
-#[cfg(feature = "web")]
-pub use web::{spawn, SpawnHandle};
-
-// =======================
-// Compile-time Assertions
-// =======================
-const _: () = {
-    fn assert_platform<T: PlatformInterface>() {}
-
-    // Check each implementation, and prevent warnings that the implementations are unused.
-    #[cfg(feature = "web")]
-    let _ = assert_platform::<web::WebPlatform>;
-    #[cfg(feature = "desktop")]
-    let _ = assert_platform::<desktop::DesktopPlatform>;
-    #[cfg(feature = "mobile")]
-    let _ = assert_platform::<mobile::MobilePlatform>;
-    let _ = assert_platform::<stub::StubPlatform>;
-};
+#[cfg(any(feature = "desktop"))]
+pub use desktop::*;

gui/src/imp/native_audio.rs

@@ -1,12 +1,19 @@
 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 struct NativeAudioSystem {
+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,
@@ -15,8 +22,6 @@ pub struct NativeAudioSystem {
 
 const SAMPLE_RATE: u32 = 48_000;
 const PACKET_SAMPLES: u32 = 960;
-// Divide by 1000 to get samples per ms, then multiply by 60ms for max Opus frame size.
-const MAX_DECODE_SAMPLES: usize = SAMPLE_RATE as usize / 1000 * 60;
 
 fn encode_and_send(
     state: TransmitState,
@@ -45,7 +50,28 @@ fn encode_and_send(
 
 type Buffer = Arc<Mutex<dasp_ring_buffer::Bounded<Vec<i16>>>>;
 
-impl NativeAudioSystem {
+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>,
@@ -75,32 +101,8 @@ impl NativeAudioSystem {
             .cloned()
             .ok_or(eyre!("no supported stream configs"))
     }
-}
 
-impl super::AudioSystemInterface for NativeAudioSystem {
-    type AudioPlayer = NativeAudioPlayer;
-
-    async fn new() -> Result<Self, Error> {
-        let host = cpal::default_host();
-        let name = host.id();
-        let processors = AudioProcessorSender::default();
-        Ok(NativeAudioSystem {
-            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 set_processor(&self, processor: AudioProcessor) {
-        self.processors.store(Some(processor))
-    }
-
-    fn start_recording(
+    pub fn start_recording(
         &mut self,
         mut each: impl FnMut(Vec<u8>, bool) + Send + 'static,
     ) -> Result<(), Error> {
@@ -120,8 +122,7 @@ impl super::AudioSystemInterface for NativeAudioSystem {
             if let Some(new_processor) = processors.take() {
                 current_processor = new_processor;
             }
-            let state =
-                current_processor.process(frame, config.channels as usize, &mut output_buffer);
+            let state = current_processor.process(frame, config.channels as usize, &mut output_buffer);
             encode_and_send(state, &mut output_buffer, &mut encoder, &mut each);
         };
 
@@ -141,7 +142,7 @@ impl super::AudioSystemInterface for NativeAudioSystem {
         }
     }
 
-    fn create_player(&mut self) -> Result<NativeAudioPlayer, Error> {
+    pub fn create_player(&mut self) -> Result<AudioPlayer, Error> {
         let config = self.choose_config(self.output.supported_output_configs()?)?;
         info!(
             "creating player on {:?} with {:#?}",
@@ -179,29 +180,31 @@ impl super::AudioSystemInterface for NativeAudioSystem {
             )?
         };
         stream.play()?;
-        Ok(NativeAudioPlayer {
+        Ok(AudioPlayer {
             decoder,
             stream,
             buffer,
-            tmp: vec![0; MAX_DECODE_SAMPLES],
+            tmp: vec![0; 2400],
         })
     }
 }
 
-pub struct NativeAudioPlayer {
+pub struct AudioPlayer {
     decoder: opus::Decoder,
     stream: cpal::Stream,
     buffer: Buffer,
     tmp: Vec<i16>,
 }
 
-impl super::AudioPlayerInterface for NativeAudioPlayer {
-    fn play_opus(&mut self, payload: &[u8]) {
-        let len = match self.decoder.decode(payload, &mut self.tmp, false) {
-            Ok(l) => l,
-            Err(e) => {
-                error!("opus decode error {e:?}");
-                return;
+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;
+                }
             }
         };
 

gui/src/imp/stub.rs

@@ -1,119 +0,0 @@
-/// Stub implementation of the platform interface, so that we can
-/// `cargo check` without any --feature flags.
-use crate::effects::AudioProcessor;
-use color_eyre::eyre::Error;
-use dioxus::hooks::UnboundedReceiver;
-use mumble_web2_common::{ClientConfig, ServerStatus};
-use std::future::Future;
-
-pub struct StubPlatform;
-
-impl super::PlatformInterface for StubPlatform {
-    type AudioSystem = StubAudioSystem;
-
-    fn init_logging() {
-        panic!("stubbed platform")
-    }
-
-    fn request_permissions() {
-        panic!("stubbed platform")
-    }
-
-    fn network_connect(
-        _address: String,
-        _username: String,
-        _event_rx: &mut UnboundedReceiver<crate::app::Command>,
-        _gui_config: &ClientConfig,
-    ) -> impl Future<Output = Result<(), Error>> {
-        async { panic!("stubbed platform") }
-    }
-
-    fn get_status(
-        _client: &reqwest::Client,
-    ) -> impl Future<Output = color_eyre::Result<ServerStatus>> {
-        async { panic!("stubbed platform") }
-    }
-
-    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") }
-    }
-}
-
-pub struct StubAudioSystem;
-
-impl super::AudioSystemInterface for StubAudioSystem {
-    type AudioPlayer = StubAudioPlayer;
-
-    async fn new() -> Result<Self, Error> {
-        panic!("stubbed platform")
-    }
-
-    fn set_processor(&self, _processor: AudioProcessor) {
-        panic!("stubbed platform")
-    }
-
-    fn start_recording(
-        &mut self,
-        _each: impl FnMut(Vec<u8>, bool) + Send + 'static,
-    ) -> Result<(), Error> {
-        panic!("stubbed platform")
-    }
-
-    fn create_player(&mut self) -> Result<Self::AudioPlayer, Error> {
-        panic!("stubbed platform")
-    }
-}
-
-pub struct StubAudioPlayer;
-
-impl super::AudioPlayerInterface for StubAudioPlayer {
-    fn play_opus(&mut self, _payload: &[u8]) {
-        panic!("stubbed platform")
-    }
-}
-
-#[allow(unused)]
-pub struct SpawnHandle;
-
-impl SpawnHandle {
-    #[allow(unused)]
-    pub fn spawn<F>(&self, _future: F)
-    where
-        F: Future<Output = ()> + 'static,
-    {
-        panic!("stubbed platform")
-    }
-
-    #[allow(unused)]
-    pub fn current() -> Self {
-        SpawnHandle
-    }
-}
-
-#[allow(unused)]
-pub fn spawn<F>(_future: F)
-where
-    F: Future<Output = ()> + 'static,
-{
-    panic!("stubbed platform")
-}

gui/src/imp/web.rs

@@ -3,6 +3,7 @@ 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;
@@ -28,6 +29,7 @@ use web_sys::AudioWorkletNode;
 use web_sys::EncodedAudioChunk;
 use web_sys::EncodedAudioChunkInit;
 use web_sys::EncodedAudioChunkType;
+use web_sys::MediaStream;
 use web_sys::MediaStreamConstraints;
 use web_sys::MessageEvent;
 use web_sys::WebTransport;
@@ -37,119 +39,16 @@ use web_sys::WorkletOptions;
 use web_sys::{console, window};
 use web_sys::{AudioContext, AudioDataCopyToOptions};
 
-#[allow(unused)]
 pub use wasm_bindgen_futures::spawn_local as spawn;
 
-#[allow(unused)]
-#[derive(Clone)]
-pub struct SpawnHandle;
+pub trait ImpRead: AsyncRead + Unpin + 'static {}
+impl<T: AsyncRead + Unpin + 'static> ImpRead for T {}
 
-impl SpawnHandle {
-    pub fn spawn<F>(&self, future: F)
-    where
-        F: Future<Output = ()> + 'static,
-    {
-        wasm_bindgen_futures::spawn_local(future);
-    }
+pub trait ImpWrite: AsyncWrite + Unpin + 'static {}
+impl<T: AsyncWrite + Unpin + 'static> ImpWrite for T {}
 
-    pub fn current() -> Self {
-        SpawnHandle
-    }
-}
-
-/// Web platform implementation using WebTransport and Web Audio API.
-pub struct WebPlatform;
-
-impl super::PlatformInterface for WebPlatform {
-    type AudioSystem = WebAudioSystem;
-
-    fn init_logging() {
-        // copied from tracing_web example usage
-
-        use tracing_subscriber::fmt::format::Pretty;
-        use tracing_subscriber::prelude::*;
-        use tracing_web::{performance_layer, MakeWebConsoleWriter};
-
-        let fmt_layer = tracing_subscriber::fmt::layer()
-            .with_ansi(false) // Only partially supported across browsers
-            .without_time() // std::time is not available in browsers
-            .with_writer(MakeWebConsoleWriter::new()) // write events to the console
-            .with_filter(LevelFilter::DEBUG);
-        let perf_layer = performance_layer().with_details_from_fields(Pretty::default());
-
-        tracing_subscriber::registry()
-            .with(fmt_layer)
-            .with(perf_layer)
-            .init();
-
-        info!("logging initiated");
-    }
-
-    fn request_permissions() {
-        // No-op on web
-    }
-
-    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("config")?,
-        };
-        info!("loading config from {}", config_url);
-
-        let config = reqwest::get(config_url)
-            .await?
-            .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>,
-        gui_config: &ClientConfig,
-    ) -> Result<(), Error> {
-        network_connect(address, username, event_rx, gui_config).await
-    }
-
-    async fn get_status(client: &reqwest::Client) -> color_eyre::Result<ServerStatus> {
-        Ok(client
-            .get(absolute_url("status")?)
-            .send()
-            .await?
-            .json::<ServerStatus>()
-            .await?)
-    }
-
-    async fn sleep(duration: Duration) {
-        TimeoutFuture::new(duration.as_millis() as u32).await;
-    }
+pub async fn sleep(d: Duration) {
+    TimeoutFuture::new(d.as_millis() as u32).await
 }
 
 trait ResultExt<T> {
@@ -174,7 +73,7 @@ impl<T> ResultExt<T> for Result<T, JsError> {
     }
 }
 
-pub struct WebAudioSystem {
+pub struct AudioSystem {
     webctx: AudioContext,
     processors: AudioProcessorSender,
 }
@@ -205,10 +104,8 @@ async fn attach_worklet(audio_context: &AudioContext) -> Result<(), Error> {
     Ok(())
 }
 
-impl super::AudioSystemInterface for WebAudioSystem {
-    type AudioPlayer = WebAudioPlayer;
-
-    async fn new() -> Result<Self, Error> {
+impl AudioSystem {
+    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();
@@ -216,14 +113,17 @@ impl super::AudioSystemInterface for WebAudioSystem {
 
         let processors = AudioProcessorSender::default();
 
-        Ok(WebAudioSystem { webctx, processors })
+        Ok(AudioSystem { webctx, processors })
     }
 
-    fn set_processor(&self, processor: AudioProcessor) {
+    pub fn set_processor(&self, processor: AudioProcessor) {
         self.processors.store(Some(processor))
     }
 
-    fn start_recording(&mut self, each: impl FnMut(Vec<u8>, bool) + '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 {
@@ -235,7 +135,7 @@ impl super::AudioSystemInterface for WebAudioSystem {
         Ok(())
     }
 
-    fn create_player(&mut self) -> Result<WebAudioPlayer, Error> {
+    pub fn create_player(&mut self) -> Result<AudioPlayer, Error> {
         let sink_node = AudioWorkletNode::new(&self.webctx, "rust_speaker_worklet").ey()?;
 
         // Connect worklet to destination
@@ -288,14 +188,14 @@ impl super::AudioSystemInterface for WebAudioSystem {
         decoder_error.forget();
         output.forget();
 
-        Ok(WebAudioPlayer(audio_decoder))
+        Ok(AudioPlayer(audio_decoder))
     }
 }
 
-pub struct WebAudioPlayer(AudioDecoder);
+pub struct AudioPlayer(AudioDecoder);
 
-impl super::AudioPlayerInterface for WebAudioPlayer {
-    fn play_opus(&mut self, payload: &[u8]) {
+impl AudioPlayer {
+    pub fn play_opus(&mut self, payload: &[u8]) {
         let js_audio_payload = Uint8Array::from(payload);
         let _ = self.0.decode(
             &EncodedAudioChunk::new(&EncodedAudioChunkInit::new(
@@ -518,8 +418,94 @@ pub async fn network_connect(
     crate::network_loop(username, event_rx, reader, writer).await
 }
 
+pub fn set_default_username(username: &str) -> Option<()> {
+    web_sys::window()?
+        .local_storage()
+        .ok()??
+        .set_item("username", username)
+        .ok()
+}
+
+pub fn set_default_server(username: &str) -> Option<()> {
+    None
+}
+
+pub fn load_username() -> Option<String> {
+    web_sys::window()
+        .unwrap()
+        .local_storage()
+        .ok()??
+        .get_item("username")
+        .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();
     Ok(Url::parse(&location.href().ey()?)?.join(path)?)
 }
+
+pub 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("config")?,
+    };
+    info!("loading config from {}", config_url);
+
+    let config = reqwest::get(config_url)
+        .await?
+        .json::<ClientConfig>()
+        .await?;
+
+    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
+
+    use tracing_subscriber::fmt::format::Pretty;
+    use tracing_subscriber::prelude::*;
+    use tracing_web::{performance_layer, MakeWebConsoleWriter};
+
+    let fmt_layer = tracing_subscriber::fmt::layer()
+        .with_ansi(false) // Only partially supported across browsers
+        .without_time() // std::time is not available in browsers
+        .with_writer(MakeWebConsoleWriter::new()) // write events to the console
+        .with_filter(LevelFilter::DEBUG);
+    let perf_layer = performance_layer().with_details_from_fields(Pretty::default());
+
+    tracing_subscriber::registry()
+        .with(fmt_layer)
+        .with(perf_layer)
+        .init();
+
+    info!("logging initiated");
+}
+
+pub struct SpawnHandle;
+
+impl SpawnHandle {
+    pub fn current() -> Self {
+        SpawnHandle
+    }
+
+    pub fn spawn<F>(&self, future: F)
+    where
+        F: Future<Output = ()> + 'static,
+    {
+        spawn(future);
+    }
+}

gui/src/lib.rs

@@ -7,12 +7,11 @@ use asynchronous_codec::FramedWrite;
 use color_eyre::eyre::{bail, Error};
 use dioxus::prelude::*;
 use futures::select;
-use futures::AsyncRead;
-use futures::AsyncWrite;
 use futures::FutureExt as _;
 use futures::SinkExt as _;
 use futures::StreamExt as _;
 use futures_channel::mpsc::UnboundedSender;
+pub use imp::spawn;
 use msghtml::process_message_html;
 use mumble_protocol::control::msgs;
 use mumble_protocol::control::ControlCodec;
@@ -28,10 +27,7 @@ use tracing::error;
 use tracing::info;
 
 use crate::effects::AudioProcessor;
-use crate::imp::{
-    AudioPlayer, AudioPlayerInterface as _, AudioSystem, AudioSystemInterface as _, Platform,
-    PlatformInterface as _,
-};
+use crate::imp::AudioSystem;
 
 pub mod app;
 mod effects;
@@ -51,9 +47,7 @@ pub async fn network_entrypoint(mut event_rx: UnboundedReceiver<Command>) {
 
         *STATE.server.write() = Default::default();
         *STATE.status.write() = ConnectionState::Connecting;
-        if let Err(error) =
-            Platform::network_connect(address, username, &mut event_rx, &config).await
-        {
+        if let Err(error) = imp::network_connect(address, username, &mut event_rx, &config).await {
             error!("could not connect {:?}", error);
             *STATE.status.write() = ConnectionState::Failed(error.to_string());
         } else {
@@ -62,7 +56,7 @@ pub async fn network_entrypoint(mut event_rx: UnboundedReceiver<Command>) {
     }
 }
 
-pub async fn network_loop<R: AsyncRead + Unpin + 'static, W: AsyncWrite + Unpin + 'static>(
+pub async fn network_loop<R: imp::ImpRead, W: imp::ImpWrite>(
     username: String,
     event_rx: &mut UnboundedReceiver<Command>,
     mut reader: FramedRead<R, ControlCodec<Serverbound, Clientbound>>,
@@ -111,12 +105,12 @@ pub async fn network_loop<R: AsyncRead + Unpin + 'static, W: AsyncWrite + Unpin
                     break;
                 }
 
-                Platform::sleep(Duration::from_millis(3000)).await;
+                imp::sleep(Duration::from_millis(3000)).await;
             }
         });
     }
 
-    let mut audio = AudioSystem::new().await?;
+    let mut audio = imp::AudioSystem::new().await?;
     {
         let send_chan = send_chan.clone();
         let mut sequence_num = 0;
@@ -302,8 +296,8 @@ fn accept_command(
 
 fn accept_packet(
     msg: ControlPacket<mumble_protocol::Clientbound>,
-    audio_context: &mut AudioSystem,
-    player_map: &mut HashMap<u32, AudioPlayer>,
+    audio_context: &mut imp::AudioSystem,
+    player_map: &mut HashMap<u32, imp::AudioPlayer>,
 ) -> Result<(), Error> {
     match msg {
         ControlPacket::UDPTunnel(u) => {
@@ -341,11 +335,41 @@ fn accept_packet(
         }
         ControlPacket::ChannelState(u) => {
             let mut server = STATE.server.write();
-            server.channels_state.update_from_channel_state(&u);
+            let id = u.get_channel_id();
+
+            let state = server.channels.entry(id).or_default();
+            let new_parent = if u.has_parent() {
+                if let Some(parent) = state.parent.and_then(|p| server.channels.get_mut(&p)) {
+                    parent.children.remove(&id);
+                }
+
+                let parent_id = u.get_parent();
+                let parent = server.channels.entry(parent_id).or_default();
+                if u.has_position() && u.get_position() as usize <= parent.children.len() {
+                    // TODO: what if positions are received out of order? we need to sort afterwards?
+                    parent.children.insert_before(u.get_position() as usize, id);
+                } else {
+                    parent.children.insert(id);
+                }
+                Some(parent_id)
+            } else {
+                None
+            };
+
+            let state = server.channels.entry(id).or_default();
+            state.parent = new_parent;
+            if u.has_name() {
+                state.name = u.get_name().to_string();
+            }
         }
         ControlPacket::ChannelRemove(u) => {
             let mut server = STATE.server.write();
-            server.channels_state.update_from_channel_remove(&u);
+            let id = u.get_channel_id();
+            if let Some(channel) = server.channels.remove(&id) {
+                if let Some(parent) = channel.parent.and_then(|p| server.channels.get_mut(&p)) {
+                    parent.children.remove(&id);
+                }
+            }
         }
         ControlPacket::UserState(u) => {
             let mut server = STATE.server.write();
@@ -357,13 +381,12 @@ fn accept_packet(
             let state = state_entry.or_default();
             // the server might now send a channel_id if the user is in channel=0
             if u.has_channel_id() || new {
-                if let Some(parent) = server.channels_state.channels.get_mut(&state.channel) {
+                if let Some(parent) = server.channels.get_mut(&state.channel) {
                     parent.users.remove(&id);
                 }
 
                 let channel_id = u.get_channel_id();
                 server
-                    .channels_state
                     .channels
                     .entry(channel_id)
                     .or_default()
@@ -395,7 +418,7 @@ fn accept_packet(
             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) {
+                if let Some(parent) = server.channels.get_mut(&state.channel) {
                     parent.users.remove(&id);
                 }
             }

gui/src/main.rs

@@ -1,6 +1,6 @@
-use mumble_web2_gui::{app, imp::Platform, imp::PlatformInterface as _};
+use mumble_web2_gui::{app, imp};
 
 pub fn main() {
-    Platform::init_logging();
+    imp::init_logging();
     dioxus::launch(app::app);
 }