Load status from relative url (#5)

Remove public_url config option
Use proxy_url instead for example configs
Get status from relative endpoint, like /config
Show version on login page

Reviewed-on: #5
Co-authored-by: Sam Sartor <me@samsartor.com>
Co-committed-by: Sam Sartor <me@samsartor.com>

gui/src/imp/desktop.rs

@@ -1,11 +1,11 @@
 use crate::app::Command;
 use crate::effects::{AudioProcessor, AudioProcessorSender};
-use color_eyre::eyre::{eyre, Context, Error};
+use color_eyre::eyre::{bail, eyre, Context, Error};
 use cpal::traits::{DeviceTrait, HostTrait, StreamTrait as _};
 use dioxus::hooks::UnboundedReceiver;
 use futures::io::{AsyncRead, AsyncWrite};
 use mumble_protocol::control::ClientControlCodec;
-use mumble_web2_common::ClientConfig;
+use mumble_web2_common::{ClientConfig, ServerStatus};
 use std::mem::replace;
 use std::net::ToSocketAddrs;
 use std::sync::Arc;
@@ -64,26 +64,34 @@ impl AudioSystem {
         self.processors.store(Some(processor))
     }
 
-    fn choose_config(&self, configs: impl Iterator<Item=cpal::SupportedStreamConfigRange>) -> Result<cpal::StreamConfig, Error> {
+    fn choose_config(
+        &self,
+        configs: impl Iterator<Item = cpal::SupportedStreamConfigRange>,
+    ) -> Result<cpal::StreamConfig, Error> {
         let mut supported_configs: Vec<_> = configs
             .filter_map(|cfg| cfg.try_with_sample_rate(cpal::SampleRate(SAMPLE_RATE)))
             .filter(|cfg| cfg.sample_format() == cpal::SampleFormat::I16)
-            .map(|cfg| {
-                cpal::StreamConfig {
-                    buffer_size: cpal::BufferSize::Fixed(match *cfg.buffer_size() {
-                        cpal::SupportedBufferSize::Range { min, max } => 480.clamp(min, max),
-                        cpal::SupportedBufferSize::Unknown => 480,
-                    }),
-                    ..cfg.config()
-                }
+            .map(|cfg| cpal::StreamConfig {
+                buffer_size: cpal::BufferSize::Fixed(match *cfg.buffer_size() {
+                    cpal::SupportedBufferSize::Range { min, max } => 480.clamp(min, max),
+                    cpal::SupportedBufferSize::Unknown => 480,
+                }),
+                ..cfg.config()
             })
             .collect();
         supported_configs.sort_by(|a, b| {
-            let cpal::BufferSize::Fixed(a_buf) = a.buffer_size else { unreachable!() };
-            let cpal::BufferSize::Fixed(b_buf) = b.buffer_size else { unreachable!() };
+            let cpal::BufferSize::Fixed(a_buf) = a.buffer_size else {
+                unreachable!()
+            };
+            let cpal::BufferSize::Fixed(b_buf) = b.buffer_size else {
+                unreachable!()
+            };
             Ord::cmp(&a.channels, &b.channels).then(Ord::cmp(&a_buf, &b_buf))
         });
-        supported_configs.get(0).cloned().ok_or(eyre!("no supported stream configs"))
+        supported_configs
+            .get(0)
+            .cloned()
+            .ok_or(eyre!("no supported stream configs"))
     }
 
     pub fn start_recording(
@@ -91,7 +99,11 @@ impl AudioSystem {
         mut each: impl FnMut(Vec<u8>) + Send + 'static,
     ) -> Result<(), Error> {
         let config = self.choose_config(self.input.supported_input_configs()?)?;
-        info!("creating recording on {:?} with {:#?}", self.input.name()?, config);
+        info!(
+            "creating recording on {:?} with {:#?}",
+            self.input.name()?,
+            config
+        );
         let mut encoder =
             opus::Encoder::new(SAMPLE_RATE, opus::Channels::Mono, opus::Application::Voip)?;
         let mut current_processor = AudioProcessor::new_plain();
@@ -118,12 +130,10 @@ impl AudioSystem {
             }
         };
 
-        match self.input.build_input_stream(
-            &config,
-            data_callback,
-            error_callback,
-            None,
-        ) {
+        match self
+            .input
+            .build_input_stream(&config, data_callback, error_callback, None)
+        {
             Ok(stream) => {
                 stream.play()?;
                 self.recording_stream = Some(stream);
@@ -138,7 +148,11 @@ impl AudioSystem {
 
     pub fn create_player(&mut self) -> Result<AudioPlayer, Error> {
         let config = self.choose_config(self.input.supported_input_configs()?)?;
-        info!("creating player on {:?} with {:#?}", self.output.name().ok(), &config);
+        info!(
+            "creating player on {:?} with {:#?}",
+            self.output.name().ok(),
+            &config
+        );
         let buffer = Arc::new(Mutex::new(dasp_ring_buffer::Bounded::from_raw_parts(
             0,
             0,
@@ -311,12 +325,15 @@ pub fn load_username() -> Option<String> {
 pub async fn load_config() -> color_eyre::Result<ClientConfig> {
     Ok(ClientConfig {
         proxy_url: None,
-        status_url: None,
         cert_hash: None,
         any_server: true,
     })
 }
 
+pub async fn get_status(client: &reqwest::Client) -> color_eyre::Result<ServerStatus> {
+    bail!("status not supported on desktop yet")
+}
+
 pub fn init_logging() {
     use tracing::level_filters::LevelFilter;
     use tracing_subscriber::filter::EnvFilter;

gui/src/imp/web.rs

@@ -6,7 +6,7 @@ use futures::{AsyncRead, AsyncWrite};
 use gloo_timers::future::TimeoutFuture;
 use js_sys::Float32Array;
 use mumble_protocol::control::ClientControlCodec;
-use mumble_web2_common::ClientConfig;
+use mumble_web2_common::{ClientConfig, ServerStatus};
 use reqwest::Url;
 use std::future::Future;
 use std::time::Duration;
@@ -426,6 +426,15 @@ pub async fn load_config() -> color_eyre::Result<ClientConfig> {
     Ok(config)
 }
 
+pub async fn get_status(client: &reqwest::Client) -> color_eyre::Result<ServerStatus> {
+    Ok(client
+        .get(absolute_url("status")?)
+        .send()
+        .await?
+        .json::<ServerStatus>()
+        .await?)
+}
+
 pub fn init_logging() {
     // copied from tracing_web example usage