From c1f337791462e991eb901e008d92f8d10d7e3794 Mon Sep 17 00:00:00 2001 From: Dandaedre Date: Fri, 16 Oct 2026 19:05:29 +0200 Subject: [PATCH] feat: bootstrap controllers from MIDI discovery Adopt a sole MIDI input when creating a managed profile, publish other unclaimed inputs to Config, and let the user add them as durable surfaces. Legacy empty profiles can add a safe Master fader, then Save and use the existing MIDI Learn flow without editing TOML. Tests: cargo test --workspace --all-targets --all-features; cargo test --workspace --doc --all-features; cargo clippy --workspace --all-targets --all-features -- -D warnings; cargo build --workspace --release --all-features; default/no-default/midir/pulse cargo checks --- architecture.md | 7 + config/src/document.rs | 55 +++++++ config/tests/editor.rs | 28 ++++ docs/configuration.md | 15 +- fader_master/src/application.rs | 120 +++++++++++++- fader_master/src/editor.rs | 56 +++++++ fader_master/src/ipc.rs | 25 ++- fader_master/src/live.rs | 11 ++ fader_master/src/local.rs | 2 + fader_master/src/midi_runtime.rs | 73 ++++++++- fader_master/src/tui_client.rs | 33 ++++ task.md | 5 + tui/examples/doc_screenshots.rs | 1 + tui/src/lib.rs | 271 ++++++++++++++++++++++++++++++- 14 files changed, 689 insertions(+), 13 deletions(-) diff --git a/architecture.md b/architecture.md index bd85ab2..9fa0258 100644 --- a/architecture.md +++ b/architecture.md @@ -440,6 +440,13 @@ backend IDs/errors. The compact mixer status line distinguishes connected, connecting, missing, ambiguous, and failed devices, adding a connect/select action where the user can resolve the state. +Unclaimed MIDI input ports are also published with their current backend ID, +stable port name, and available USB identity. Config can add one as a durable +surface draft; the first added surface becomes the default controller, and Save +rebuilds the MIDI runtime before Learn is enabled. On creation of a missing +managed profile, exactly one discovered input is adopted automatically. No +choice is guessed when discovery returns zero or multiple inputs. + Terminal restoration is guarded around all fallible client/run work after terminal initialization. The restore action is injectable for failure-path tests; client and transport diagnostics stay in the rendered status area rather diff --git a/config/src/document.rs b/config/src/document.rs index 99f7844..6b51549 100644 --- a/config/src/document.rs +++ b/config/src/document.rs @@ -119,6 +119,61 @@ pickup_tolerance = 0.02 }) } + /// Adds a discovered MIDI input as a durable control surface. + #[allow(clippy::too_many_arguments)] + pub fn add_surface( + &mut self, + id: &str, + label: &str, + input_port: &str, + output_port: Option<&str>, + usb_vendor_id: Option<&str>, + usb_product_id: Option<&str>, + usb_serial: Option<&str>, + usb_path: Option<&str>, + manual_backend_id: Option<&str>, + ) -> Result<(), ConfigError> { + self.transaction(|document| { + if document.get("surfaces").is_none() { + document["surfaces"] = Item::ArrayOfTables(ArrayOfTables::new()); + } + let surfaces = document + .get_mut("surfaces") + .and_then(Item::as_array_of_tables_mut) + .ok_or_else(|| ConfigError::validation("surfaces", "must be an array of tables"))?; + let mut table = Table::new(); + table["id"] = value(id); + table["label"] = value(label); + table["input_port"] = value(input_port); + if let Some(output_port) = output_port { + table["output_port"] = value(output_port); + } + if let Some(vendor) = usb_vendor_id { + table["usb_vendor_id"] = value(vendor); + } + if let Some(product) = usb_product_id { + table["usb_product_id"] = value(product); + } + if let Some(serial) = usb_serial { + table["usb_serial"] = value(serial); + } + if let Some(path) = usb_path { + table["usb_path"] = value(path); + } + if let Some(backend_id) = manual_backend_id { + table["manual_backend_id"] = value(backend_id); + } + table["identity_policy"] = value(if manual_backend_id.is_some() { + "manual" + } else { + "require_unique" + }); + table["motorized"] = value(false); + surfaces.push(table); + Ok(()) + }) + } + /// Changes one application's display label without rebuilding its table. pub fn set_application_label( &mut self, diff --git a/config/tests/editor.rs b/config/tests/editor.rs index 70dea12..dc320fd 100644 --- a/config/tests/editor.rs +++ b/config/tests/editor.rs @@ -5,6 +5,34 @@ use fader_config::{ const PROFILE: &str = include_str!("../../examples/profiles/desktop.toml"); +#[test] +fn draft_adds_a_discovered_midi_surface_with_durable_identity() { + let mut draft = ProfileDocument::empty("default").unwrap(); + draft + .add_surface( + "apc-mini", + "APC MINI", + "APC MINI:APC MINI MIDI 1", + Some("APC MINI:APC MINI MIDI 1"), + Some("09e8"), + Some("0028"), + Some("Ver00.10"), + Some("pci-0000:00:14.0-usb-0:1"), + Some("36:0"), + ) + .unwrap(); + draft.set_default_controller(Some("apc-mini")).unwrap(); + + let profile = draft.preview().unwrap(); + let surface = &profile.surfaces()[0]; + assert_eq!(surface.id(), "apc-mini"); + assert_eq!(surface.input_port(), "APC MINI:APC MINI MIDI 1"); + assert_eq!(surface.output_port(), Some("APC MINI:APC MINI MIDI 1")); + assert_eq!(surface.usb_serial(), Some("Ver00.10")); + assert_eq!(surface.manual_backend_id(), Some("36:0")); + assert_eq!(profile.default_controller(), Some("apc-mini")); +} + #[test] fn draft_creates_an_application_group_and_fader_as_valid_toml() { let mut draft = ProfileDocument::parse(PROFILE).unwrap(); diff --git a/docs/configuration.md b/docs/configuration.md index 3c889a9..a32d65b 100644 --- a/docs/configuration.md +++ b/docs/configuration.md @@ -45,9 +45,18 @@ Without `--config`, fader_master uses the XDG layout: when they are absolute. A runtime directory is required for the standalone local socket; no shared `/tmp` fallback is invented. -On first managed startup, a valid empty `default` profile and active selection -are created. If the active selection names a missing managed profile, an empty -profile with that validated ID is recreated. An explicitly supplied missing +On first managed startup, a valid `default` profile and active selection are +created. The profile starts with a safe Master-output fader. If exactly one MIDI +input is visible, its port and available USB identity are adopted as the default +controller; zero or multiple inputs are left for the user to choose. Config +lists unconfigured inputs under **Detected MIDI ports**: open one, choose **Add +as controller**, Save, then edit the Master fader and use Learn MIDI for volume +and mute. This is enough to get a new installation working without editing TOML. +Profiles created by an older version with no faders expose **Add Master output +fader** in Config and can use the same setup path. + +If the active selection names a missing managed profile, the same first-run +profile is recreated with that validated ID. An explicitly supplied missing `--config` path remains an error so a typo cannot silently create a new file. Switch an existing server to another managed profile with: diff --git a/fader_master/src/application.rs b/fader_master/src/application.rs index 7d3b091..a19d8d5 100644 --- a/fader_master/src/application.rs +++ b/fader_master/src/application.rs @@ -15,7 +15,7 @@ use fader_config::{ upgrade_profile, }; use fader_core::Gain; -use midi::{LinuxIdentityCatalog, MidiInputCatalog}; +use midi::{LinuxIdentityCatalog, MidiInputCatalog, PortIdentity}; use volume_lib::{AudioBackend, CompiledAdapterProbe, TargetRequirements, select_adapter}; use crate::{ @@ -238,9 +238,83 @@ fn initialize_missing_profile(path: &Path, id: &str) -> Result<()> { .with_context(|| format!("could not inspect profile {}", path.display())); } } - let source = ProfileDocument::empty(id)?.finish()?; + let mut document = ProfileDocument::empty(id)?; + if let Some(identity) = discover_single_midi_surface() { + add_discovered_surface(&mut document, &identity)?; + } + let source = document.finish()?; AtomicFile::write(path, source.as_bytes()) - .with_context(|| format!("could not initialize empty profile {}", path.display())) + .with_context(|| format!("could not initialize profile {}", path.display())) +} + +fn discover_single_midi_surface() -> Option { + let catalog = MidiInputCatalog::new("fader_master first-run discovery").ok()?; + let ports = catalog.ports().ok()?; + if ports.len() != 1 { + return None; + } + let identities = LinuxIdentityCatalog::new().ok()?; + identities.inspect(&ports[0]).ok() +} + +fn add_discovered_surface(document: &mut ProfileDocument, identity: &PortIdentity) -> Result<()> { + let name = stable_midi_port_name(&identity.name); + let id = midi_surface_id(name); + let usb = identity.usb.as_ref(); + document.add_surface( + &id, + name, + name, + Some(name), + usb.map(|value| value.vendor_id.as_str()), + usb.map(|value| value.product_id.as_str()), + usb.and_then(|value| value.serial.as_deref()), + usb.and_then(|value| value.path.as_deref()), + Some(&identity.backend_id), + )?; + document.set_default_controller(Some(&id))?; + Ok(()) +} + +fn stable_midi_port_name(name: &str) -> &str { + let Some((prefix, suffix)) = name.rsplit_once(' ') else { + return name; + }; + let Some((client, port)) = suffix.split_once(':') else { + return name; + }; + if !client.is_empty() + && !port.is_empty() + && client.bytes().all(|byte| byte.is_ascii_digit()) + && port.bytes().all(|byte| byte.is_ascii_digit()) + { + prefix + } else { + name + } +} + +fn midi_surface_id(name: &str) -> String { + let mut id = String::new(); + let mut separator = false; + for character in name.chars() { + if character.is_ascii_alphanumeric() { + if separator && !id.is_empty() && id.len() < 63 { + id.push('-'); + } + separator = false; + if id.len() < 64 { + id.push(character.to_ascii_lowercase()); + } + } else { + separator = true; + } + } + if id.is_empty() { + "midi-controller".to_owned() + } else { + id + } } fn build_server( @@ -393,9 +467,47 @@ mod tests { use std::{cell::Cell, fs}; use fader_config::{ActiveConfig, ProfileDocument, XdgEnvironment, XdgPaths}; + use midi::{PortIdentity, UsbDeviceIdentity}; use tempfile::tempdir; - use super::{load_profile_document, resolve_managed_profile, start_if_missing}; + use super::{ + add_discovered_surface, load_profile_document, midi_surface_id, resolve_managed_profile, + stable_midi_port_name, start_if_missing, + }; + + #[test] + fn first_run_guess_uses_one_discovered_controller_and_durable_identity() { + let mut document = ProfileDocument::empty("default").unwrap(); + add_discovered_surface( + &mut document, + &PortIdentity { + backend_id: "36:0".to_owned(), + name: "APC MINI:APC MINI MIDI 1 36:0".to_owned(), + usb: Some(UsbDeviceIdentity { + vendor_id: "09e8".to_owned(), + product_id: "0028".to_owned(), + serial: Some("Ver00.10".to_owned()), + path: Some("pci-usb-0:1".to_owned()), + }), + }, + ) + .unwrap(); + + let profile = document.preview().unwrap(); + assert_eq!( + profile.default_controller(), + Some("apc-mini-apc-mini-midi-1") + ); + assert_eq!(profile.surfaces()[0].label(), "APC MINI:APC MINI MIDI 1"); + assert_eq!(profile.surfaces()[0].usb_serial(), Some("Ver00.10")); + assert_eq!(profile.surfaces()[0].manual_backend_id(), Some("36:0")); + assert_eq!(profile.faders()[0].id(), "master-fader"); + assert_eq!( + stable_midi_port_name("Controller Port 24:3"), + "Controller Port" + ); + assert_eq!(midi_surface_id(" !!! "), "midi-controller"); + } #[test] fn combined_mode_only_starts_a_server_when_probe_did_not_find_one() { diff --git a/fader_master/src/editor.rs b/fader_master/src/editor.rs index dc61c50..30b1e38 100644 --- a/fader_master/src/editor.rs +++ b/fader_master/src/editor.rs @@ -71,6 +71,32 @@ impl ConfigurationEditor { }); } match edit { + ConfigurationEdit::AddSurface { + id, + label, + input_port, + output_port, + usb_vendor_id, + usb_product_id, + usb_serial, + usb_path, + manual_backend_id, + } => { + self.document.add_surface( + &id, + &label, + &input_port, + output_port.as_deref(), + usb_vendor_id.as_deref(), + usb_product_id.as_deref(), + usb_serial.as_deref(), + usb_path.as_deref(), + manual_backend_id.as_deref(), + )?; + if self.document.preview()?.default_controller().is_none() { + self.document.set_default_controller(Some(&id))?; + } + } ConfigurationEdit::AddApplication { id, label, @@ -337,6 +363,36 @@ mod tests { const PROFILE: &str = include_str!("../../examples/profiles/desktop.toml"); + #[test] + fn discovered_surface_edit_bootstraps_the_default_controller() { + let root = tempdir().unwrap(); + let path = root.path().join("default.toml"); + let document = ProfileDocument::empty("default").unwrap(); + fs::write(&path, document.source()).unwrap(); + let mut editor = ConfigurationEditor::new(document, path); + + let profile = editor + .apply( + 0, + ConfigurationEdit::AddSurface { + id: "apc-mini".into(), + label: "APC MINI".into(), + input_port: "APC MINI:APC MINI MIDI 1".into(), + output_port: Some("APC MINI:APC MINI MIDI 1".into()), + usb_vendor_id: Some("09e8".into()), + usb_product_id: Some("0028".into()), + usb_serial: Some("Ver00.10".into()), + usb_path: None, + manual_backend_id: Some("36:0".into()), + }, + ) + .unwrap(); + + assert_eq!(profile.surfaces()[0].id(), "apc-mini"); + assert_eq!(profile.default_controller(), Some("apc-mini")); + assert!(editor.dirty()); + } + #[test] fn accepted_edits_advance_revision_and_stale_or_invalid_edits_do_not() { let root = tempdir().unwrap(); diff --git a/fader_master/src/ipc.rs b/fader_master/src/ipc.rs index 0e19414..d4e182d 100644 --- a/fader_master/src/ipc.rs +++ b/fader_master/src/ipc.rs @@ -3,7 +3,7 @@ use std::io::{self, Read, Write}; use serde::{Deserialize, Serialize, de::DeserializeOwned}; use thiserror::Error; -pub const PROTOCOL_VERSION: u16 = 16; +pub const PROTOCOL_VERSION: u16 = 17; pub const MAX_FRAME_BYTES: usize = 64 * 1024; /// Kind of mixer object addressed by a client. @@ -74,6 +74,17 @@ pub enum RequestCommand { #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)] #[serde(tag = "operation", rename_all = "snake_case")] pub enum ConfigurationEdit { + AddSurface { + id: String, + label: String, + input_port: String, + output_port: Option, + usb_vendor_id: Option, + usb_product_id: Option, + usb_serial: Option, + usb_path: Option, + manual_backend_id: Option, + }, AddApplication { id: String, label: String, @@ -202,6 +213,8 @@ pub struct MixerSnapshot { pub status: String, pub objects: Vec, pub devices: Vec, + #[serde(default)] + pub discovered_midi_ports: Vec, pub configuration: ConfigurationSnapshot, } @@ -314,6 +327,16 @@ pub struct MidiDevice { pub error: Option, } +#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)] +pub struct DiscoveredMidiPort { + pub backend_id: String, + pub name: String, + pub usb_vendor_id: Option, + pub usb_product_id: Option, + pub usb_serial: Option, + pub usb_path: Option, +} + #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)] pub struct MixerObject { pub object: MixerObjectKey, diff --git a/fader_master/src/live.rs b/fader_master/src/live.rs index 5381cb8..7d90227 100644 --- a/fader_master/src/live.rs +++ b/fader_master/src/live.rs @@ -64,6 +64,7 @@ pub struct LiveMixerState { faders: BTreeMap, pickups: BTreeMap<(SurfaceId, FaderId), Pickup>, devices: Vec, + discovered_midi_ports: Vec, write_ceiling: Gain, backend: String, status: String, @@ -340,6 +341,7 @@ impl LiveMixerState { faders, pickups, devices: Vec::new(), + discovered_midi_ports: Vec::new(), write_ceiling, backend: backend.into(), status: "connecting".to_owned(), @@ -481,6 +483,7 @@ impl LiveMixerState { status: self.status.clone(), objects, devices: self.devices.clone(), + discovered_midi_ports: self.discovered_midi_ports.clone(), configuration: self.configuration.clone(), } } @@ -506,6 +509,10 @@ impl LiveMixerState { self.devices = devices; } + pub fn set_discovered_midi_ports(&mut self, ports: Vec) { + self.discovered_midi_ports = ports; + } + pub(crate) fn set_configuration(&mut self, configuration: ConfigurationSnapshot) { self.configuration = configuration; } @@ -523,6 +530,10 @@ impl LiveMixerState { std::mem::swap(&mut replacement.output, &mut self.output); std::mem::swap(&mut replacement.status, &mut self.status); std::mem::swap(&mut replacement.devices, &mut self.devices); + std::mem::swap( + &mut replacement.discovered_midi_ports, + &mut self.discovered_midi_ports, + ); replacement.configuration = self.configuration.clone(); replacement.revision_offset = next_revision.saturating_sub(replacement.reducer.revision().get()); diff --git a/fader_master/src/local.rs b/fader_master/src/local.rs index a4dc463..f83c129 100644 --- a/fader_master/src/local.rs +++ b/fader_master/src/local.rs @@ -312,6 +312,8 @@ impl LocalServer { self.flush_dispatch(); self.midi.sync_feedback(&self.mixer.snapshot()); self.mixer.set_devices(self.midi.snapshot()); + self.mixer + .set_discovered_midi_ports(self.midi.discovered_ports()); while let Some(mut client) = self.listener.accept()? { let _ = client.set_read_timeout(Some(SERVER_CLIENT_TIMEOUT)); let _ = client.set_write_timeout(Some(SERVER_CLIENT_TIMEOUT)); diff --git a/fader_master/src/midi_runtime.rs b/fader_master/src/midi_runtime.rs index b02f288..436d2fd 100644 --- a/fader_master/src/midi_runtime.rs +++ b/fader_master/src/midi_runtime.rs @@ -12,10 +12,10 @@ use fader_core::{ use midi::{ ButtonEdge, DeviceMatch, LinuxIdentityCatalog, MidiInputCatalog, MidiInputConnection, MidiInputEvent, MidiIntent, MidiMessage, MidiOutputCatalog, MidiOutputConnection, MidiRouter, - SurfaceAction, SurfaceAssignment, SurfaceLifecycle, SurfaceStatus, + PortIdentity, SurfaceAction, SurfaceAssignment, SurfaceLifecycle, SurfaceStatus, }; -use crate::ipc::{MidiDevice, MixerObjectKey, MixerObjectKind, MixerSnapshot}; +use crate::ipc::{DiscoveredMidiPort, MidiDevice, MixerObjectKey, MixerObjectKind, MixerSnapshot}; const SCAN_INTERVAL: Duration = Duration::from_secs(1); const EVENT_CAPACITY: usize = 256; @@ -29,6 +29,7 @@ pub struct MidiRuntime { output_connections: BTreeMap, output_backend_ids: BTreeMap, output_errors: BTreeMap, + discovered_ports: Vec, sender: SyncSender, receiver: Receiver, last_scan: Option, @@ -254,6 +255,7 @@ impl MidiRuntime { output_connections: BTreeMap::new(), output_backend_ids: BTreeMap::new(), output_errors: BTreeMap::new(), + discovered_ports: Vec::new(), sender, receiver, last_scan: None, @@ -398,6 +400,21 @@ impl MidiRuntime { .collect() } + #[must_use] + pub fn discovered_ports(&self) -> Vec { + self.discovered_ports + .iter() + .map(|port| DiscoveredMidiPort { + backend_id: port.backend_id.clone(), + name: stable_port_name(&port.name).to_owned(), + usb_vendor_id: port.usb.as_ref().map(|usb| usb.vendor_id.clone()), + usb_product_id: port.usb.as_ref().map(|usb| usb.product_id.clone()), + usb_serial: port.usb.as_ref().and_then(|usb| usb.serial.clone()), + usb_path: port.usb.as_ref().and_then(|usb| usb.path.clone()), + }) + .collect() + } + fn scan(&mut self) { let input_error = self.discover_and_reconcile().err(); if let Err(error) = self.discover_and_reconcile_outputs() { @@ -431,6 +448,7 @@ impl MidiRuntime { } } } + self.discovered_ports = unclaimed_ports(visible, &self.lifecycle); Ok(()) } @@ -571,6 +589,22 @@ impl MidiRuntime { } } +fn unclaimed_ports(visible: Vec, lifecycle: &SurfaceLifecycle) -> Vec { + let claimed = lifecycle + .statuses() + .filter_map(|(_, status)| match status { + SurfaceStatus::Connecting { backend_id, .. } + | SurfaceStatus::Connected { backend_id, .. } + | SurfaceStatus::Error { backend_id, .. } => Some(backend_id), + SurfaceStatus::Missing | SurfaceStatus::Ambiguous { .. } => None, + }) + .collect::>(); + visible + .into_iter() + .filter(|port| !claimed.contains(&port.backend_id)) + .collect() +} + fn stable_port_name(name: &str) -> &str { let Some((prefix, suffix)) = name.rsplit_once(' ') else { return name; @@ -597,6 +631,41 @@ mod tests { use fader_core::{MidiChannel, MidiData}; use midi::{ButtonEdge, MidiMessage}; + #[test] + fn discovery_exposes_only_ports_not_claimed_by_configured_surfaces() { + let surface = SurfaceId::new("configured").unwrap(); + let mut lifecycle = SurfaceLifecycle::new([SurfaceAssignment { + surface, + expected: DeviceMatch { + port_name: "Configured Controller".into(), + vendor_id: None, + product_id: None, + serial: None, + path: None, + }, + manual_backend_id: None, + }]) + .unwrap(); + let visible = vec![ + PortIdentity { + backend_id: "20:0".into(), + name: "Configured Controller".into(), + usb: None, + }, + PortIdentity { + backend_id: "36:0".into(), + name: "New Controller".into(), + usb: None, + }, + ]; + lifecycle.reconcile(&visible); + + let available = unclaimed_ports(visible, &lifecycle); + + assert_eq!(available.len(), 1); + assert_eq!(available[0].backend_id, "36:0"); + } + #[test] fn configured_surfaces_exist_as_missing_before_native_discovery() { let profile = diff --git a/fader_master/src/tui_client.rs b/fader_master/src/tui_client.rs index 48f7cbb..76e1770 100644 --- a/fader_master/src/tui_client.rs +++ b/fader_master/src/tui_client.rs @@ -89,6 +89,18 @@ impl IpcMixerClient { error: device.error, }) .collect(), + discovered_midi_ports: snapshot + .discovered_midi_ports + .into_iter() + .map(|port| tui::DiscoveredMidiPort { + backend_id: port.backend_id, + name: port.name, + usb_vendor_id: port.usb_vendor_id, + usb_product_id: port.usb_product_id, + usb_serial: port.usb_serial, + usb_path: port.usb_path, + }) + .collect(), configuration: tui::ConfigurationSnapshot { revision: snapshot.configuration.revision, dirty: snapshot.configuration.dirty, @@ -296,6 +308,27 @@ impl MixerClient for IpcMixerClient { fn configuration_edit(edit: TuiConfigurationEdit) -> crate::ipc::ConfigurationEdit { use crate::ipc::ConfigurationEdit as IpcEdit; match edit { + TuiConfigurationEdit::AddSurface { + id, + label, + input_port, + output_port, + usb_vendor_id, + usb_product_id, + usb_serial, + usb_path, + manual_backend_id, + } => IpcEdit::AddSurface { + id, + label, + input_port, + output_port, + usb_vendor_id, + usb_product_id, + usb_serial, + usb_path, + manual_backend_id, + }, TuiConfigurationEdit::Application { existing, id, diff --git a/task.md b/task.md index 869ba39..ebc8241 100644 --- a/task.md +++ b/task.md @@ -484,6 +484,11 @@ Dependencies: all required feature milestones; hardware-only ALSA remains an exp an exact `.v0.bak` backup, and atomic replacement. New managed profiles include a safe default-output fader so first-run setup has an editable mixer target before any application or controller is known. + Exactly one discoverable MIDI input is adopted with its durable identity; + ambiguous first-run discovery remains unchanged. Unconfigured inputs are + otherwise listed in Config and can be added, saved, and assigned through the + existing MIDI Learn workflow without editing TOML. Config also repairs legacy + empty profiles by offering a safe Master-output fader. - [ ] **M12.4 Release gates:** all workspace/default/feature/MSRV checks, reproducible lockfile, license review and dependency advisory review using maintained tooling selected at implementation time. Measure/control latency under multi-surface load and publish the tested envelope. ## User requirement coverage diff --git a/tui/examples/doc_screenshots.rs b/tui/examples/doc_screenshots.rs index 46b71f9..6b3475b 100644 --- a/tui/examples/doc_screenshots.rs +++ b/tui/examples/doc_screenshots.rs @@ -133,6 +133,7 @@ fn snapshot(mixer_orientation: MixerOrientation) -> MixerSnapshot { backend_id: Some("24:0".to_owned()), error: None, }], + discovered_midi_ports: Vec::new(), configuration: ConfigurationSnapshot { revision: 7, dirty: false, diff --git a/tui/src/lib.rs b/tui/src/lib.rs index 9372438..d655ac6 100644 --- a/tui/src/lib.rs +++ b/tui/src/lib.rs @@ -78,6 +78,16 @@ pub struct MidiDevice { pub error: Option, } +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct DiscoveredMidiPort { + pub backend_id: String, + pub name: String, + pub usb_vendor_id: Option, + pub usb_product_id: Option, + pub usb_serial: Option, + pub usb_path: Option, +} + #[derive(Clone, Debug, Default, PartialEq)] pub struct ConfigurationSnapshot { pub revision: u64, @@ -221,6 +231,17 @@ pub struct ConfiguredBinding { #[derive(Clone, Debug, PartialEq)] pub enum ConfigurationEdit { + AddSurface { + id: String, + label: String, + input_port: String, + output_port: Option, + usb_vendor_id: Option, + usb_product_id: Option, + usb_serial: Option, + usb_path: Option, + manual_backend_id: Option, + }, Application { existing: bool, id: String, @@ -309,6 +330,7 @@ pub struct MixerSnapshot { pub error: Option, pub items: Vec, pub devices: Vec, + pub discovered_midi_ports: Vec, pub configuration: ConfigurationSnapshot, } @@ -423,6 +445,7 @@ impl BufferedMixerClient { error: None, items: Vec::new(), devices: Vec::new(), + discovered_midi_ports: Vec::new(), configuration: ConfigurationSnapshot::default(), }; let shared = Arc::new(( @@ -908,9 +931,11 @@ enum SettingsRow { DefaultController, HiddenFaders { count: usize }, ActiveProfile, + AddMasterFader, CancelMidiLearn, Save, MidiDevice { id: String }, + DiscoveredMidiPort { backend_id: String }, } #[derive(Clone, Debug, Eq, PartialEq)] @@ -1464,6 +1489,9 @@ impl LiveTui { if self.snapshot.configuration.learning.is_some() { rows.push(SettingsRow::CancelMidiLearn); } + if self.snapshot.configuration.faders.is_empty() { + rows.push(SettingsRow::AddMasterFader); + } rows.push(SettingsRow::Save); rows.extend( self.snapshot @@ -1473,6 +1501,11 @@ impl LiveTui { id: device.id.clone(), }), ); + rows.extend(self.snapshot.discovered_midi_ports.iter().map(|port| { + SettingsRow::DiscoveredMidiPort { + backend_id: port.backend_id.clone(), + } + })); rows } @@ -1559,10 +1592,25 @@ impl LiveTui { self.profile_picker = Some(ProfilePicker { selected }); } SettingsRow::CancelMidiLearn if forward => self.cancel_midi_learn(), + SettingsRow::AddMasterFader if forward => { + self.apply_layout_edit(ConfigurationEdit::Fader { + existing: false, + id: "master-fader".to_owned(), + target: MixerObjectId { + kind: MixerObjectKind::Output, + id: "default".to_owned(), + }, + pickup: true, + pickup_tolerance: 0.02, + }); + } SettingsRow::Save if forward => self.save_configuration(), SettingsRow::MidiDevice { id } if forward => { self.midi_device_details = Some(id); } + SettingsRow::DiscoveredMidiPort { backend_id } if forward => { + self.midi_device_details = Some(backend_id); + } _ => {} } } @@ -1669,6 +1717,34 @@ impl LiveTui { let Some(id) = self.midi_device_details.clone() else { return; }; + if let Some(port) = self + .snapshot + .discovered_midi_ports + .iter() + .find(|port| port.backend_id == id) + .cloned() + { + match code { + KeyCode::Esc => self.midi_device_details = None, + KeyCode::Enter => { + let surface_id = unique_surface_id(&port.name, &self.snapshot.devices); + self.apply_layout_edit(ConfigurationEdit::AddSurface { + id: surface_id, + label: port.name.clone(), + input_port: port.name.clone(), + output_port: Some(port.name), + usb_vendor_id: port.usb_vendor_id, + usb_product_id: port.usb_product_id, + usb_serial: port.usb_serial, + usb_path: port.usb_path, + manual_backend_id: Some(port.backend_id), + }); + self.midi_device_details = None; + } + _ => {} + } + return; + } if !self.snapshot.devices.iter().any(|device| device.id == id) { if code == KeyCode::Esc { self.midi_device_details = None; @@ -2607,6 +2683,40 @@ fn unique_separator_id(label: &str, layout: &[MixerLayoutEntry]) -> String { .unwrap_or_else(|| "separator-id-exhausted".to_owned()) } +fn unique_surface_id(name: &str, devices: &[MidiDevice]) -> String { + let base = name + .chars() + .filter_map(|character| { + if character.is_ascii_alphanumeric() { + Some(character.to_ascii_lowercase()) + } else if character.is_ascii_whitespace() || matches!(character, '-' | '_' | ':') { + Some('-') + } else { + None + } + }) + .take(56) + .collect::() + .trim_matches('-') + .to_owned(); + let base = if base.is_empty() { + "midi-controller".to_owned() + } else { + base + }; + let used = devices + .iter() + .map(|device| device.id.as_str()) + .collect::>(); + if !used.contains(base.as_str()) { + return base; + } + (2..) + .map(|suffix| format!("{base}-{suffix}")) + .find(|candidate| !used.contains(candidate.as_str())) + .unwrap_or_else(|| "midi-controller-id-exhausted".to_owned()) +} + fn centered_rect(area: Rect, width: u16, height: u16) -> Rect { let width = width.min(area.width); let height = height.min(area.height); @@ -3069,6 +3179,43 @@ impl LiveTui { return; }; let theme = self.theme.palette(); + if let Some(port) = self + .snapshot + .discovered_midi_ports + .iter() + .find(|port| &port.backend_id == id) + { + let usb = match (&port.usb_vendor_id, &port.usb_product_id) { + (Some(vendor), Some(product)) => format!("{vendor}:{product}"), + _ => "Unavailable".to_owned(), + }; + let popup = centered_rect(area, 68, 10); + Clear.render(popup, buf); + Paragraph::new(Text::from(vec![ + Line::from(port.name.as_str()).bold(), + Line::from("Not configured"), + Line::from(format!("Backend port {}", port.backend_id)), + Line::from(format!("USB identity {usb}")), + Line::from(format!( + "Serial {}", + port.usb_serial.as_deref().unwrap_or("Unavailable") + )), + Line::from(""), + Line::from("▶ Add as controller [Enter]") + .fg(theme.accent) + .bold(), + ])) + .block( + Block::bordered() + .title(" Detected MIDI port ".fg(theme.accent).bold()) + .title_bottom(" Enter add · Esc close ".fg(theme.muted)) + .border_set(border::DOUBLE) + .border_style(Style::default().fg(theme.accent)) + .style(Style::default().bg(theme.background)), + ) + .render(popup, buf); + return; + } let Some(device) = self.snapshot.devices.iter().find(|device| &device.id == id) else { return; }; @@ -3208,7 +3355,10 @@ impl LiveTui { let settings_rows = self.settings_rows(); let mut selected_line = None; for (index, row) in settings_rows.iter().enumerate() { - if matches!(row, SettingsRow::MidiDevice { .. }) { + if matches!( + row, + SettingsRow::MidiDevice { .. } | SettingsRow::DiscoveredMidiPort { .. } + ) { continue; } let marker = if index == self.settings_selected { @@ -3242,6 +3392,7 @@ impl LiveTui { format!("Active profile {} [Enter]", config.profile_id) } SettingsRow::CancelMidiLearn => "Cancel MIDI learn [Enter]".to_owned(), + SettingsRow::AddMasterFader => "Add Master output fader [Enter]".to_owned(), SettingsRow::Save => format!( "Save changes {}", if config.dirty { @@ -3250,7 +3401,9 @@ impl LiveTui { "already saved" } ), - SettingsRow::MidiDevice { .. } => continue, + SettingsRow::MidiDevice { .. } | SettingsRow::DiscoveredMidiPort { .. } => { + continue; + } }; if index == self.settings_selected { selected_line = Some(lines.len()); @@ -3295,6 +3448,39 @@ impl LiveTui { ); } } + if !self.snapshot.discovered_midi_ports.is_empty() { + lines.push(Line::from("")); + lines.push(Line::from("Detected MIDI ports").fg(theme.accent).bold()); + for (index, row) in settings_rows.iter().enumerate() { + let SettingsRow::DiscoveredMidiPort { backend_id } = row else { + continue; + }; + let Some(port) = self + .snapshot + .discovered_midi_ports + .iter() + .find(|port| &port.backend_id == backend_id) + else { + continue; + }; + let selected = index == self.settings_selected; + if selected { + selected_line = Some(lines.len()); + } + lines.push( + Line::from(format!( + "{} {} — available [Enter]", + if selected { "▶" } else { " " }, + port.name + )) + .style(if selected { + Style::default().fg(theme.accent).bold() + } else { + Style::default().fg(theme.foreground) + }), + ); + } + } let scroll = selected_line .unwrap_or_default() .saturating_add(1) @@ -3712,6 +3898,7 @@ impl DemoClient { error: None, }], devices: Vec::new(), + discovered_midi_ports: Vec::new(), configuration: ConfigurationSnapshot::default(), } } @@ -5134,7 +5321,7 @@ mod tests { }) .unwrap(); app.handle_key_event(press(KeyCode::Tab)); - for _ in 0..6 { + for _ in 0..7 { app.handle_key_event(press(KeyCode::Down)); } app.handle_key_event(press(KeyCode::Enter)); @@ -5187,6 +5374,84 @@ mod tests { ))); } + #[test] + fn detected_midi_port_can_be_added_from_settings() { + let edits = Arc::new(Mutex::new(Vec::new())); + let mut snapshot = DemoClient::default().view(); + snapshot.discovered_midi_ports.push(DiscoveredMidiPort { + backend_id: "36:0".into(), + name: "APC MINI:APC MINI MIDI 1".into(), + usb_vendor_id: Some("09e8".into()), + usb_product_id: Some("0028".into()), + usb_serial: Some("Ver00.10".into()), + usb_path: Some("pci-usb-0:1".into()), + }); + let mut app = LiveTui::new(LayoutClient { + snapshot, + edits: Arc::clone(&edits), + }) + .unwrap(); + app.handle_key_event(press(KeyCode::Tab)); + for _ in 0..7 { + app.handle_key_event(press(KeyCode::Down)); + } + app.handle_key_event(press(KeyCode::Enter)); + + let area = Rect::new(0, 0, 100, 24); + let mut buffer = Buffer::empty(area); + (&app).render(area, &mut buffer); + let rendered = buffer + .content + .iter() + .map(|cell| cell.symbol()) + .collect::(); + assert!(rendered.contains("Detected MIDI port")); + assert!(rendered.contains("Add as controller")); + + app.handle_key_event(press(KeyCode::Enter)); + assert!(matches!( + edits.lock().unwrap().as_slice(), + [ConfigurationEdit::AddSurface { + id, + input_port, + manual_backend_id: Some(backend), + .. + }] if id == "apc-mini-apc-mini-midi-1" + && input_port == "APC MINI:APC MINI MIDI 1" + && backend == "36:0" + )); + } + + #[test] + fn legacy_empty_profile_can_add_a_master_fader_from_settings() { + let edits = Arc::new(Mutex::new(Vec::new())); + let snapshot = DemoClient::default().view(); + let mut app = LiveTui::new(LayoutClient { + snapshot, + edits: Arc::clone(&edits), + }) + .unwrap(); + app.handle_key_event(press(KeyCode::Tab)); + for _ in 0..5 { + app.handle_key_event(press(KeyCode::Down)); + } + app.handle_key_event(press(KeyCode::Enter)); + + assert!(matches!( + edits.lock().unwrap().as_slice(), + [ConfigurationEdit::Fader { + existing: false, + id, + target: MixerObjectId { + kind: MixerObjectKind::Output, + id: target, + }, + pickup: true, + .. + }] if id == "master-fader" && target == "default" + )); + } + #[test] fn configuration_tab_changes_theme_without_raw_object_editors() { let edits = Arc::new(Mutex::new(Vec::new()));