feat(M9.2): learn MIDI controls into server drafts
Rust CI fader_master failed CI.
MadGobblins/fader_master/pipeline/head There was a failure building this commit Details

Test: cargo test -p fader-config --all-targets --all-features

Test: cargo test -p tui --all-targets --all-features

Test: cargo test -p fader_master --all-targets --all-features

Test: cargo clippy -p fader-config -p tui -p fader_master --all-targets --all-features -- -D warnings
This commit is contained in:
Dandaedre 2026-10-15 04:18:12 +02:00
parent 9941a79231
commit fa45944b79
Signed by: Dandaedre
GPG Key ID: 440C6592E8A26D99
9 changed files with 555 additions and 23 deletions

View File

@ -309,6 +309,11 @@ Draft edits are serialized by the server, require the caller's expected draft
revision, and never mutate live routing or audio as a side effect. Successful
draft edits are explicitly marked unsaved until a later apply/save command.
MIDI learn is scoped to one configured surface, logical fader, and action. While
armed, messages from that surface are withheld from normal routing; unrelated
surfaces continue normally. The first compatible CC or note press becomes a
validated draft binding, while cancellation restores routing immediately.
The implemented atomic writer checks that its parent and any existing target
are owned by the effective user and are not symlinks. It creates mode-`0600`
temporary files in the destination directory, streams and syncs their content,

View File

@ -109,6 +109,41 @@ impl ConfigurationEditor {
pickup_tolerance,
)?,
ConfigurationEdit::RemoveFader { id } => self.document.remove_fader(&id)?,
ConfigurationEdit::AddBinding {
surface,
fader,
action,
kind,
channel,
number,
} => self.document.add_binding(
&surface,
&fader,
match action.as_str() {
"volume" => fader_config::Action::Volume,
"toggle_mute" => fader_config::Action::ToggleMute,
_ => {
return Err(ConfigError::Validation {
path: "binding.action".to_owned(),
message: format!("unsupported action {action:?}"),
}
.into());
}
},
match kind.as_str() {
"cc" => fader_config::MessageKind::Cc,
"note" => fader_config::MessageKind::Note,
_ => {
return Err(ConfigError::Validation {
path: "binding.message.kind".to_owned(),
message: format!("unsupported message kind {kind:?}"),
}
.into());
}
},
channel,
number,
)?,
}
self.revision = self.revision.saturating_add(1);
self.dirty = true;

View File

@ -3,7 +3,7 @@ use std::io::{self, Read, Write};
use serde::{Deserialize, Serialize, de::DeserializeOwned};
use thiserror::Error;
pub const PROTOCOL_VERSION: u16 = 6;
pub const PROTOCOL_VERSION: u16 = 7;
pub const MAX_FRAME_BYTES: usize = 64 * 1024;
/// Kind of mixer object addressed by a client.
@ -47,6 +47,12 @@ pub enum RequestCommand {
expected_revision: u64,
edit: ConfigurationEdit,
},
StartMidiLearn {
surface: String,
fader: String,
action: String,
},
CancelMidiLearn,
SetVolume {
object: MixerObjectKey,
gain: f64,
@ -106,6 +112,14 @@ pub enum ConfigurationEdit {
RemoveFader {
id: String,
},
AddBinding {
surface: String,
fader: String,
action: String,
kind: String,
channel: u16,
number: u16,
},
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
@ -136,6 +150,8 @@ pub struct MixerSnapshot {
pub struct ConfigurationSnapshot {
pub revision: u64,
pub dirty: bool,
pub learning: Option<String>,
pub error: Option<String>,
pub profile_id: String,
pub applications: Vec<ConfiguredApplication>,
pub groups: Vec<ConfiguredGroup>,

View File

@ -105,6 +105,8 @@ pub(crate) fn configuration_snapshot(
ConfigurationSnapshot {
revision,
dirty,
learning: None,
error: None,
profile_id: profile.id().to_string(),
applications: profile
.applications()
@ -570,6 +572,11 @@ impl LiveMixerState {
"configuration edits must be handled by the server owner".to_owned(),
));
}
RequestCommand::StartMidiLearn { .. } | RequestCommand::CancelMidiLearn => {
return Err(LiveMixerError::Profile(
"MIDI learn commands must be handled by the server owner".to_owned(),
));
}
RequestCommand::SetVolume {
object,
gain,

View File

@ -10,7 +10,7 @@ use std::{
};
use fader_config::{ProfileDocument, XdgEnvironment, XdgPaths};
use fader_core::{BackendEpoch, Gain};
use fader_core::{BackendEpoch, FaderId, Gain, SurfaceId};
use thiserror::Error;
use volume_lib::{AdapterQueue, Enqueue, PulseWorker, WorkerEvent};
@ -216,7 +216,8 @@ impl LocalServer {
}
pub fn tick(&mut self) -> Result<(), LocalError> {
for intent in self.midi.tick() {
let midi_tick = self.midi.tick();
for intent in midi_tick.intents {
let sequence = self.midi_sequence;
self.midi_sequence = self
.midi_sequence
@ -225,6 +226,37 @@ impl LocalServer {
let commands = self.mixer.midi_intent(intent, sequence)?;
self.enqueue(commands)?;
}
if let Some(binding) = midi_tick.learned {
let edit = crate::ipc::ConfigurationEdit::AddBinding {
surface: binding.surface,
fader: binding.fader,
action: match binding.action {
fader_config::Action::Volume => "volume",
fader_config::Action::ToggleMute => "toggle_mute",
}
.to_owned(),
kind: match binding.kind {
fader_config::MessageKind::Cc => "cc",
fader_config::MessageKind::Note => "note",
}
.to_owned(),
channel: binding.channel,
number: binding.number,
};
match self
.configuration
.apply(self.configuration.revision(), edit)
{
Ok(profile) => self.publish_configuration(&profile, None),
Err(error) => {
let profile = self
.configuration
.profile()
.map_err(|error| crate::live::LiveMixerError::Profile(error.to_string()))?;
self.publish_configuration(&profile, Some(error.to_string()));
}
}
}
self.mixer.set_devices(self.midi.snapshot());
self.flush_dispatch();
match self.worker.receive_timeout(self.poll_interval) {
@ -284,6 +316,75 @@ impl LocalServer {
Err(error) => Err(crate::live::LiveMixerError::Profile(error.to_string())),
}
}
crate::ipc::RequestCommand::StartMidiLearn {
surface,
fader,
action,
} if request.version == PROTOCOL_VERSION => {
let profile = self
.configuration
.profile()
.map_err(|error| crate::live::LiveMixerError::Profile(error.to_string()))?;
if !profile.surfaces().iter().any(|item| item.id() == surface) {
return self.write_client_error(
stream,
request_id,
format!("unknown MIDI surface {surface:?}"),
);
}
if !profile.faders().iter().any(|item| item.id() == fader) {
return self.write_client_error(
stream,
request_id,
format!("unknown fader {fader:?}"),
);
}
let action = match action.as_str() {
"volume" => fader_config::Action::Volume,
"toggle_mute" => fader_config::Action::ToggleMute,
_ => {
return self.write_client_error(
stream,
request_id,
format!("unsupported MIDI learn action {action:?}"),
);
}
};
let surface_id = SurfaceId::new(&surface)
.map_err(|error| crate::live::LiveMixerError::Profile(error.to_string()))?;
let fader_id = FaderId::new(&fader)
.map_err(|error| crate::live::LiveMixerError::Profile(error.to_string()))?;
self.midi.start_learn(crate::midi_runtime::MidiLearn {
surface: surface_id,
fader: fader_id,
action,
});
let mut configuration = configuration_snapshot(
&profile,
self.configuration.revision(),
self.configuration.dirty(),
);
configuration.learning = Some(format!("{surface} -> {fader} ({action:?})"));
self.mixer.set_configuration(configuration);
self.mixer.request(ClientRequest {
version: request.version,
request_id,
command: crate::ipc::RequestCommand::Snapshot,
})
}
crate::ipc::RequestCommand::CancelMidiLearn if request.version == PROTOCOL_VERSION => {
self.midi.cancel_learn();
let profile = self
.configuration
.profile()
.map_err(|error| crate::live::LiveMixerError::Profile(error.to_string()))?;
self.publish_configuration(&profile, None);
self.mixer.request(ClientRequest {
version: request.version,
request_id,
command: crate::ipc::RequestCommand::Snapshot,
})
}
command => self.mixer.request(ClientRequest {
version: request.version,
request_id,
@ -308,6 +409,36 @@ impl LocalServer {
Ok(())
}
fn publish_configuration(&mut self, profile: &fader_config::Profile, error: Option<String>) {
let mut configuration = configuration_snapshot(
profile,
self.configuration.revision(),
self.configuration.dirty(),
);
configuration.error = error;
self.mixer.set_configuration(configuration);
}
fn write_client_error(
&self,
stream: &mut UnixStream,
request_id: u64,
message: String,
) -> Result<(), LocalError> {
write_frame(
stream,
&ServerResponse {
version: PROTOCOL_VERSION,
request_id,
result: ResponseResult::Error {
message,
resync: false,
},
},
)?;
Ok(())
}
fn enqueue(&mut self, commands: Vec<fader_core::AdapterCommand>) -> Result<(), LocalError> {
for command in commands {
let operation = match &command {

View File

@ -10,8 +10,9 @@ use fader_core::{
MidiData, SurfaceId,
};
use midi::{
DeviceMatch, LinuxIdentityCatalog, MidiInputCatalog, MidiInputConnection, MidiInputEvent,
MidiIntent, MidiRouter, SurfaceAction, SurfaceAssignment, SurfaceLifecycle, SurfaceStatus,
ButtonEdge, DeviceMatch, LinuxIdentityCatalog, MidiInputCatalog, MidiInputConnection,
MidiInputEvent, MidiIntent, MidiMessage, MidiRouter, SurfaceAction, SurfaceAssignment,
SurfaceLifecycle, SurfaceStatus,
};
use crate::ipc::MidiDevice;
@ -29,6 +30,30 @@ pub struct MidiRuntime {
last_scan: Option<Instant>,
scan_error: Option<String>,
router: MidiRouter,
learn: Option<MidiLearn>,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct MidiLearn {
pub surface: SurfaceId,
pub fader: FaderId,
pub action: fader_config::Action,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct LearnedBinding {
pub surface: String,
pub fader: String,
pub action: fader_config::Action,
pub kind: fader_config::MessageKind,
pub channel: u16,
pub number: u16,
}
#[derive(Debug, Default)]
pub struct MidiTick {
pub intents: Vec<MidiIntent>,
pub learned: Option<LearnedBinding>,
}
impl std::fmt::Debug for MidiRuntime {
@ -103,10 +128,11 @@ impl MidiRuntime {
last_scan: None,
scan_error: None,
router,
learn: None,
})
}
pub fn tick(&mut self) -> Vec<MidiIntent> {
pub fn tick(&mut self) -> MidiTick {
if self
.last_scan
.is_none_or(|last| last.elapsed() >= SCAN_INTERVAL)
@ -114,15 +140,13 @@ impl MidiRuntime {
self.scan();
self.last_scan = Some(Instant::now());
}
let mut intents = Vec::new();
let mut result = MidiTick::default();
loop {
match self.receiver.try_recv() {
Ok(MidiInputEvent::Message {
surface, message, ..
}) => {
if let Some(intent) = self.router.route(&surface, message) {
intents.push(intent);
}
self.handle_message(surface, message, &mut result);
}
Ok(MidiInputEvent::Malformed { error, .. }) => {
self.scan_error = Some(format!("malformed MIDI input: {error}"));
@ -137,7 +161,73 @@ impl MidiRuntime {
{
self.scan_error = Some("MIDI input queue overflowed; reconnect required".to_owned());
}
intents
result
}
pub fn start_learn(&mut self, learn: MidiLearn) {
self.learn = Some(learn);
}
pub fn cancel_learn(&mut self) {
self.learn = None;
}
#[must_use]
pub fn learning(&self) -> Option<&MidiLearn> {
self.learn.as_ref()
}
fn handle_message(&mut self, surface: SurfaceId, message: MidiMessage, result: &mut MidiTick) {
if self
.learn
.as_ref()
.is_some_and(|learn| learn.surface == surface)
{
let learned = self.learn.as_ref().and_then(|learn| {
let (kind, channel, number) = match (learn.action, message) {
(
fader_config::Action::Volume,
MidiMessage::ControlChange {
channel, number, ..
},
) => (fader_config::MessageKind::Cc, channel, number),
(
fader_config::Action::ToggleMute,
MidiMessage::Note {
channel,
number,
edge: ButtonEdge::Press,
..
},
) => (fader_config::MessageKind::Note, channel, number),
(
fader_config::Action::ToggleMute,
MidiMessage::ControlChange {
channel,
number,
value,
},
) if value.get() > 0 => (fader_config::MessageKind::Cc, channel, number),
_ => return None,
};
Some(LearnedBinding {
surface: learn.surface.as_str().to_owned(),
fader: learn.fader.as_str().to_owned(),
action: learn.action,
kind,
channel: u16::from(channel.get()),
number: u16::from(number.get()),
})
});
if learned.is_some() {
self.learn = None;
result.learned = learned;
}
return;
}
if let Some(intent) = self.router.route(&surface, message) {
result.intents.push(intent);
}
}
#[must_use]
@ -326,4 +416,48 @@ mod tests {
Some(MidiIntent::ToggleMute { fader, .. }) if fader.as_str() == "master-fader"
));
}
#[test]
fn midi_learn_is_surface_scoped_suppresses_routing_and_cancel_restores_it() {
let profile =
Profile::parse(include_str!("../../examples/profiles/arch-pipewire.toml")).unwrap();
let mut runtime = MidiRuntime::new(&profile).unwrap();
let surface = SurfaceId::new("apc-mini").unwrap();
runtime.start_learn(MidiLearn {
surface: surface.clone(),
fader: FaderId::new("media-fader").unwrap(),
action: fader_config::Action::Volume,
});
let message = MidiMessage::ControlChange {
channel: MidiChannel::new(1).unwrap(),
number: MidiData::new(48).unwrap(),
value: MidiData::new(100).unwrap(),
};
let mut captured = MidiTick::default();
runtime.handle_message(
SurfaceId::new("other-surface").unwrap(),
message,
&mut captured,
);
assert!(captured.learned.is_none());
assert!(runtime.learning().is_some());
runtime.handle_message(surface.clone(), message, &mut captured);
assert!(captured.intents.is_empty());
assert_eq!(captured.learned.as_ref().unwrap().number, 48);
assert!(runtime.learning().is_none());
runtime.start_learn(MidiLearn {
surface: surface.clone(),
fader: FaderId::new("media-fader").unwrap(),
action: fader_config::Action::Volume,
});
runtime.cancel_learn();
let mut routed = MidiTick::default();
runtime.handle_message(surface, message, &mut routed);
assert!(matches!(
routed.intents.as_slice(),
[MidiIntent::AbsoluteVolume { fader, .. }] if fader.as_str() == "music-fader"
));
}
}

View File

@ -92,6 +92,8 @@ impl IpcMixerClient {
configuration: tui::ConfigurationSnapshot {
revision: snapshot.configuration.revision,
dirty: snapshot.configuration.dirty,
learning: snapshot.configuration.learning,
error: snapshot.configuration.error,
profile_id: snapshot.configuration.profile_id,
applications: snapshot
.configuration
@ -195,6 +197,23 @@ impl MixerClient for IpcMixerClient {
edit: configuration_edit(edit),
})
}
fn start_midi_learn(
&mut self,
surface: String,
fader: String,
action: String,
) -> io::Result<MixerSnapshot> {
self.send(RequestCommand::StartMidiLearn {
surface,
fader,
action,
})
}
fn cancel_midi_learn(&mut self) -> io::Result<MixerSnapshot> {
self.send(RequestCommand::CancelMidiLearn)
}
}
fn configuration_edit(edit: TuiConfigurationEdit) -> crate::ipc::ConfigurationEdit {

View File

@ -343,7 +343,10 @@ Dependencies: M8, M2, M1.
The server now owns the validated draft and its independent revision; stale
or invalid edit requests are rejected without advancing or altering it, and
accepted edits are exposed as an unsaved draft in the Config tab.
- [ ] **M9.2 Surface bindings / MIDI learn:** select surface, listen for one supported control, preview conflicts and save binding. Tests: learning suppresses the normal action, other surfaces are not captured accidentally, cancellation restores routing, duplicate binding is rejected.
- [x] **M9.2 Surface bindings / MIDI learn:** select surface, listen for one supported control, preview conflicts and save binding. Tests: learning suppresses the normal action, other surfaces are not captured accidentally, cancellation restores routing, duplicate binding is rejected.
The Config tab starts surface/fader/action-scoped learning with `L` and
cancels with `C`. Captured CC/note identity is added to the validated server
draft; conflicts are shown without changing the draft revision.
- [ ] **M9.3 Apply/save/conflict:** server-owned revisioned edits, separate live apply and persistence. Tests: stale edits conflict, external file edits are not overwritten, comments survive save, write failure is shown as unsaved and leaves previous disk config usable.
## M10 — Transactional profile swapping

View File

@ -78,6 +78,8 @@ pub struct MidiDevice {
pub struct ConfigurationSnapshot {
pub revision: u64,
pub dirty: bool,
pub learning: Option<String>,
pub error: Option<String>,
pub profile_id: String,
pub applications: Vec<ConfiguredApplication>,
pub groups: Vec<ConfiguredGroup>,
@ -178,14 +180,44 @@ pub trait MixerClient {
"configuration editing is unavailable",
))
}
fn start_midi_learn(
&mut self,
_surface: String,
_fader: String,
_action: String,
) -> io::Result<MixerSnapshot> {
Err(io::Error::new(
io::ErrorKind::Unsupported,
"MIDI learn is unavailable",
))
}
fn cancel_midi_learn(&mut self) -> io::Result<MixerSnapshot> {
Err(io::Error::new(
io::ErrorKind::Unsupported,
"MIDI learn is unavailable",
))
}
}
#[derive(Clone, Debug)]
enum BufferedAction {
SetVolume { id: MixerObjectId, gain: f64 },
ToggleMute { id: MixerObjectId },
SetVolume {
id: MixerObjectId,
gain: f64,
},
ToggleMute {
id: MixerObjectId,
},
Refresh,
EditConfiguration { edit: ConfigurationEdit },
EditConfiguration {
edit: ConfigurationEdit,
},
StartMidiLearn {
surface: String,
fader: String,
action: String,
},
CancelMidiLearn,
}
#[derive(Debug)]
@ -195,7 +227,7 @@ struct BufferedState {
desired_mutes: BTreeMap<MixerObjectId, bool>,
volume_work: BTreeMap<MixerObjectId, f64>,
mute_work: VecDeque<MixerObjectId>,
configuration_work: VecDeque<ConfigurationEdit>,
configuration_work: VecDeque<BufferedAction>,
error: Option<String>,
shutdown: bool,
}
@ -332,7 +364,43 @@ impl MixerClient for BufferedMixerClient {
if state.configuration_work.len() >= 64 {
return Err(io::Error::other("configuration edit buffer is full"));
}
state.configuration_work.push_back(edit);
state
.configuration_work
.push_back(BufferedAction::EditConfiguration { edit });
state.error = None;
let snapshot = state.snapshot.clone();
wake.notify_one();
Ok(snapshot)
}
fn start_midi_learn(
&mut self,
surface: String,
fader: String,
action: String,
) -> io::Result<MixerSnapshot> {
self.queue_configuration_action(BufferedAction::StartMidiLearn {
surface,
fader,
action,
})
}
fn cancel_midi_learn(&mut self) -> io::Result<MixerSnapshot> {
self.queue_configuration_action(BufferedAction::CancelMidiLearn)
}
}
impl BufferedMixerClient {
fn queue_configuration_action(&self, action: BufferedAction) -> io::Result<MixerSnapshot> {
let (state, wake) = &*self.shared;
let mut state = state
.lock()
.map_err(|_| io::Error::other("buffered mixer client state is poisoned"))?;
if state.configuration_work.len() >= 64 {
return Err(io::Error::other("configuration action buffer is full"));
}
state.configuration_work.push_back(action);
state.error = None;
let snapshot = state.snapshot.clone();
wake.notify_one();
@ -394,8 +462,8 @@ fn client_loop<C>(
BufferedAction::ToggleMute { id }
} else if let Some((id, gain)) = state.volume_work.pop_first() {
BufferedAction::SetVolume { id, gain }
} else if let Some(edit) = state.configuration_work.pop_front() {
BufferedAction::EditConfiguration { edit }
} else if let Some(action) = state.configuration_work.pop_front() {
action
} else {
BufferedAction::Refresh
}
@ -433,6 +501,12 @@ fn execute_action<C: MixerClient>(
BufferedAction::EditConfiguration { edit } => {
client.edit_configuration(edit.clone(), configuration_revision)
}
BufferedAction::StartMidiLearn {
surface,
fader,
action,
} => client.start_midi_learn(surface.clone(), fader.clone(), action.clone()),
BufferedAction::CancelMidiLearn => client.cancel_midi_learn(),
};
match execute(client, confirmed.revision, confirmed.configuration.revision) {
Ok(snapshot) => Ok(snapshot),
@ -500,6 +574,7 @@ fn discard_failed_action(state: &mut BufferedState, action: &BufferedAction) {
}
BufferedAction::Refresh => {}
BufferedAction::EditConfiguration { .. } => {}
BufferedAction::StartMidiLearn { .. } | BufferedAction::CancelMidiLearn => {}
}
}
@ -567,6 +642,7 @@ enum EditorOperation {
Group,
Fader,
Remove,
Learn,
}
#[derive(Clone, Debug, Eq, PartialEq)]
@ -681,6 +757,15 @@ impl<C: MixerClient> LiveTui<C> {
KeyCode::Char('d') if self.tab == Tab::Configuration => {
self.start_editor(EditorOperation::Remove)
}
KeyCode::Char('l') if self.tab == Tab::Configuration => {
self.start_editor(EditorOperation::Learn)
}
KeyCode::Char('c') if self.tab == Tab::Configuration => {
match self.client.cancel_midi_learn() {
Ok(snapshot) => self.replace_snapshot(snapshot),
Err(error) => self.client_error = Some(error.to_string()),
}
}
KeyCode::Esc | KeyCode::Char('q') => self.exit = true,
_ => {}
}
@ -716,6 +801,22 @@ impl<C: MixerClient> LiveTui<C> {
let Some(editor) = self.editor.take() else {
return;
};
if editor.operation == EditorOperation::Learn {
let fields = editor.value.split('|').map(str::trim).collect::<Vec<_>>();
if fields.len() != 3 || !matches!(fields[2], "volume" | "toggle_mute") {
self.client_error = Some("expected surface|fader|volume/toggle_mute".to_owned());
return;
}
match self.client.start_midi_learn(
fields[0].to_owned(),
fields[1].to_owned(),
fields[2].to_owned(),
) {
Ok(snapshot) => self.replace_snapshot(snapshot),
Err(error) => self.client_error = Some(error.to_string()),
}
return;
}
let edit = match self.parse_editor(&editor) {
Ok(edit) => edit,
Err(error) => {
@ -808,6 +909,7 @@ impl<C: MixerClient> LiveTui<C> {
Err("expected id|application/group/output|target|pickup".to_owned())
}
EditorOperation::Remove => Err("expected application/group/fader|id".to_owned()),
EditorOperation::Learn => Err("MIDI learn uses its own input".to_owned()),
}
}
@ -958,6 +1060,8 @@ impl<C> Widget for &LiveTui<C> {
"fader".fg(theme.secondary),
" D ".fg(theme.foreground),
"delete".fg(theme.secondary),
" L/C ".fg(theme.foreground),
"learn".fg(theme.secondary),
" Tab ".fg(theme.foreground),
"mixer".fg(theme.secondary),
" T ".fg(theme.foreground),
@ -1018,6 +1122,7 @@ const fn editor_prompt(operation: EditorOperation) -> &'static str {
EditorOperation::Group => "group id|label|member1,member2",
EditorOperation::Fader => "fader id|application/group/output|target|pickup",
EditorOperation::Remove => "delete application/group/fader|id",
EditorOperation::Learn => "learn surface|fader|volume/toggle_mute",
}
}
@ -1038,12 +1143,22 @@ impl<C> LiveTui<C> {
))
.bold(),
];
if let Some(learning) = &config.learning {
lines.push(
Line::from(format!(
"MIDI learn: {learning} — move or press one control"
))
.fg(theme.warning)
.bold(),
);
}
if let Some(error) = &config.error {
lines.push(Line::from(format!("Configuration error: {error}")).fg(theme.error));
}
lines.push(Line::from(""));
lines.push(
Line::from(
"A app · G group · F fader · D delete · Enter submit · Esc cancel",
)
.fg(theme.muted),
Line::from("A app · G group · F fader · D delete · L learn · C cancel learn")
.fg(theme.muted),
);
lines.push(Line::from("Applications").fg(theme.accent).bold());
lines.extend(config.applications.iter().map(|application| {
@ -1404,6 +1519,8 @@ mod tests {
snapshot.configuration = ConfigurationSnapshot {
revision: 3,
dirty: true,
learning: None,
error: None,
profile_id: "desktop".into(),
applications: vec![ConfiguredApplication {
id: "browser".into(),
@ -1524,6 +1641,71 @@ mod tests {
assert!(app.editor.is_none());
}
#[test]
fn configuration_tab_starts_and_cancels_midi_learn() {
struct LearnClient {
snapshot: MixerSnapshot,
calls: Arc<Mutex<Vec<String>>>,
}
impl MixerClient for LearnClient {
fn snapshot(&mut self) -> io::Result<MixerSnapshot> {
Ok(self.snapshot.clone())
}
fn set_volume(
&mut self,
_: MixerObjectId,
_: f64,
_: u64,
) -> io::Result<MixerSnapshot> {
unreachable!()
}
fn toggle_mute(&mut self, _: MixerObjectId, _: u64) -> io::Result<MixerSnapshot> {
unreachable!()
}
fn start_midi_learn(
&mut self,
surface: String,
fader: String,
action: String,
) -> io::Result<MixerSnapshot> {
self.calls
.lock()
.unwrap()
.push(format!("start:{surface}:{fader}:{action}"));
self.snapshot.configuration.learning = Some("waiting".into());
Ok(self.snapshot.clone())
}
fn cancel_midi_learn(&mut self) -> io::Result<MixerSnapshot> {
self.calls.lock().unwrap().push("cancel".into());
self.snapshot.configuration.learning = None;
Ok(self.snapshot.clone())
}
}
let calls = Arc::new(Mutex::new(Vec::new()));
let mut app = LiveTui::new(LearnClient {
snapshot: DemoClient::default().view(),
calls: Arc::clone(&calls),
})
.unwrap();
app.handle_key_event(press(KeyCode::Char('2')));
app.handle_key_event(press(KeyCode::Char('l')));
for character in "apc-mini|media-fader|volume".chars() {
app.handle_key_event(press(KeyCode::Char(character)));
}
app.handle_key_event(press(KeyCode::Enter));
assert_eq!(
app.snapshot.configuration.learning.as_deref(),
Some("waiting")
);
app.handle_key_event(press(KeyCode::Char('c')));
assert!(app.snapshot.configuration.learning.is_none());
assert_eq!(
calls.lock().unwrap().as_slice(),
&["start:apc-mini:media-fader:volume", "cancel"]
);
}
#[test]
fn device_status_summaries_include_recovery_actions_and_errors() {
let ambiguous = MidiDevice {