feat: expose tauri app commands

src-tauri/src/app_state.rs

@@ -0,0 +1,83 @@
+use std::sync::Mutex;
+
+use serde::{Deserialize, Serialize};
+
+use crate::audio::{RecordingSession, RecordingStatus};
+use crate::models::{model_statuses, ModelWithStatus};
+use crate::settings::AppSettings;
+
+#[derive(Debug)]
+pub struct ManagedAppState {
+    pub settings: Mutex<AppSettings>,
+    pub recording: Mutex<RecordingSession>,
+    pub transcript: Mutex<TranscriptDraft>,
+}
+
+#[derive(Debug, Default, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct TranscriptDraft {
+    pub text: String,
+    pub last_message: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct AppSnapshot {
+    pub settings: AppSettings,
+    pub recording_status: RecordingStatus,
+    pub transcript: TranscriptDraft,
+    pub models: Vec<ModelWithStatus>,
+}
+
+impl Default for ManagedAppState {
+    fn default() -> Self {
+        Self {
+            settings: Mutex::new(AppSettings::default()),
+            recording: Mutex::new(RecordingSession::default()),
+            transcript: Mutex::new(TranscriptDraft::default()),
+        }
+    }
+}
+
+impl ManagedAppState {
+    pub fn snapshot(&self) -> Result<AppSnapshot, String> {
+        let settings = self
+            .settings
+            .lock()
+            .map_err(|_| "falha ao acessar configurações".to_string())?
+            .clone();
+        let recording_status = self
+            .recording
+            .lock()
+            .map_err(|_| "falha ao acessar estado de gravação".to_string())?
+            .status
+            .clone();
+        let transcript = self
+            .transcript
+            .lock()
+            .map_err(|_| "falha ao acessar transcrição".to_string())?
+            .clone();
+
+        Ok(AppSnapshot {
+            settings,
+            recording_status,
+            transcript,
+            models: model_statuses(),
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn default_snapshot_starts_idle() {
+        let state = ManagedAppState::default();
+        let snapshot = state.snapshot().expect("snapshot should work");
+
+        assert_eq!(snapshot.recording_status, RecordingStatus::Idle);
+        assert!(snapshot.transcript.text.is_empty());
+        assert_eq!(snapshot.models.len(), 1);
+    }
+}