//! Application state shared by commands, the tray and background threads. //! //! Holds the store, the settings, the secret store, the HTTP transport, the //! recording that is currently running, the call detector, the calls //! awaiting a decision in the end-of-call prompt, the calls being //! processed and the cached mixes for playback. Everything here is //! independent of windows and events; the command layer turns results into //! UI updates. use std::collections::{HashMap, HashSet, VecDeque}; use std::fs; use std::io::ErrorKind; use std::path::{Path, PathBuf}; use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::{Arc, Mutex, MutexGuard}; use std::thread; use std::time::{Duration, Instant}; use chrono::{DateTime, Local}; use recorder_audio::RenderSession; use recorder_core::backend::{BackendClient, KeyInfo, NewKey, StoredKey}; use recorder_core::call_view::{self, CallDetail, CallListItem}; use recorder_core::capture::{CaptureSource, OutputTarget}; use recorder_core::detect::{CallDetector, DetectorEvent, MicSession}; use recorder_core::http::{HttpTransport, ReqwestTransport}; use recorder_core::model::{Call, CallId, CallStatus, Speaker}; use recorder_core::playback; use recorder_core::recorder::Recorder; use recorder_core::secrets::{SecretStore, Service}; use recorder_core::settings::Settings; use recorder_core::store::Store; use serde::Serialize; use crate::detection::detector_config; /// `app` value of calls started from the tray or UI instead of detection. const MANUAL_APP: &str = "Manuell"; /// How long [`AppState::test_devices`] records. const TEST_DURATION: Duration = Duration::from_secs(5); const TEST_POLL: Duration = Duration::from_millis(50); const ALREADY_PROCESSING: &str = "Wird bereits verarbeitet"; const ALREADY_UPLOADING: &str = "Wird bereits hochgeladen"; /// Why [`AppState::discard_call`] refused. #[derive(Debug, Clone, PartialEq)] pub enum DiscardError { /// DeepScript jobs of the call are still on record; their delete has to /// succeed first, or the cascade would forget them. CleanupPending, Other(String), } impl std::fmt::Display for DiscardError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { DiscardError::CleanupPending => f.write_str( "Daten bei DeepScript werden noch gelöscht – bitte später erneut versuchen.", ), DiscardError::Other(msg) => f.write_str(msg), } } } impl From for DiscardError { fn from(msg: String) -> Self { DiscardError::Other(msg) } } /// Payload of the `recording-state` event. #[derive(Serialize, Clone, Debug)] #[serde(tag = "state", rename_all = "lowercase")] pub enum RecordingState { Idle, Recording { call_id: CallId, app: String, started_at: DateTime, }, } /// Payload of the `levels` event. #[derive(Serialize, Clone, Debug)] pub struct Levels { pub mic: f32, pub out: f32, pub failed_tracks: Vec<&'static str>, } /// Result of [`AppState::test_devices`]: peak rms level per track. #[derive(Serialize, Clone, Copy, Debug)] pub struct DeviceLevels { pub mic: f32, pub out: f32, } /// What the end-of-call prompt shows about a call. #[derive(Serialize, Clone, Debug, PartialEq)] pub struct CallBrief { pub id: CallId, pub app: String, pub started_at: DateTime, pub ended_at: Option>, pub duration_secs: i64, } impl CallBrief { fn of(call: &Call) -> Self { Self { id: call.id, app: call.app.clone(), started_at: call.started_at, ended_at: call.ended_at, duration_secs: call_view::duration_secs(call), } } } /// The call the end-of-call prompt shows, and how many wait behind it. #[derive(Serialize, Clone, Debug, PartialEq)] pub struct PendingPrompt { #[serde(flatten)] pub brief: CallBrief, pub more_waiting: usize, } /// A recording that was just stopped or discarded. #[derive(Debug)] pub struct Ended { pub call_id: CallId, /// Whether stopping (finalizing the files and the row) or discarding /// worked. pub result: Result<(), String>, } struct CurrentRecording { call_id: CallId, app: String, started_at: DateTime, detected: bool, recorder: Recorder, } pub struct AppState { pub store: Store, pub secrets: Box, /// The one HTTP client all API calls share. pub transport: Arc, settings: Mutex, settings_path: PathBuf, recordings_dir: PathBuf, /// Where the mixes for playback are cached (`/playback`), /// served to the main window by [`crate::playback`]. playback_dir: PathBuf, /// The leases on cached mixes. Held while a mix is built or removed, /// so a call deleted meanwhile never leaves its mix behind. playback: Mutex, current: Mutex>, detector: Mutex, /// Stopped calls awaiting the end-of-call prompt's decision, oldest /// first. A call leaves the queue when it is decided (discarded or sent /// to transcription). pending_prompts: Mutex>, /// Calls a pipeline run is under way for; at most one run per call. processing: Mutex>, /// Set while a recording starts or the devices are tested, so neither /// runs twice and `current` is never locked for longer than a moment. devices_busy: AtomicBool, /// The backend this build talks to ([`crate::backend::BACKEND_URL`]). backend_url: String, /// Held while the stored backend key and its login change, so a /// compare-and-delete never removes a key stored meanwhile. backend_key_lock: Mutex<()>, /// Calls whose transcript is being uploaded; one upload per call. uploading: Mutex>, /// Calls whose transcript reached the CRM but could not be recorded /// locally (`mark_uploaded` failed after a successful upload): /// `claim_upload` refuses these for the rest of this run, so a retry /// never creates a second copy at the CRM. In-memory only; a restart /// forgets it (the row's `crm_transcript_id` is still empty then). upload_confirmed_unsaved: Mutex>, } /// A mix ready to play, from [`AppState::prepare_playback`]. #[derive(Serialize, Clone, Copy, Debug, PartialEq)] pub struct PreparedPlayback { pub duration_secs: f64, /// Hand back to [`AppState::release_playback`] when the player is done. pub lease: u64, } /// Which player holds each cached mix: the lease of the latest /// [`AppState::prepare_playback`] per call. A player that lets go of an /// older lease (it was replaced by a newer one meanwhile) removes nothing. #[derive(Default)] struct PlaybackLeases { next: u64, latest: HashMap, } /// An upload reserved with [`AppState::claim_upload`]; released when /// dropped, also if the upload fails or panics. pub struct UploadClaim<'a> { state: &'a AppState, id: CallId, } impl Drop for UploadClaim<'_> { fn drop(&mut self) { lock(&self.state.uploading).remove(&self.id); } } /// Releases [`AppState::devices_busy`] when dropped. struct DevicesClaim<'a>(&'a AtomicBool); impl Drop for DevicesClaim<'_> { fn drop(&mut self) { self.0.store(false, Ordering::SeqCst); } } impl AppState { pub fn new( store: Store, secrets: Box, settings_path: PathBuf, recordings_dir: PathBuf, playback_dir: PathBuf, ) -> Self { let settings = Settings::load(&settings_path); let detector = CallDetector::new(detector_config(&settings)); Self { store, secrets, transport: Arc::new(ReqwestTransport::new()), settings: Mutex::new(settings), settings_path, recordings_dir, playback_dir, playback: Mutex::new(PlaybackLeases::default()), current: Mutex::new(None), detector: Mutex::new(detector), pending_prompts: Mutex::new(VecDeque::new()), processing: Mutex::new(HashSet::new()), devices_busy: AtomicBool::new(false), // Defensive: BACKEND_URL itself must never have a trailing // slash (see backend::tests::backend_urls_have_no_trailing…), // but a stored key's base_url is compared against this field. backend_url: crate::backend::BACKEND_URL .trim_end_matches('/') .to_string(), backend_key_lock: Mutex::new(()), uploading: Mutex::new(HashSet::new()), upload_confirmed_unsaved: Mutex::new(HashSet::new()), } } pub fn settings(&self) -> Settings { lock(&self.settings).clone() } /// Validates, saves and applies the settings the user edited; the /// detector picks up the new allowlist and delays immediately. The /// backend login (managed by the app) is kept. pub fn save_settings(&self, edited: Settings) -> Result<(), String> { let mut current = lock(&self.settings); let settings = current.edited(edited)?; save(&settings, &self.settings_path)?; lock(&self.detector).set_config(detector_config(&settings)); *current = settings; Ok(()) } /// The backend this build talks to. pub fn backend_url(&self) -> &str { &self.backend_url } /// Client of this build's backend. pub fn backend_client(&self) -> BackendClient { BackendClient::new(self.transport.clone(), &self.backend_url) } /// The stored backend key with its expiry, if it was created for this /// build's backend. A key of another backend is discarded instead (as /// if expired), so it is never sent anywhere else. Reads the keyring, /// so call it off the UI thread. pub fn backend_key(&self) -> Option { let _key_lock = lock(&self.backend_key_lock); let key = self .secrets .get(Service::Backend) .filter(|key| !key.trim().is_empty())?; let settings = self.settings(); if settings.backend_key_base_url.as_deref() != Some(self.backend_url.as_str()) { log::info!( "backend: the stored key belongs to {:?}, not {:?}: discarding it", settings.backend_key_base_url, self.backend_url ); if let Err(e) = self.forget_backend_key() { log::error!("backend: {e}"); } return None; } Some(StoredKey { key, expires_at: settings.backend_key_expires_at, }) } /// Stores a key the login created for the backend at `base_url` (in /// the keyring) with whose it is, when it expires and its backend (in /// the settings). A key of another backend than this build's is /// refused and nothing stored. pub fn store_backend_key( &self, key: &NewKey, base_url: &str, username: Option, ) -> Result<(), String> { let base_url = base_url.trim_end_matches('/'); if base_url != self.backend_url { return Err(format!( "Der Schlüssel gehört zu einem anderen Server ({base_url}) und wurde nicht gespeichert." )); } let _key_lock = lock(&self.backend_key_lock); self.secrets .set(Service::Backend, &key.key) .map_err(|e| format!("Backend-Schlüssel konnte nicht gespeichert werden: {e}"))?; self.update_settings(|s| { s.backend_username = username; s.backend_key_expires_at = Some(key.expires_at); s.backend_key_base_url = Some(base_url.to_string()); }) } /// Takes over whose the stored key is and when it expires, as the /// backend reports it. pub fn refresh_backend_login(&self, info: &KeyInfo) -> Result<(), String> { self.update_settings(|s| { s.backend_username = Some(info.username.clone()); s.backend_key_expires_at = Some(info.expires_at); }) } /// "Abmelden": forgets the backend key (keyring) and its login /// (settings). pub fn discard_backend_key(&self) -> Result<(), String> { let _key_lock = lock(&self.backend_key_lock); self.forget_backend_key() } /// Forgets the stored backend key only if it still is `refused`, the /// key the backend just refused; a key stored meanwhile (by a login) /// stays. Returns whether it was forgotten. pub fn discard_refused_backend_key(&self, refused: &str) -> Result { let _key_lock = lock(&self.backend_key_lock); if self.secrets.get(Service::Backend).as_deref() != Some(refused) { return Ok(false); } self.forget_backend_key().map(|()| true) } /// Deletes the key and its login; the caller holds `backend_key_lock`. /// The keyring is never called while the settings are locked. fn forget_backend_key(&self) -> Result<(), String> { self.secrets .delete(Service::Backend) .map_err(|e| format!("Backend-Schlüssel konnte nicht entfernt werden: {e}"))?; self.update_settings(|s| { s.backend_username = None; s.backend_key_expires_at = None; s.backend_key_base_url = None; }) } /// Reserves call `id` for one upload; released when the claim is /// dropped. A second upload of the same call is refused meanwhile, and /// so is a call already uploaded to *this build's* backend /// ([`call_view::uploaded_here`]) — or one the CRM confirmed but whose /// id could not be saved locally, see /// [`AppState::note_upload_confirmed_but_unsaved`]: the CRM this build /// talks to must never get a duplicate. An upload recorded for another /// backend (e.g. the test backend, read by a release build) is not /// "uploaded" here and is claimed like any other call. All three checks /// happen while `uploading` is locked, so a second upload can never /// slip in between this check and the one upload it allows. pub fn claim_upload(&self, id: CallId) -> Result, String> { let mut uploading = lock(&self.uploading); if uploading.contains(&id) { return Err(ALREADY_UPLOADING.to_string()); } if lock(&self.upload_confirmed_unsaved).contains(&id) { return Err("Bereits hochgeladen".to_string()); } // An upload recorded for another backend (e.g. the test backend, // read by a release build) does not count: the CRM this build // talks to has never seen this transcript. if call_view::uploaded_here(&self.find_call(id)?, &self.backend_url) { return Err("Bereits hochgeladen".to_string()); } uploading.insert(id); Ok(UploadClaim { state: self, id }) } /// Whether call `id`'s transcript is being uploaded. pub fn is_uploading(&self, id: CallId) -> bool { lock(&self.uploading).contains(&id) } /// Records that call `id`'s transcript reached the CRM, but saving that /// locally (`mark_uploaded`) failed: [`AppState::claim_upload`] refuses /// this call for the rest of the run, so a retry can never send the CRM /// a second copy. In-memory only; see the field's doc comment. pub fn note_upload_confirmed_but_unsaved(&self, id: CallId) { lock(&self.upload_confirmed_unsaved).insert(id); } /// Changes and saves settings the app manages itself; saves only if /// something changed. fn update_settings(&self, change: impl FnOnce(&mut Settings)) -> Result<(), String> { let mut current = lock(&self.settings); let mut settings = current.clone(); change(&mut settings); if settings != *current { save(&settings, &self.settings_path)?; *current = settings; } Ok(()) } /// Advances the call detector by one poll. pub fn detector_tick(&self, now: Instant, sessions: &[MicSession]) -> Option { lock(&self.detector).tick(now, sessions) } /// Ends the detector's current call without an event and keeps it from /// detecting the same app again until that app releases the mic. pub fn suppress_detected_call(&self) { lock(&self.detector).manual_stop(); } /// Whether a recording started by hand (not by detection) is running. pub fn manual_recording_running(&self) -> bool { lock(&self.current) .as_ref() .is_some_and(|cur| !cur.detected) } pub fn recording_state(&self) -> RecordingState { match lock(&self.current).as_ref() { Some(cur) => RecordingState::Recording { call_id: cur.call_id, app: cur.app.clone(), started_at: cur.started_at, }, None => RecordingState::Idle, } } /// Levels of the recording `call_id`, or `None` once it is no longer /// the current recording. pub fn levels(&self, call_id: CallId) -> Option { let current = lock(&self.current); let cur = current.as_ref().filter(|cur| cur.call_id == call_id)?; let (mic, out) = cur.recorder.levels(); Some(Levels { mic, out, failed_tracks: cur.recorder.failed_tracks(), }) } /// Starts recording the configured mic and output device. pub fn start_manual_recording(&self) -> Result { let out = recorder_audio::output_source(output_target(&self.settings())); self.start_recording(MANUAL_APP, false, out) } /// Starts recording a detected call (`app` is its display name, `exe` /// and `root_pid` identify the call app): the configured mic and the /// output device the call plays on (see [`detected_output_target`]). pub fn start_detected_recording( &self, app: &str, exe: &str, root_pid: u32, ) -> Result { let sessions = recorder_audio::render_sessions(); log::info!( "render sessions: [{}]", recorder_audio::describe_render_sessions(&sessions) ); let target = detected_output_target( self.settings().output_device.as_deref(), &sessions, exe, root_pid, ); self.start_recording(app, true, recorder_audio::output_source(target)) } /// Creates a call row and records the configured mic and `out` into /// `recordings/-mic.wav` / `-out.wav`. fn start_recording( &self, app: &str, detected: bool, out: Box, ) -> Result { let _claim = self.claim_devices("Es läuft bereits eine Aufnahme")?; let settings = self.settings(); fs::create_dir_all(&self.recordings_dir) .map_err(|e| format!("Aufnahmeordner konnte nicht angelegt werden: {e}"))?; let started_at = Local::now(); let call_id = self .store .create_call(app, started_at, Path::new(""), Path::new("")) .map_err(|e| format!("Gespräch konnte nicht angelegt werden: {e}"))?; let (mic_path, out_path) = self.track_paths(call_id); let started = self .store .set_paths(call_id, &mic_path, &out_path) .map_err(|e| e.to_string()) .and_then(|()| { let mic = recorder_audio::mic_source(settings.mic_device.as_deref()); Recorder::start(mic, out, &mic_path, &out_path).map_err(|e| e.to_string()) }); let recorder = match started { Ok(recorder) => recorder, Err(err) => { if let Err(e) = self.store.delete_call(call_id) { log::error!("could not delete call {call_id} after failed start: {e}"); } return Err(format!("Aufnahme konnte nicht gestartet werden: {err}")); } }; *lock(&self.current) = Some(CurrentRecording { call_id, app: app.to_string(), started_at, detected, recorder, }); Ok(call_id) } /// Stops the current recording, if any, and finalizes its row. A /// recorder error still finishes the row and marks the call as failed. pub fn stop_recording(&self) -> Option { self.stop_where(|_| true) } /// Like [`AppState::stop_recording`], but only stops a recording that /// call detection started; a manual recording keeps running. pub fn stop_detected_recording(&self) -> Option { self.stop_where(|cur| cur.detected) } fn stop_where(&self, matches: impl Fn(&CurrentRecording) -> bool) -> Option { let cur = { let mut current = lock(&self.current); if !current.as_ref().is_some_and(matches) { return None; } current.take()? }; let id = cur.call_id; let recorded = cur.recorder.stop(); let result = self .store .finish_recording(id, Local::now(), false) .map_err(|e| format!("Gespräch konnte nicht gespeichert werden: {e}")) .and_then(|()| { let Err(err) = recorded else { return Ok(()); }; let msg = format!("Aufnahme fehlerhaft: {err}"); if let Err(e) = self.store.set_status(id, CallStatus::Failed, Some(&msg)) { log::error!("could not mark call {id} as failed: {e}"); } Err(msg) }); Some(Ended { call_id: id, result, }) } /// Discards the current recording, if any: deletes both WAVs and the /// call row. pub fn discard_current_recording(&self) -> Option { let cur = lock(&self.current).take()?; let id = cur.call_id; cur.recorder.discard(); let result = self .store .delete_call(id) .map_err(|e| format!("Gespräch konnte nicht gelöscht werden: {e}")); Some(Ended { call_id: id, result, }) } /// Queues `id` for the end-of-call prompt (once). pub fn queue_prompt(&self, id: CallId) { let mut queue = lock(&self.pending_prompts); if !queue.contains(&id) { queue.push_back(id); } } /// The oldest queued call that still exists, with the number of calls /// queued behind it. Calls deleted elsewhere drop out of the queue. pub fn pending_prompt(&self) -> Option { let mut queue = lock(&self.pending_prompts); loop { let id = *queue.front()?; match self.store.get_call(id) { Ok(Some(call)) => { return Some(PendingPrompt { brief: CallBrief::of(&call), more_waiting: queue.len() - 1, }) } Ok(None) => { queue.pop_front(); } Err(e) => { log::error!("could not load call {id} for the prompt: {e}"); return None; } } } } /// Takes a decided call out of the prompt queue. Returns the position /// it had, or `None` if `id` was not queued. pub fn remove_queued_prompt(&self, id: CallId) -> Option { let mut queue = lock(&self.pending_prompts); let index = queue.iter().position(|&queued| queued == id)?; queue.remove(index); Some(index) } /// How many calls wait for the end-of-call prompt. pub fn prompts_waiting(&self) -> usize { lock(&self.pending_prompts).len() } pub fn call_brief(&self, id: CallId) -> Result { Ok(CallBrief::of(&self.find_call(id)?)) } /// All calls for the main window's list, newest first. pub fn call_list(&self) -> Result, String> { let calls = self.store.list_calls().map_err(|e| e.to_string())?; Ok(calls .iter() .map(|call| CallListItem::of(call, &self.backend_url)) .collect()) } /// The selected call with its transcript (speaker merges applied), /// speaker names and whether it is being uploaded. pub fn call_detail(&self, id: CallId) -> Result { let call = self.find_call(id)?; let segments = self.store.segments(id).map_err(|e| e.to_string())?; let names = self.store.speaker_names(id).map_err(|e| e.to_string())?; let merges = self.store.speaker_merges(id).map_err(|e| e.to_string())?; let mut detail = CallDetail::of( &call, &segments, names, &merges, &self.backend_url, &self.settings().language, ); detail.uploading = self.is_uploading(id); detail.audio_available = playback::audio_available(&call); Ok(detail) } /// Mixes call `id`'s tracks for playback (or reuses the cached mix, /// see [`playback::prepare`]) under a new lease. Refused while the call /// is recorded or processed, and once its audio is gone. pub fn prepare_playback(&self, id: CallId) -> Result { if lock(&self.current) .as_ref() .is_some_and(|cur| cur.call_id == id) { return Err(playback::RECORDING.to_string()); } let mut leases = lock(&self.playback); // Read under the lock: a call deleted before it is not mixed, one // deleted meanwhile has its mix removed once the lock is free. let call = self.find_call(id)?; let info = playback::prepare(&call, &self.playback_dir)?; leases.next += 1; let lease = leases.next; leases.latest.insert(id, lease); Ok(PreparedPlayback { duration_secs: info.duration_secs, lease, }) } /// The player of `lease` is done with call `id`'s mix: removes it, /// unless a newer lease (another player of the same call) holds it. pub fn release_playback(&self, id: CallId, lease: u64) { let mut leases = lock(&self.playback); if leases.latest.get(&id) == Some(&lease) { leases.latest.remove(&id); playback::remove_cached(&self.playback_dir, id); } } /// Removes call `id`'s cached mix whoever holds it: with the call, and /// once its audio is deleted. The retention job, when it deletes a /// call's audio, calls this too. pub fn remove_playback(&self, id: CallId) { let mut leases = lock(&self.playback); leases.latest.remove(&id); playback::remove_cached(&self.playback_dir, id); } /// Where the mixes are cached ([`crate::playback`] serves them). pub fn playback_dir(&self) -> &Path { &self.playback_dir } /// Empties the playback cache (at startup), so mixed customer audio /// never lingers from an earlier run. pub fn clear_playback_cache(&self) { let dir = &self.playback_dir; match playback::clear_cache(dir) { Ok(()) => log::info!("cleared the playback cache {}", dir.display()), Err(e) => log::warn!("could not empty {}: {e}", dir.display()), } } /// Renames a speaker of call `id`; a blank `name` restores the default /// label ("Ich", "Sprecher N"). pub fn rename_speaker(&self, id: CallId, speaker_key: &str, name: &str) -> Result<(), String> { if Speaker::from_key(speaker_key).is_none() { return Err(format!("Unbekannter Sprecher: {speaker_key}")); } self.find_call(id)?; let name = name.trim(); let result = if name.is_empty() { self.store.remove_speaker_name(id, speaker_key) } else { self.store.set_speaker_name(id, speaker_key, name) }; result.map_err(|e| format!("Name konnte nicht gespeichert werden: {e}")) } /// Merges remote speaker `from_key` of call `id` into `into_key`; both /// must speak in the call's transcript. pub fn merge_speakers(&self, id: CallId, from_key: &str, into_key: &str) -> Result<(), String> { self.find_call(id)?; let segments = self.store.segments(id).map_err(|e| e.to_string())?; for key in [from_key, into_key] { if !segments.iter().any(|s| s.speaker.key() == key) { return Err(format!("Unbekannter Sprecher: {key}")); } } self.store .set_speaker_merge(id, from_key, into_key) .map_err(|e| e.to_string()) } /// Undoes the merge of speaker `from_key` of call `id`. pub fn unmerge_speaker(&self, id: CallId, from_key: &str) -> Result<(), String> { self.find_call(id)?; self.store .remove_speaker_merge(id, from_key) .map_err(|e| format!("Zusammenführung konnte nicht aufgehoben werden: {e}")) } /// Names call `id`; an empty or missing title clears the name. pub fn rename_call(&self, id: CallId, title: Option<&str>) -> Result<(), String> { self.find_call(id)?; self.store.set_title(id, title).map_err(|e| e.to_string()) } /// Records that call `id`'s transcript was just uploaded and the CRM /// gave it `crm_transcript_id`. pub fn mark_uploaded(&self, id: CallId, crm_transcript_id: &str) -> Result<(), String> { self.find_call(id)?; self.store .set_uploaded(id, crm_transcript_id, &self.backend_url, Local::now()) .map_err(|e| format!("Upload konnte nicht vermerkt werden: {e}")) } fn find_call(&self, id: CallId) -> Result { self.store .get_call(id) .map_err(|e| e.to_string())? .ok_or_else(|| "Gespräch nicht gefunden".to_string()) } /// Deletes a finished (or still undecided/failed) call: both audio files /// and the row, cascading to its segments, speaker names, merges and /// recorded remote jobs — this is also how a transcribed (`Done`) call's /// "Löschen" removes it. Takes it out of the prompt queue and returns how /// many calls still wait for it. Refused while the call is being /// recorded, processed ([`AppState::claim_processing`]/ /// [`AppState::reserve_processing`] or status `Processing`), uploaded /// ([`AppState::claim_upload`]), or while its DeepScript jobs are still /// on record ([`DiscardError::CleanupPending`]). pub fn discard_call(&self, id: CallId) -> Result { if lock(&self.current) .as_ref() .is_some_and(|cur| cur.call_id == id) { return Err("Das Gespräch wird gerade aufgenommen".to_string().into()); } // Both held until the call is gone, so neither a pipeline run nor an // upload can claim it meanwhile (same uploading -> store lock order // as `claim_upload`, so this can never deadlock against it). let processing = lock(&self.processing); if processing.contains(&id) { return Err(ALREADY_PROCESSING.to_string().into()); } let uploading = lock(&self.uploading); if uploading.contains(&id) { return Err(ALREADY_UPLOADING.to_string().into()); } let call = self .store .get_call(id) .map_err(|e| e.to_string())? .ok_or_else(|| "Gespräch nicht gefunden".to_string())?; if call.status == CallStatus::Processing { return Err(ALREADY_PROCESSING.to_string().into()); } let remote_jobs = self.store.remote_jobs(id).map_err(|e| e.to_string())?; if !remote_jobs.is_empty() { return Err(DiscardError::CleanupPending); } // Files first: if one cannot be deleted, the row stays so the user // can try again instead of leaving orphaned audio behind. Already // gone (e.g. removed by retention) is not an error. for path in [&call.mic_path, &call.out_path] { if path.as_os_str().is_empty() { continue; } match fs::remove_file(path) { Ok(()) => {} Err(e) if e.kind() == ErrorKind::NotFound => {} Err(e) => { return Err(format!("Audiodatei konnte nicht gelöscht werden: {e}").into()) } } } // Unqueue before deleting the row, so the prompt never sees a queued // call whose row is gone; put it back if the delete fails. let position = self.remove_queued_prompt(id); if let Err(e) = self.store.delete_call(id) { if let Some(index) = position { let mut queue = lock(&self.pending_prompts); if !queue.contains(&id) { let index = index.min(queue.len()); queue.insert(index, id); } } return Err(format!("Gespräch konnte nicht gelöscht werden: {e}").into()); } drop(uploading); drop(processing); self.remove_playback(id); Ok(self.prompts_waiting()) } /// Reserves `id` for one pipeline run; release it with /// [`AppState::release_processing`] when the run ends. A call that waits /// for the decision can be processed; a failed one only on `retry`, or /// while the prompt still shows it (its first attempt failed before /// anything started, e.g. for lack of an API key). pub fn claim_processing(&self, id: CallId, retry: bool) -> Result<(), String> { let mut processing = lock(&self.processing); if processing.contains(&id) { return Err(ALREADY_PROCESSING.to_string()); } let call = self .store .get_call(id) .map_err(|e| e.to_string())? .ok_or_else(|| "Gespräch nicht gefunden".to_string())?; match call.status { CallStatus::AwaitingDecision => {} CallStatus::Failed if retry || lock(&self.pending_prompts).contains(&id) => {} CallStatus::Processing => return Err(ALREADY_PROCESSING.to_string()), CallStatus::Recording => return Err("Das Gespräch wird gerade aufgenommen".to_string()), CallStatus::Done => return Err("Das Gespräch ist bereits transkribiert".to_string()), CallStatus::Failed => { return Err("Das Gespräch wartet nicht auf eine Entscheidung".to_string()) } } processing.insert(id); Ok(()) } /// Reserves `id` for a cleanup of its remote jobs, whatever its status; /// `false` if a run or cleanup already has it. Release it with /// [`AppState::release_processing`]. pub fn reserve_processing(&self, id: CallId) -> bool { lock(&self.processing).insert(id) } /// Ends the pipeline run claimed by [`AppState::claim_processing`] (or /// the cleanup reserved by [`AppState::reserve_processing`]). pub fn release_processing(&self, id: CallId) { lock(&self.processing).remove(&id); } /// Whether a recording runs or starts, or a call is being processed (or /// its remote jobs cleaned up). An update must not be installed then: /// the installer ends the app. pub fn recording_or_processing(&self) -> bool { self.devices_busy.load(Ordering::SeqCst) || lock(&self.current).is_some() || !lock(&self.processing).is_empty() } /// Records both configured devices into a temporary directory for five /// seconds and returns the peak level of each track. pub fn test_devices(&self) -> Result { let _claim = self.claim_devices("Während einer Aufnahme ist kein Test möglich")?; let settings = self.settings(); let dir = tempfile::tempdir() .map_err(|e| format!("Testordner konnte nicht angelegt werden: {e}"))?; let mic = recorder_audio::mic_source(settings.mic_device.as_deref()); let out = recorder_audio::output_source(output_target(&settings)); let recorder = Recorder::start( mic, out, &dir.path().join("test-mic.wav"), &dir.path().join("test-out.wav"), ) .map_err(|e| format!("Test fehlgeschlagen: {e}"))?; let mut peak = DeviceLevels { mic: 0.0, out: 0.0 }; let until = Instant::now() + TEST_DURATION; while Instant::now() < until { thread::sleep(TEST_POLL); let (mic, out) = recorder.levels(); peak.mic = peak.mic.max(mic); peak.out = peak.out.max(out); } recorder.discard(); Ok(peak) } /// Reserves the audio devices for a recording start or a test. Fails /// with `recording_msg` while a recording runs. fn claim_devices(&self, recording_msg: &str) -> Result, String> { if self.devices_busy.swap(true, Ordering::SeqCst) { return Err("Die Audiogeräte werden gerade getestet oder gestartet".to_string()); } let claim = DevicesClaim(&self.devices_busy); // Checked after claiming: a start that just finished has already // stored its recording before releasing the claim. if lock(&self.current).is_some() { return Err(recording_msg.to_string()); } Ok(claim) } fn track_paths(&self, id: CallId) -> (PathBuf, PathBuf) { ( self.recordings_dir.join(format!("{id}-mic.wav")), self.recordings_dir.join(format!("{id}-out.wav")), ) } } /// The output a detected call is recorded from: the configured output /// device, else the device on which the call app (`exe`, `root_pid`) has an /// active render session, else the default communications device. Always /// device loopback: new Teams plays call audio from a process outside the /// ms-teams.exe tree, so loopback of that process tree recorded silence. fn detected_output_target( output_device: Option<&str>, sessions: &[RenderSession], exe: &str, root_pid: u32, ) -> OutputTarget { if let Some(id) = output_device { log::info!("out track: configured output device {id}"); return OutputTarget::Device(id.to_string()); } match recorder_audio::render_endpoint_for(sessions, exe, root_pid) { Some(session) => { log::info!( "out track: call app playing on {} ({})", session.device_name, session.device_id ); OutputTarget::Device(session.device_id.clone()) } None => { log::info!("out track: no render session of {exe} found, using communications default"); OutputTarget::DefaultRender } } } fn save(settings: &Settings, path: &Path) -> Result<(), String> { settings .save(path) .map_err(|e| format!("Einstellungen konnten nicht gespeichert werden: {e}")) } fn output_target(settings: &Settings) -> OutputTarget { match &settings.output_device { Some(id) => OutputTarget::Device(id.clone()), None => OutputTarget::DefaultRender, } } /// Locks ignoring poisoning: a panic in one command must not wedge the app. fn lock(mutex: &Mutex) -> MutexGuard<'_, T> { mutex .lock() .unwrap_or_else(|poisoned| poisoned.into_inner()) } #[cfg(test)] mod tests { use chrono::TimeZone; use recorder_core::backend::{KeyInfo, NewKey, StoredKey}; use recorder_core::model::{Segment, Speaker}; use recorder_core::secrets::{MemorySecrets, Service}; use super::*; struct Fixture { state: AppState, dir: tempfile::TempDir, } fn fixture() -> Fixture { let dir = tempfile::tempdir().unwrap(); let state = AppState::new( Store::open_in_memory().unwrap(), Box::new(MemorySecrets::default()), dir.path().join("settings.json"), dir.path().join("recordings"), dir.path().join("playback"), ); Fixture { state, dir } } fn at(h: u32, m: u32, s: u32) -> DateTime { Local.with_ymd_and_hms(2026, 11, 5, h, m, s).unwrap() } /// A finished call from 10:14:00 to 10:46:30 with both track files /// (`-mic.wav`, `-out.wav`). fn finished_call(f: &Fixture, name: &str) -> (CallId, PathBuf, PathBuf) { let mic = f.dir.path().join(format!("{name}-mic.wav")); let out = f.dir.path().join(format!("{name}-out.wav")); fs::write(&mic, b"mic").unwrap(); fs::write(&out, b"out").unwrap(); let store = &f.state.store; let id = store .create_call("Microsoft Teams", at(10, 14, 0), &mic, &out) .unwrap(); store.finish_recording(id, at(10, 46, 30), false).unwrap(); (id, mic, out) } #[test] fn call_brief_has_app_times_and_duration() { let f = fixture(); let (id, _, _) = finished_call(&f, "a"); assert_eq!( f.state.call_brief(id).unwrap(), CallBrief { id, app: "Microsoft Teams".into(), started_at: at(10, 14, 0), ended_at: Some(at(10, 46, 30)), duration_secs: 32 * 60 + 30, } ); assert!(f.state.call_brief(id + 1).is_err()); } fn queued(f: &Fixture) -> Option<(CallId, usize)> { f.state .pending_prompt() .map(|prompt| (prompt.brief.id, prompt.more_waiting)) } #[test] fn pending_prompt_shows_the_call_until_it_is_gone() { let f = fixture(); assert_eq!(f.state.pending_prompt(), None); let (id, _, _) = finished_call(&f, "a"); f.state.queue_prompt(id); assert_eq!(queued(&f), Some((id, 0))); assert_eq!( f.state.pending_prompt().map(|p| p.brief), Some(f.state.call_brief(id).unwrap()) ); f.state.store.delete_call(id).unwrap(); assert_eq!(f.state.pending_prompt(), None); } #[test] fn prompts_queue_up_in_order() { let f = fixture(); let (first, _, _) = finished_call(&f, "a"); let (second, _, _) = finished_call(&f, "b"); f.state.queue_prompt(first); f.state.queue_prompt(second); f.state.queue_prompt(first); // queued once only assert_eq!(queued(&f), Some((first, 1))); // Deciding the first shows the second. assert_eq!(f.state.discard_call(first), Ok(1)); assert_eq!(queued(&f), Some((second, 0))); assert_eq!(f.state.discard_call(second), Ok(0)); assert_eq!(queued(&f), None); } #[test] fn a_queued_call_is_decided_by_id_not_by_position() { let f = fixture(); let (a, _, _) = finished_call(&f, "a"); let (b, _, _) = finished_call(&f, "b"); let (c, _, _) = finished_call(&f, "c"); for id in [a, b, c] { f.state.queue_prompt(id); } assert_eq!(f.state.discard_call(b), Ok(2)); assert_eq!(queued(&f), Some((a, 1))); assert_eq!(f.state.remove_queued_prompt(a), Some(0)); assert_eq!(queued(&f), Some((c, 0))); assert_eq!(f.state.remove_queued_prompt(a), None); } #[test] fn a_vanished_call_is_skipped() { let f = fixture(); let (gone, _, _) = finished_call(&f, "a"); let (next, _, _) = finished_call(&f, "b"); f.state.queue_prompt(gone); f.state.queue_prompt(next); f.state.store.delete_call(gone).unwrap(); assert_eq!(queued(&f), Some((next, 0))); } #[test] fn discard_call_deletes_audio_and_row_and_clears_the_prompt() { let f = fixture(); let (id, mic, out) = finished_call(&f, "a"); f.state.queue_prompt(id); assert_eq!(f.state.discard_call(id), Ok(0)); assert!(!mic.exists()); assert!(!out.exists()); assert_eq!(f.state.store.get_call(id).unwrap(), None); assert_eq!(f.state.pending_prompt(), None); } #[test] fn discard_call_of_an_unqueued_call_keeps_the_prompt() { let f = fixture(); let (pending, _, _) = finished_call(&f, "a"); f.state.queue_prompt(pending); let other = f .state .store .create_call("MicroSIP", at(9, 0, 0), Path::new(""), Path::new("")) .unwrap(); // Missing track files are not an error. assert_eq!(f.state.discard_call(other), Ok(1)); assert_eq!(f.state.store.get_call(other).unwrap(), None); assert_eq!(queued(&f), Some((pending, 0))); } #[test] fn discarding_an_unqueued_call_reports_an_empty_queue() { // The prompt window hides whenever nothing is left, even if the // discarded call had already dropped out of the queue. let f = fixture(); let (id, _, _) = finished_call(&f, "a"); assert_eq!(f.state.discard_call(id), Ok(0)); assert_eq!(f.state.prompts_waiting(), 0); } #[test] fn a_call_being_processed_is_not_discarded() { let f = fixture(); let (id, mic, out) = finished_call(&f, "a"); f.state.queue_prompt(id); f.state.claim_processing(id, false).unwrap(); assert_eq!( f.state.discard_call(id), Err(DiscardError::Other("Wird bereits verarbeitet".to_string())) ); f.state.release_processing(id); f.state .store .set_status(id, CallStatus::Processing, None) .unwrap(); assert_eq!( f.state.discard_call(id), Err(DiscardError::Other("Wird bereits verarbeitet".to_string())) ); assert!(mic.exists()); assert!(out.exists()); assert!(f.state.store.get_call(id).unwrap().is_some()); assert_eq!(f.state.prompts_waiting(), 1); } #[test] fn a_call_with_recorded_remote_jobs_is_not_discarded() { let f = fixture(); let (id, mic, out) = finished_call(&f, "a"); f.state.queue_prompt(id); f.state .store .set_status(id, CallStatus::Failed, Some("Fehler")) .unwrap(); f.state.store.record_remote_job(id, "mic", "job-1").unwrap(); assert_eq!(f.state.discard_call(id), Err(DiscardError::CleanupPending)); assert_eq!( DiscardError::CleanupPending.to_string(), "Daten bei DeepScript werden noch gelöscht – bitte später erneut versuchen." ); assert!(mic.exists()); assert!(out.exists()); assert!(f.state.store.get_call(id).unwrap().is_some()); assert_eq!(f.state.store.remote_jobs(id).unwrap().len(), 1); assert_eq!(f.state.prompts_waiting(), 1); // Not reserved: the cleanup the command starts can take the call. assert!(f.state.reserve_processing(id)); } #[test] fn a_transcribed_call_is_deleted_like_any_other() { let f = fixture(); let (id, mic, out) = finished_call(&f, "a"); f.state .store .set_status(id, CallStatus::Done, None) .unwrap(); assert_eq!(f.state.discard_call(id), Ok(0)); assert!(!mic.exists()); assert!(!out.exists()); assert_eq!(f.state.store.get_call(id).unwrap(), None); } #[test] fn a_call_being_uploaded_is_not_discarded() { let f = fixture(); let (id, mic, out) = finished_call(&f, "a"); f.state .store .set_status(id, CallStatus::Done, None) .unwrap(); let claim = f.state.claim_upload(id).unwrap(); assert_eq!( f.state.discard_call(id), Err(DiscardError::Other("Wird bereits hochgeladen".to_string())) ); assert!(mic.exists()); assert!(out.exists()); assert!(f.state.store.get_call(id).unwrap().is_some()); // Once the upload is done, the delete goes through. drop(claim); assert_eq!(f.state.discard_call(id), Ok(0)); } #[test] fn a_call_already_uploaded_here_is_deleted_without_touching_the_crm() { let f = fixture(); let (id, mic, out) = finished_call(&f, "a"); f.state .store .set_status(id, CallStatus::Done, None) .unwrap(); f.state.mark_uploaded(id, "4711").unwrap(); assert_eq!(f.state.discard_call(id), Ok(0)); assert!(!mic.exists()); assert!(!out.exists()); assert_eq!(f.state.store.get_call(id).unwrap(), None); } #[test] fn a_cleanup_reserves_a_call_of_any_status() { let f = fixture(); let (id, _, _) = finished_call(&f, "a"); f.state .store .set_status(id, CallStatus::Done, None) .unwrap(); assert!(f.state.reserve_processing(id)); assert!(!f.state.reserve_processing(id)); f.state .store .set_status(id, CallStatus::Failed, Some("Fehler")) .unwrap(); assert_eq!( f.state.claim_processing(id, true), Err("Wird bereits verarbeitet".to_string()) ); f.state.release_processing(id); assert!(f.state.reserve_processing(id)); } #[test] fn a_call_is_processed_once_at_a_time() { let f = fixture(); let (id, _, _) = finished_call(&f, "a"); assert_eq!(f.state.claim_processing(id, false), Ok(())); assert_eq!( f.state.claim_processing(id, true), Err("Wird bereits verarbeitet".to_string()) ); f.state.release_processing(id); assert_eq!(f.state.claim_processing(id, false), Ok(())); } #[test] fn a_processing_call_is_not_claimed_again() { let f = fixture(); let (id, _, _) = finished_call(&f, "a"); f.state .store .set_status(id, CallStatus::Processing, None) .unwrap(); assert_eq!( f.state.claim_processing(id, true), Err("Wird bereits verarbeitet".to_string()) ); } #[test] fn a_failed_call_is_processed_again_on_retry_or_from_the_prompt() { let f = fixture(); let (id, _, _) = finished_call(&f, "a"); f.state .store .set_status(id, CallStatus::Failed, Some("Fehler")) .unwrap(); assert!(f.state.claim_processing(id, false).is_err()); assert_eq!(f.state.claim_processing(id, true), Ok(())); f.state.release_processing(id); f.state.queue_prompt(id); assert_eq!(f.state.claim_processing(id, false), Ok(())); } #[test] fn an_update_waits_while_a_call_is_processed() { let f = fixture(); let (id, _, _) = finished_call(&f, "a"); assert!(!f.state.recording_or_processing()); f.state.claim_processing(id, false).unwrap(); assert!(f.state.recording_or_processing()); f.state.release_processing(id); assert!(!f.state.recording_or_processing()); } #[test] fn an_update_waits_while_a_recording_starts() { let f = fixture(); let claim = f .state .claim_devices("Es läuft bereits eine Aufnahme") .unwrap(); assert!(f.state.recording_or_processing()); drop(claim); assert!(!f.state.recording_or_processing()); } #[test] fn done_and_recording_calls_are_not_processed() { let f = fixture(); let (done, _, _) = finished_call(&f, "a"); f.state .store .set_status(done, CallStatus::Done, None) .unwrap(); assert!(f.state.claim_processing(done, true).is_err()); let recording = f .state .store .create_call("Manuell", at(9, 0, 0), Path::new(""), Path::new("")) .unwrap(); assert!(f.state.claim_processing(recording, true).is_err()); assert!(f.state.claim_processing(recording + 1, true).is_err()); } #[test] fn call_list_is_newest_first_with_durations() { let f = fixture(); let (older, _, _) = finished_call(&f, "a"); let newer = f .state .store .create_call("Manuell", at(11, 0, 0), Path::new(""), Path::new("")) .unwrap(); let list = f.state.call_list().unwrap(); let rows: Vec<_> = list .iter() .map(|item| (item.id, item.status, item.duration_secs)) .collect(); assert_eq!( rows, [ (newer, CallStatus::Recording, 0), (older, CallStatus::AwaitingDecision, 32 * 60 + 30), ] ); } #[test] fn call_detail_shows_the_transcript_with_renamed_speakers() { let f = fixture(); let (id, _, _) = finished_call(&f, "a"); f.state .store .save_segments( id, &[ Segment { speaker: Speaker::Me, start: 0.0, end: 1.5, text: "Guten Tag.".into(), }, Segment { speaker: Speaker::Remote(1), start: 2.0, end: 3.0, text: "Hallo.".into(), }, ], ) .unwrap(); f.state .rename_speaker(id, "remote:1", "Frau Probe") .unwrap(); let detail = f.state.call_detail(id).unwrap(); assert_eq!(detail.call.item.id, id); let labels: Vec<_> = detail.segments.iter().map(|s| s.label.as_str()).collect(); assert_eq!(labels, ["Ich", "Frau Probe"]); assert!(f.state.call_detail(id + 1).is_err()); } #[test] fn renaming_a_speaker_trims_and_an_empty_name_restores_the_default() { let f = fixture(); let (id, _, _) = finished_call(&f, "a"); let names = |f: &Fixture| f.state.store.speaker_names(id).unwrap(); f.state .rename_speaker(id, "remote:2", " Herr Test ") .unwrap(); assert_eq!( names(&f).get("remote:2").map(String::as_str), Some("Herr Test") ); f.state.rename_speaker(id, "remote:2", " ").unwrap(); assert!(names(&f).is_empty()); } #[test] fn renaming_needs_a_known_speaker_and_call() { let f = fixture(); let (id, _, _) = finished_call(&f, "a"); assert!(f.state.rename_speaker(id, "remote:x", "Name").is_err()); assert!(f.state.rename_speaker(id + 1, "me", "Name").is_err()); assert!(f.state.store.speaker_names(id).unwrap().is_empty()); } /// A finished call whose transcript has "Ich" and remote speakers 1 and 2. fn transcribed_call(f: &Fixture) -> CallId { let (id, _, _) = finished_call(f, "a"); let line = |speaker, start: f64, text: &str| Segment { speaker, start, end: start + 1.0, text: text.into(), }; f.state .store .save_segments( id, &[ line(Speaker::Remote(1), 0.0, "Guten Tag,"), line(Speaker::Remote(2), 1.5, "hier Weingut Beispiel."), line(Speaker::Me, 3.0, "Hallo."), ], ) .unwrap(); id } fn transcript(f: &Fixture, id: CallId) -> Vec<(String, String)> { f.state .call_detail(id) .unwrap() .segments .into_iter() .map(|s| (s.label, s.text)) .collect() } #[test] fn merging_speakers_joins_their_lines_until_undone() { let f = fixture(); let id = transcribed_call(&f); let before = transcript(&f, id); f.state.merge_speakers(id, "remote:2", "remote:1").unwrap(); assert_eq!( transcript(&f, id), [ ( "Sprecher 1".into(), "Guten Tag, hier Weingut Beispiel.".into() ), ("Ich".into(), "Hallo.".into()), ] ); assert_eq!(f.state.call_detail(id).unwrap().merges.len(), 1); f.state.unmerge_speaker(id, "remote:2").unwrap(); assert_eq!(transcript(&f, id), before); assert!(f.state.call_detail(id).unwrap().merges.is_empty()); } #[test] fn merging_needs_a_known_call_and_speakers_of_the_call() { let f = fixture(); let id = transcribed_call(&f); let merge = |from, into| f.state.merge_speakers(id, from, into); assert_eq!( f.state.merge_speakers(id + 1, "remote:2", "remote:1"), Err("Gespräch nicht gefunden".to_string()) ); assert_eq!( merge("remote:x", "remote:1"), Err("Unbekannter Sprecher: remote:x".to_string()) ); assert_eq!( merge("remote:2", "remote:3"), Err("Unbekannter Sprecher: remote:3".to_string()) ); assert!(merge("me", "remote:1").is_err()); merge("remote:2", "remote:1").unwrap(); assert_eq!( merge("remote:1", "remote:2"), Err("Diese Zuordnung würde eine Schleife ergeben".to_string()) ); assert!(f.state.unmerge_speaker(id + 1, "remote:2").is_err()); assert_eq!(f.state.store.speaker_merges(id).unwrap().len(), 1); } #[test] fn a_call_is_named_and_the_name_cleared() { let f = fixture(); let (id, _, _) = finished_call(&f, "a"); let title = |f: &Fixture| f.state.call_list().unwrap()[0].title.clone(); f.state.rename_call(id, Some(" Angebot Rioja ")).unwrap(); assert_eq!(title(&f).as_deref(), Some("Angebot Rioja")); assert_eq!( f.state.call_detail(id).unwrap().call.item.title.as_deref(), Some("Angebot Rioja") ); assert_eq!( f.state.rename_call(id, Some(&"x".repeat(121))), Err("Titel zu lang (max. 120 Zeichen)".to_string()) ); f.state.rename_call(id, Some("")).unwrap(); assert_eq!(title(&f), None); assert_eq!( f.state.rename_call(id + 1, Some("Test")), Err("Gespräch nicht gefunden".to_string()) ); } #[test] fn invalid_detection_delays_are_not_saved() { let f = fixture(); let invalid = Settings { end_after_secs: 2, ..Settings::default() }; assert_eq!( f.state.save_settings(invalid), Err("Ende nach: 3–120 Sekunden".to_string()) ); assert_eq!(f.state.settings(), Settings::default()); assert!(!f.dir.path().join("settings.json").exists()); let valid = Settings { end_after_secs: 30, ..Settings::default() }; assert_eq!(f.state.save_settings(valid.clone()), Ok(())); assert_eq!(f.state.settings(), valid); } fn new_key(key: &str) -> NewKey { NewKey { key: key.into(), expires_at: Local.with_ymd_and_hms(2027, 11, 6, 10, 0, 0).unwrap(), } } const BASE: &str = crate::backend::BACKEND_URL; #[test] fn a_stored_backend_key_comes_with_its_login_and_server() { let f = fixture(); assert_eq!(f.state.backend_key(), None); f.state .store_backend_key( &new_key("euv_k"), &format!("{BASE}/"), Some("hinrichs".into()), ) .unwrap(); let expires_at = Local.with_ymd_and_hms(2027, 11, 6, 10, 0, 0).unwrap(); assert_eq!( f.state.backend_key(), Some(StoredKey { key: "euv_k".into(), expires_at: Some(expires_at), }) ); let saved = Settings::load(&f.dir.path().join("settings.json")); assert_eq!(saved.backend_username.as_deref(), Some("hinrichs")); assert_eq!(saved.backend_key_expires_at, Some(expires_at)); assert_eq!(saved.backend_key_base_url.as_deref(), Some(BASE)); assert!(!fs::read_to_string(f.dir.path().join("settings.json")) .unwrap() .contains("euv_k")); assert_eq!(f.state.settings(), saved); } #[test] fn a_key_of_another_server_is_not_stored() { let f = fixture(); let err = f .state .store_backend_key(&new_key("euv_k"), "https://other.example", None) .unwrap_err(); assert!(err.contains("anderen Server"), "{err}"); assert_eq!(f.state.secrets.get(Service::Backend), None); assert_eq!(f.state.settings(), Settings::default()); } #[test] fn a_stored_key_of_another_server_is_discarded_before_use() { for recorded in [Some("https://other.example"), None] { let f = fixture(); f.state .store_backend_key(&new_key("euv_k"), BASE, Some("hinrichs".into())) .unwrap(); // As if stored by a build for another backend. f.state .update_settings(|s| s.backend_key_base_url = recorded.map(str::to_string)) .unwrap(); assert_eq!(f.state.backend_key(), None, "{recorded:?}"); assert_eq!(f.state.secrets.get(Service::Backend), None); let settings = f.state.settings(); assert_eq!(settings.backend_username, None); assert_eq!(settings.backend_key_expires_at, None); assert_eq!(settings.backend_key_base_url, None); } } /// The real transition the review asked to lock in: a key created while /// this install talked to the test backend must not work once the same /// install is a release build talking to the production backend — it is /// discarded and a fresh login is required, exactly like any other /// backend mismatch above, but with the two real build-time constants /// instead of a placeholder domain. #[test] fn a_key_from_the_test_backend_does_not_work_for_a_release_build() { let mut f = fixture(); // A build on the test backend (what `cargo tauri dev` is), whatever // profile this test itself runs in. f.state.backend_url = crate::backend::DEV_BACKEND_URL.to_string(); f.state .store_backend_key( &new_key("euv_test"), crate::backend::DEV_BACKEND_URL, Some("hinrichs".into()), ) .unwrap(); assert!(f.state.backend_key().is_some()); // Same keyring entry and settings file; now read as a release build // would (a different `backend_url`, nothing else changed). f.state.backend_url = crate::backend::RELEASE_BACKEND_URL.to_string(); assert_eq!( f.state.backend_key(), None, "a test-backend key must not work for the release backend" ); assert_eq!(f.state.secrets.get(Service::Backend), None); let settings = f.state.settings(); assert_eq!(settings.backend_username, None); assert_eq!(settings.backend_key_base_url, None); } #[test] fn the_backend_login_is_refreshed_from_the_key_info() { let f = fixture(); f.state .store_backend_key(&new_key("euv_k"), BASE, None) .unwrap(); let later = Local.with_ymd_and_hms(2028, 1, 1, 0, 0, 0).unwrap(); f.state .refresh_backend_login(&KeyInfo { label: "l".into(), hint: "h".into(), username: "hinrichs".into(), created_at: later, expires_at: later, }) .unwrap(); let settings = f.state.settings(); assert_eq!(settings.backend_username.as_deref(), Some("hinrichs")); assert_eq!(settings.backend_key_expires_at, Some(later)); assert_eq!(settings.backend_key_base_url.as_deref(), Some(BASE)); } #[test] fn a_discarded_backend_key_is_gone_with_its_login() { let f = fixture(); f.state .store_backend_key(&new_key("euv_k"), BASE, Some("hinrichs".into())) .unwrap(); f.state.discard_backend_key().unwrap(); assert_eq!(f.state.backend_key(), None); assert_eq!(f.state.secrets.get(Service::Backend), None); let settings = f.state.settings(); assert_eq!(settings.backend_username, None); assert_eq!(settings.backend_key_expires_at, None); assert_eq!(settings.backend_key_base_url, None); } #[test] fn only_the_refused_key_is_discarded() { let f = fixture(); f.state .store_backend_key(&new_key("euv_new"), BASE, None) .unwrap(); // A login stored a new key after the old one was refused. assert_eq!(f.state.discard_refused_backend_key("euv_old"), Ok(false)); assert_eq!( f.state.backend_key().map(|k| k.key).as_deref(), Some("euv_new") ); assert_eq!(f.state.discard_refused_backend_key("euv_new"), Ok(true)); assert_eq!(f.state.backend_key(), None); assert_eq!(f.state.settings().backend_key_base_url, None); } #[test] fn saving_settings_keeps_the_backend_login() { let f = fixture(); f.state .store_backend_key(&new_key("euv_k"), BASE, Some("hinrichs".into())) .unwrap(); // The settings page sends what it loaded, maybe before the login. let edited = Settings { retention_days: 14, ..Settings::default() }; assert_eq!(f.state.save_settings(edited), Ok(())); assert!(f.state.backend_key().is_some()); let settings = f.state.settings(); assert_eq!(settings.backend_username.as_deref(), Some("hinrichs")); assert_eq!(settings.backend_key_base_url.as_deref(), Some(BASE)); assert_eq!(settings.retention_days, 14); } #[test] fn the_backend_is_fixed_per_build() { let f = fixture(); // Debug builds (`cargo tauri dev`, `cargo test`) use the test // backend, release builds the production one. let expected = if cfg!(debug_assertions) { "https://test.euvinopro.eu" } else { "https://backend.euvinopro.eu" }; assert_eq!(f.state.backend_url(), expected); assert_eq!( f.state.backend_client().login_url(), format!("{expected}/euvadm") ); } #[test] fn a_call_is_uploaded_once_at_a_time() { let f = fixture(); let (id, _, _) = finished_call(&f, "a"); let (other, _, _) = finished_call(&f, "b"); assert!(!f.state.call_detail(id).unwrap().uploading); let claim = f.state.claim_upload(id).unwrap(); assert!(f.state.is_uploading(id)); assert!(f.state.call_detail(id).unwrap().uploading); assert_eq!( f.state.claim_upload(id).err(), Some("Wird bereits hochgeladen".to_string()) ); assert!(f.state.claim_upload(other).is_ok(), "other calls are free"); drop(claim); assert!(!f.state.is_uploading(id)); assert!(f.state.claim_upload(id).is_ok()); } #[test] fn a_call_already_uploaded_is_not_claimed_again() { let f = fixture(); let (id, _, _) = finished_call(&f, "a"); f.state.mark_uploaded(id, "4711").unwrap(); assert_eq!( f.state.claim_upload(id).err(), Some("Bereits hochgeladen".to_string()) ); assert!(!f.state.is_uploading(id)); } /// The real case the review asked to lock in: a call uploaded to the /// test backend is refused for upload by a build whose own backend is /// the test backend (the normal case, above), but uploadable again by a /// build whose backend is the production one — the CRM at that backend /// has never seen this transcript. #[test] fn an_upload_to_another_backend_is_not_counted_as_uploaded_here() { let mut f = fixture(); let (id, _, _) = finished_call(&f, "a"); // A build on the test backend (what `cargo tauri dev` is), whatever // profile this test itself runs in: mark_uploaded records it. f.state.backend_url = crate::backend::DEV_BACKEND_URL.to_string(); f.state.mark_uploaded(id, "4711").unwrap(); assert_eq!( f.state.find_call(id).unwrap().crm_base_url.as_deref(), Some(crate::backend::DEV_BACKEND_URL) ); assert_eq!( f.state.claim_upload(id).err(), Some("Bereits hochgeladen".to_string()) ); // The same row, now read as a release build would be: a different // backend, nothing else changed. f.state.backend_url = crate::backend::RELEASE_BACKEND_URL.to_string(); assert!(f.state.claim_upload(id).is_ok()); } #[test] fn an_upload_confirmed_but_unsaved_is_never_retried() { // The CRM has the transcript, but mark_uploaded failed: the row // itself still shows no crm_transcript_id. let f = fixture(); let (id, _, _) = finished_call(&f, "a"); f.state.note_upload_confirmed_but_unsaved(id); assert!(f .state .call_detail(id) .unwrap() .call .item .crm_transcript_id .is_none()); assert_eq!( f.state.claim_upload(id).err(), Some("Bereits hochgeladen".to_string()) ); assert!(!f.state.is_uploading(id)); } #[test] fn an_upload_is_recorded_on_the_call() { let f = fixture(); let (id, _, _) = finished_call(&f, "a"); f.state.mark_uploaded(id, "4711").unwrap(); let call = f.state.store.get_call(id).unwrap().unwrap(); assert_eq!(call.crm_transcript_id.as_deref(), Some("4711")); assert_eq!(call.crm_base_url.as_deref(), Some(BASE)); assert!(call.uploaded_at.is_some()); assert_eq!( f.state.mark_uploaded(id + 1, "1"), Err("Gespräch nicht gefunden".to_string()) ); } fn render_session(exe: &str, root_pid: u32, device: &str) -> RenderSession { RenderSession { exe: exe.to_string(), pid: root_pid + 1, root_pid, active: true, device_id: format!("id-{device}"), device_name: device.to_string(), } } #[test] fn detected_calls_record_the_device_the_call_app_plays_on() { let sessions = [ render_session("spotify.exe", 50, "Lautsprecher"), render_session("ms-teams.exe", 100, "Headset"), ]; assert_eq!( detected_output_target(None, &sessions, "ms-teams.exe", 100), OutputTarget::Device("id-Headset".into()) ); } #[test] fn detected_calls_without_a_render_session_record_the_default_device() { let sessions = [render_session("spotify.exe", 50, "Lautsprecher")]; assert_eq!( detected_output_target(None, &sessions, "ms-teams.exe", 100), OutputTarget::DefaultRender ); } #[test] fn a_configured_output_device_wins_for_detected_calls() { let sessions = [render_session("ms-teams.exe", 100, "Headset")]; assert_eq!( detected_output_target(Some("id-Lautsprecher"), &sessions, "ms-teams.exe", 100), OutputTarget::Device("id-Lautsprecher".into()) ); } /// A finished call whose tracks hold real audio: one second on the mic, /// half a second on the output. fn playable_call(f: &Fixture, name: &str) -> CallId { let (id, mic, out) = finished_call(f, name); for (path, samples) in [(&mic, 16_000), (&out, 8_000)] { let mut writer = recorder_core::audio::TrackWriter::create(path).unwrap(); writer.write(&vec![0.1; samples]).unwrap(); writer.finalize().unwrap(); } id } fn playback_file(f: &Fixture, id: CallId) -> PathBuf { f.dir.path().join("playback").join(format!("{id}.wav")) } #[test] fn a_finished_call_is_mixed_into_the_playback_cache() { let f = fixture(); let id = playable_call(&f, "a"); assert!(f.state.call_detail(id).unwrap().audio_available); let prepared = f.state.prepare_playback(id).unwrap(); assert!((prepared.duration_secs - 1.0).abs() < 1e-9); assert!(playback_file(&f, id).exists()); } #[test] fn the_player_holding_the_latest_lease_removes_the_mix() { let f = fixture(); let id = playable_call(&f, "a"); let first = f.state.prepare_playback(id).unwrap().lease; // The call was shown again before the first player let go. let second = f.state.prepare_playback(id).unwrap().lease; assert_ne!(first, second); f.state.release_playback(id, first); assert!( playback_file(&f, id).exists(), "the second player still plays" ); f.state.release_playback(id, second); assert!(!playback_file(&f, id).exists()); f.state.release_playback(id, second); // already gone: no error // A lease of one call never removes another call's mix. let other = playable_call(&f, "b"); let lease = f.state.prepare_playback(other).unwrap().lease; f.state.release_playback(id, lease); assert!(playback_file(&f, other).exists()); } #[test] fn missing_files_are_no_audio_but_not_deleted_audio() { let f = fixture(); let (id, mic, out) = finished_call(&f, "a"); // a few junk bytes each let detail = f.state.call_detail(id).unwrap(); assert!(!detail.audio_available); assert!(!detail.audio_deleted); fs::remove_file(mic).unwrap(); fs::remove_file(out).unwrap(); assert_eq!( f.state.prepare_playback(id), Err(playback::AUDIO_MISSING.to_string()) ); } #[test] fn recording_and_processing_calls_are_not_played() { let f = fixture(); let dir = f.dir.path(); let recording = f .state .store .create_call( "Microsoft Teams", at(10, 0, 0), &dir.join("r-mic.wav"), &dir.join("r-out.wav"), ) .unwrap(); assert_eq!( f.state.prepare_playback(recording), Err(playback::RECORDING.to_string()) ); let processing = playable_call(&f, "p"); f.state .store .set_status(processing, CallStatus::Processing, None) .unwrap(); assert_eq!( f.state.prepare_playback(processing), Err(playback::PROCESSING.to_string()) ); assert!(!playback_file(&f, processing).exists()); assert_eq!( f.state.prepare_playback(999), Err("Gespräch nicht gefunden".to_string()) ); } #[test] fn deleted_audio_is_not_played_and_its_mix_is_removed() { let f = fixture(); let id = playable_call(&f, "a"); f.state.prepare_playback(id).unwrap(); // What the retention sweep does to a transcribed call's audio. let call = f.state.store.get_call(id).unwrap().unwrap(); fs::remove_file(&call.mic_path).unwrap(); fs::remove_file(&call.out_path).unwrap(); f.state.store.mark_audio_deleted(id).unwrap(); let detail = f.state.call_detail(id).unwrap(); assert!(!detail.audio_available); assert!(detail.audio_deleted); assert_eq!( f.state.prepare_playback(id), Err(playback::AUDIO_GONE.to_string()) ); assert!(!playback_file(&f, id).exists()); } #[test] fn deleting_a_call_removes_its_mix() { let f = fixture(); let id = playable_call(&f, "a"); let other = playable_call(&f, "b"); f.state.prepare_playback(id).unwrap(); f.state.prepare_playback(other).unwrap(); f.state.discard_call(id).unwrap(); assert!(!playback_file(&f, id).exists()); assert!(playback_file(&f, other).exists()); assert_eq!( f.state.prepare_playback(id), Err("Gespräch nicht gefunden".to_string()) ); } #[test] fn the_playback_cache_is_emptied_at_startup() { let f = fixture(); let id = playable_call(&f, "a"); f.state.prepare_playback(id).unwrap(); f.state.clear_playback_cache(); assert!(!f.dir.path().join("playback").exists()); f.state.clear_playback_cache(); // nothing left: no error } }