feat #14740: play back calls
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
@@ -17,7 +17,7 @@ tauri-build = { version = "2.7.4", features = [] }
|
||||
serde_json = "1.0"
|
||||
serde = { version = "1.0", features = ["derive"] }
|
||||
log = "0.4"
|
||||
tauri = { version = "2.12.5", features = ["tray-icon"] }
|
||||
tauri = { version = "2.12.5", features = ["tray-icon", "protocol-asset"] }
|
||||
tauri-plugin-log = "2"
|
||||
tauri-plugin-autostart = "2"
|
||||
tauri-plugin-single-instance = "2"
|
||||
|
||||
@@ -11,6 +11,7 @@ use std::time::Duration;
|
||||
use recorder_core::call_view::{CallDetail, CallListItem};
|
||||
use recorder_core::capture::Devices;
|
||||
use recorder_core::model::CallId;
|
||||
use recorder_core::playback::PlaybackInfo;
|
||||
use recorder_core::secrets::Service;
|
||||
use recorder_core::settings::Settings;
|
||||
use serde::Serialize;
|
||||
@@ -208,6 +209,13 @@ pub fn rename_call(
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Mixes the call's two tracks into one file to play in the detail view
|
||||
/// (or reuses the cached mix); the UI plays it through the asset protocol.
|
||||
#[tauri::command]
|
||||
pub async fn prepare_playback(app: AppHandle, id: CallId) -> CmdResult<PlaybackInfo> {
|
||||
blocking(app, move |app| app.state::<AppState>().prepare_playback(id)).await
|
||||
}
|
||||
|
||||
/// Deletes a finished call's audio and row. Closes the prompt if no call
|
||||
/// waits for it any more; otherwise the prompt reloads and shows the next.
|
||||
/// While its DeepScript jobs are still on record, nothing is deleted and a
|
||||
|
||||
@@ -72,6 +72,9 @@ pub fn run() {
|
||||
|
||||
let data_dir = app.path().app_data_dir()?;
|
||||
let config_dir = app.path().app_config_dir()?;
|
||||
// The asset protocol may read this directory, and only this one
|
||||
// (`app.security.assetProtocol.scope` in tauri.conf.json).
|
||||
let playback_dir = app.path().app_cache_dir()?.join("playback");
|
||||
std::fs::create_dir_all(&data_dir)?;
|
||||
let store = Store::open(&data_dir.join("calls.sqlite"))?;
|
||||
let recovery = pipeline::recover_on_startup(&store)?;
|
||||
@@ -82,6 +85,7 @@ pub fn run() {
|
||||
Box::new(KeyringSecrets),
|
||||
config_dir.join("settings.json"),
|
||||
data_dir.join("recordings"),
|
||||
playback_dir,
|
||||
);
|
||||
let leftover_jobs = state.store.calls_with_remote_jobs().unwrap_or_else(|e| {
|
||||
log::error!("could not read leftover remote jobs: {e}");
|
||||
@@ -96,6 +100,8 @@ pub fn run() {
|
||||
std::thread::spawn(KeyringSecrets::remove_unused_keys);
|
||||
// Before anything can start a run.
|
||||
processing::clear_upload_dir(app.handle());
|
||||
// Before any window can ask for a mix.
|
||||
state.clear_playback_cache();
|
||||
app.manage(state);
|
||||
app.manage(PendingUpdate::default());
|
||||
app.manage(UpdateSchedule::default());
|
||||
@@ -154,6 +160,7 @@ pub fn run() {
|
||||
commands::merge_speakers,
|
||||
commands::unmerge_speaker,
|
||||
commands::rename_call,
|
||||
commands::prepare_playback,
|
||||
backend::backend_server,
|
||||
backend::backend_status,
|
||||
backend::backend_login,
|
||||
|
||||
+162
-3
@@ -2,9 +2,10 @@
|
||||
//!
|
||||
//! 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 and the calls being
|
||||
//! processed. Everything here is independent of windows and
|
||||
//! events; the command layer turns results into UI updates.
|
||||
//! 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::{HashSet, VecDeque};
|
||||
use std::fs;
|
||||
@@ -23,6 +24,7 @@ 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::{self, PlaybackInfo};
|
||||
use recorder_core::recorder::Recorder;
|
||||
use recorder_core::secrets::{SecretStore, Service};
|
||||
use recorder_core::settings::Settings;
|
||||
@@ -147,6 +149,12 @@ pub struct AppState {
|
||||
settings: Mutex<Settings>,
|
||||
settings_path: PathBuf,
|
||||
recordings_dir: PathBuf,
|
||||
/// Where the mixes for playback are cached (`<app cache>/playback`,
|
||||
/// the only directory the webview's asset protocol may read).
|
||||
playback_dir: PathBuf,
|
||||
/// Held while a mix is built or removed, so a call deleted meanwhile
|
||||
/// never leaves its mix behind.
|
||||
playback_lock: Mutex<()>,
|
||||
current: Mutex<Option<CurrentRecording>>,
|
||||
detector: Mutex<CallDetector>,
|
||||
/// Stopped calls awaiting the end-of-call prompt's decision, oldest
|
||||
@@ -201,6 +209,7 @@ impl AppState {
|
||||
secrets: Box<dyn SecretStore>,
|
||||
settings_path: PathBuf,
|
||||
recordings_dir: PathBuf,
|
||||
playback_dir: PathBuf,
|
||||
) -> Self {
|
||||
let settings = Settings::load(&settings_path);
|
||||
let detector = CallDetector::new(detector_config(&settings));
|
||||
@@ -211,6 +220,8 @@ impl AppState {
|
||||
settings: Mutex::new(settings),
|
||||
settings_path,
|
||||
recordings_dir,
|
||||
playback_dir,
|
||||
playback_lock: Mutex::new(()),
|
||||
current: Mutex::new(None),
|
||||
detector: Mutex::new(detector),
|
||||
pending_prompts: Mutex::new(VecDeque::new()),
|
||||
@@ -656,9 +667,44 @@ impl AppState {
|
||||
&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`]). Refused while the call is recorded or
|
||||
/// processed, and once its audio is gone.
|
||||
pub fn prepare_playback(&self, id: CallId) -> Result<PlaybackInfo, String> {
|
||||
if lock(&self.current)
|
||||
.as_ref()
|
||||
.is_some_and(|cur| cur.call_id == id)
|
||||
{
|
||||
return Err(playback::RECORDING.to_string());
|
||||
}
|
||||
let _building = lock(&self.playback_lock);
|
||||
// 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)?;
|
||||
playback::prepare(&call, &self.playback_dir)
|
||||
}
|
||||
|
||||
/// Removes call `id`'s cached mix, once the call or its audio is
|
||||
/// deleted.
|
||||
pub fn remove_playback(&self, id: CallId) {
|
||||
let _building = lock(&self.playback_lock);
|
||||
playback::remove_cached(&self.playback_dir, id);
|
||||
}
|
||||
|
||||
/// 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> {
|
||||
@@ -789,6 +835,7 @@ impl AppState {
|
||||
}
|
||||
drop(uploading);
|
||||
drop(processing);
|
||||
self.remove_playback(id);
|
||||
Ok(self.prompts_waiting())
|
||||
}
|
||||
|
||||
@@ -967,6 +1014,7 @@ mod tests {
|
||||
Box::new(MemorySecrets::default()),
|
||||
dir.path().join("settings.json"),
|
||||
dir.path().join("recordings"),
|
||||
dir.path().join("playback"),
|
||||
);
|
||||
Fixture { state, dir }
|
||||
}
|
||||
@@ -1897,4 +1945,115 @@ mod tests {
|
||||
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 info = f.state.prepare_playback(id).unwrap();
|
||||
assert_eq!(info.path, playback_file(&f, id));
|
||||
assert!((info.duration_secs - 1.0).abs() < 1e-9);
|
||||
assert!(info.path.exists());
|
||||
}
|
||||
|
||||
#[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();
|
||||
|
||||
assert!(!f.state.call_detail(id).unwrap().audio_available);
|
||||
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
|
||||
}
|
||||
}
|
||||
|
||||
@@ -44,7 +44,13 @@
|
||||
}
|
||||
],
|
||||
"security": {
|
||||
"csp": null
|
||||
"csp": null,
|
||||
"assetProtocol": {
|
||||
"enable": true,
|
||||
"scope": [
|
||||
"$APPCACHE/playback/**"
|
||||
]
|
||||
}
|
||||
}
|
||||
},
|
||||
"bundle": {
|
||||
|
||||
Reference in New Issue
Block a user