freeplay(recorder): Replace string recorder status with enum (#402)

Author: PolyMeilex

Cargo.lock

@@ -14,6 +14,7 @@ fluid-synth = ["synth", "cpal", "fluidlite", "oxisynth"]
 oxi-synth = ["synth", "cpal", "oxisynth"]
 
 [dependencies]
+thiserror.workspace = true
 pollster.workspace = true
 log.workspace = true
 env_logger.workspace = true

neothesia/Cargo.toml

@@ -15,7 +15,7 @@ use crate::{
     icons,
     scene::{
         MouseToMidiEventState, NuonRenderer, Scene,
-        freeplay::recorder::{FreeplayRecorder, PreviewState},
+        freeplay::recorder::{FreeplayRecorder, PreviewState, RecorderError, RecorderStatus},
         playing_scene::{Keyboard, midi_player::MidiPlayer},
     },
     song::Song,
@@ -56,7 +56,7 @@ pub struct FreeplayScene {
     mouse_to_midi_state: MouseToMidiEventState,
     deduced_chord_name: String,
     recorder: FreeplayRecorder,
-    recorder_status: String,
+    recorder_status: RecorderStatus,
     preview_state: Option<PreviewState>,
 
     context: std::task::Context<'static>,
@@ -102,7 +102,7 @@ impl FreeplayScene {
             mouse_to_midi_state: MouseToMidiEventState::default(),
             deduced_chord_name: String::new(),
             recorder: FreeplayRecorder::default(),
-            recorder_status: String::new(),
+            recorder_status: RecorderStatus::default(),
             preview_state: None,
 
             context: std::task::Context::from_waker(noop_waker_ref()),
@@ -197,7 +197,7 @@ impl FreeplayScene {
         self.keyboard.reset_notes();
     }
 
-    fn rebuild_preview(&mut self, ctx: &Context) -> Result<(), String> {
+    fn rebuild_preview(&mut self, ctx: &Context) -> Result<(), RecorderError> {
         self.clear_preview();
 
         let song = self.recorder.to_song()?;
@@ -269,15 +269,7 @@ impl FreeplayScene {
         self.keyboard.reset_notes();
     }
 
-    fn preview_status_label(&self) -> String {
-        if self.recorder.is_recording() {
-            return format!("Recording {:.1}s", self.recorder.duration().as_secs_f32(),);
-        }
-
-        self.recorder_status.clone()
-    }
-
-    fn stop_recording(&mut self, ctx: &Context) -> Result<(), String> {
+    fn stop_recording(&mut self, ctx: &Context) -> Result<(), RecorderError> {
         self.recorder.stop();
         self.rebuild_preview(ctx)
     }
@@ -287,33 +279,30 @@ impl FreeplayScene {
             match self.stop_recording(ctx) {
                 Ok(()) => {
                     self.recorder_status =
-                        format!("Recorded {:.1}s", self.recorder.duration().as_secs_f32());
+                        RecorderStatus::RecordingFinished(self.recorder.duration());
                 }
                 Err(err) => {
-                    self.recorder_status = err;
+                    self.recorder_status = RecorderStatus::Error(err);
                 }
             }
 
             return;
         }
 
         self.clear_preview();
+        self.recorder_status = RecorderStatus::default();
         self.recorder.start();
-        self.recorder_status = "Recording in progress".to_string();
     }
 
     fn handle_save_click(&mut self, ctx: &Context) {
         if self.recorder.is_recording()
             && let Err(err) = self.stop_recording(ctx)
         {
-            self.recorder_status = err;
+            self.recorder_status = RecorderStatus::Error(err);
             return;
         }
 
-        if !self.recorder.has_note_events() {
-            self.recorder_status = "Nothing recorded yet".to_string();
-            return;
-        }
+        debug_assert!(self.recorder.has_note_events());
 
         let mut dialog = rfd::AsyncFileDialog::new()
             .add_filter("midi", &["mid", "midi"])
@@ -326,28 +315,26 @@ impl FreeplayScene {
         let smf = match self.recorder.to_smf() {
             Ok(smf) => smf,
             Err(err) => {
-                self.recorder_status = err;
+                self.recorder_status = RecorderStatus::Error(err);
                 return;
             }
         };
 
-        self.futures.push(on_async(
-            dialog.save_file(),
-            |path, state, _ctx| match path {
-                Some(file) => match FreeplayRecorder::save_to_path(smf, file.path()) {
+        self.futures
+            .push(on_async(dialog.save_file(), |file, state, _ctx| {
+                let Some(file) = file else {
+                    return;
+                };
+
+                match FreeplayRecorder::save_to_path(smf, file.path()) {
                     Ok(()) => {
-                        state.recorder_status =
-                            format!("Saved recording to {}", file.path().display());
+                        state.recorder_status = RecorderStatus::Saved(file.path().to_owned());
                     }
                     Err(err) => {
-                        state.recorder_status = err;
+                        state.recorder_status = RecorderStatus::Error(err);
                     }
-                },
-                None => {
-                    state.recorder_status = "Save canceled".to_string();
                 }
-            },
-        ));
+            }));
     }
 
     fn update_preview(&mut self, ctx: &Context, delta: Duration) -> Option<f32> {
@@ -376,7 +363,11 @@ impl FreeplayScene {
             .map(|s| s.player.is_paused())
             .unwrap_or(true);
 
-        let status_label = self.preview_status_label();
+        let status_label = if self.recorder.is_recording() {
+            format!("Recording {:.1}s", self.recorder.duration().as_secs_f32())
+        } else {
+            self.recorder_status.to_string()
+        };
 
         enum Msg {
             TogglePlay,

neothesia/src/scene/freeplay/mod.rs

@@ -1,6 +1,7 @@
 use std::{
     collections::HashSet,
-    path::Path,
+    fmt,
+    path::{Path, PathBuf},
     time::{Duration, Instant},
 };
 
@@ -11,6 +12,44 @@ use neothesia_core::render::{NoteLabels, WaterfallRenderer};
 
 use crate::{scene::playing_scene::midi_player::MidiPlayer, song::Song};
 
+#[derive(Debug, Eq, PartialEq, thiserror::Error)]
+pub enum RecorderError {
+    #[error("No note events recorded")]
+    NoNotesFound,
+    #[error("Failed to write MIDI file")]
+    Write,
+    #[error("{0}")]
+    MidiFileParse(String),
+}
+
+#[derive(Default, Debug)]
+pub enum RecorderStatus {
+    #[default]
+    Idle,
+    RecordingFinished(Duration),
+    Saved(PathBuf),
+    Error(RecorderError),
+}
+
+impl fmt::Display for RecorderStatus {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Idle => {}
+            Self::RecordingFinished(duration) => {
+                write!(f, "Recorded {:.1}s", duration.as_secs_f32())?;
+            }
+            Self::Error(err) => {
+                write!(f, "{err}")?;
+            }
+            Self::Saved(path) => {
+                write!(f, "Saved recording to {}", path.display())?;
+            }
+        }
+
+        Ok(())
+    }
+}
+
 #[derive(Clone, Copy)]
 pub struct RecordedMidiEvent {
     timestamp: Duration,
@@ -122,15 +161,24 @@ impl FreeplayRecorder {
         }
     }
 
-    pub fn save_to_path(smf: Smf<'static>, path: &Path) -> Result<(), String> {
+    pub fn save_to_path(smf: Smf<'static>, path: &Path) -> Result<(), RecorderError> {
         let mut bytes = Vec::new();
-        smf.write_std(&mut bytes)
-            .map_err(|err| format!("Failed to encode MIDI: {err}"))?;
-        std::fs::write(path, bytes).map_err(|err| format!("Failed to write MIDI file: {err}"))
+
+        if smf.write_std(&mut bytes).is_err() {
+            return Err(RecorderError::Write);
+        }
+
+        if std::fs::write(path, bytes).is_err() {
+            return Err(RecorderError::Write);
+        }
+
+        Ok(())
     }
 
-    pub fn to_song(&self) -> Result<Song, String> {
-        let midi = midi_file::MidiFile::from_smf("freeplay-recording.mid", self.to_smf()?)?;
+    pub fn to_song(&self) -> Result<Song, RecorderError> {
+        let smf = self.to_smf()?;
+        let midi = midi_file::MidiFile::from_smf("freeplay-recording.mid", smf)
+            .map_err(RecorderError::MidiFileParse)?;
         Ok(Song::new(midi))
     }
 
@@ -150,9 +198,9 @@ impl FreeplayRecorder {
         }
     }
 
-    pub fn to_smf(&self) -> Result<Smf<'static>, String> {
+    pub fn to_smf(&self) -> Result<Smf<'static>, RecorderError> {
         if !self.has_note_events() {
-            return Err("No note events recorded yet".to_string());
+            return Err(RecorderError::NoNotesFound);
         }
 
         let events = match &self.state {
@@ -256,7 +304,7 @@ mod freeplay_recorder_tests {
         let error = recorder
             .to_song()
             .expect_err("pedal-only recordings should not create preview songs");
-        assert_eq!(error, "No note events recorded yet");
+        assert_eq!(error, RecorderError::NoNotesFound);
     }
 
     #[test]
@@ -277,6 +325,6 @@ mod freeplay_recorder_tests {
         let error = recorder
             .to_song()
             .expect_err("note-off-only recordings should not create preview songs");
-        assert_eq!(error, "No note events recorded yet");
+        assert_eq!(error, RecorderError::NoNotesFound);
     }
 }