feat(native): record encoding (#14188)

fix #13784 

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

* **New Features**
* Start/stop system or meeting recordings with Ogg/Opus artifacts and
native start/stop APIs; workspace backup recovery.

* **Refactor**
* Simplified recording lifecycle and UI flows; native runtime now
orchestrates recording/processing and reporting.

* **Bug Fixes**
* Stronger path validation, safer import/export dialogs, consistent
error handling/logging, and retry-safe recording processing.

* **Chores**
* Added cross-platform native audio capture and Ogg/Opus encoding
support.

* **Tests**
* New unit, integration, and e2e tests for recording, path guards,
dialogs, and workspace recovery.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

packages/frontend/native/media_capture/src/macos/screen_capture_kit.rs

@@ -34,6 +34,7 @@ use screencapturekit::shareable_content::SCShareableContent;
 use uuid::Uuid;
 
 use crate::{
+  audio_callback::AudioCallback,
   error::CoreAudioError,
   pid::{audio_process_list, get_process_property},
   tap_audio::{AggregateDeviceManager, AudioCaptureSession},
@@ -651,10 +652,9 @@ impl ShareableContent {
     Ok(false)
   }
 
-  #[napi]
-  pub fn tap_audio(
+  pub(crate) fn tap_audio_with_callback(
     process_id: u32,
-    audio_stream_callback: ThreadsafeFunction<napi::bindgen_prelude::Float32Array, ()>,
+    audio_stream_callback: AudioCallback,
   ) -> Result<AudioCaptureSession> {
     let app = ShareableContent::applications()?
       .into_iter()
@@ -668,13 +668,10 @@ impl ShareableContent {
         ));
       }
 
-      // Convert ThreadsafeFunction to Arc<ThreadsafeFunction>
-      let callback_arc = Arc::new(audio_stream_callback);
-
       // Use AggregateDeviceManager instead of AggregateDevice directly
       // This provides automatic default device change detection
       let mut device_manager = AggregateDeviceManager::new(&app)?;
-      device_manager.start_capture(callback_arc)?;
+      device_manager.start_capture(audio_stream_callback)?;
       let boxed_manager = Box::new(device_manager);
       Ok(AudioCaptureSession::new(boxed_manager))
     } else {
@@ -686,9 +683,16 @@ impl ShareableContent {
   }
 
   #[napi]
-  pub fn tap_global_audio(
-    excluded_processes: Option<Vec<&ApplicationInfo>>,
+  pub fn tap_audio(
+    process_id: u32,
     audio_stream_callback: ThreadsafeFunction<napi::bindgen_prelude::Float32Array, ()>,
+  ) -> Result<AudioCaptureSession> {
+    ShareableContent::tap_audio_with_callback(process_id, AudioCallback::Js(Arc::new(audio_stream_callback)))
+  }
+
+  pub(crate) fn tap_global_audio_with_callback(
+    excluded_processes: Option<Vec<&ApplicationInfo>>,
+    audio_stream_callback: AudioCallback,
   ) -> Result<AudioCaptureSession> {
     let excluded_object_ids = excluded_processes
       .unwrap_or_default()
@@ -696,13 +700,21 @@ impl ShareableContent {
       .map(|app| app.object_id)
       .collect::<Vec<_>>();
 
-    // Convert ThreadsafeFunction to Arc<ThreadsafeFunction>
-    let callback_arc = Arc::new(audio_stream_callback);
-
     // Use the new AggregateDeviceManager for automatic device adaptation
     let mut device_manager = AggregateDeviceManager::new_global(&excluded_object_ids)?;
-    device_manager.start_capture(callback_arc)?;
+    device_manager.start_capture(audio_stream_callback)?;
     let boxed_manager = Box::new(device_manager);
     Ok(AudioCaptureSession::new(boxed_manager))
   }
+
+  #[napi]
+  pub fn tap_global_audio(
+    excluded_processes: Option<Vec<&ApplicationInfo>>,
+    audio_stream_callback: ThreadsafeFunction<napi::bindgen_prelude::Float32Array, ()>,
+  ) -> Result<AudioCaptureSession> {
+    ShareableContent::tap_global_audio_with_callback(
+      excluded_processes,
+      AudioCallback::Js(Arc::new(audio_stream_callback)),
+    )
+  }
 }

packages/frontend/native/media_capture/src/macos/tap_audio.rs

@@ -20,15 +20,13 @@ use coreaudio::sys::{
   kAudioObjectPropertyElementMain, kAudioObjectPropertyScopeGlobal, kAudioObjectSystemObject, kAudioSubDeviceUIDKey,
   kAudioSubTapUIDKey,
 };
-use napi::{
-  bindgen_prelude::{Float32Array, Result, Status},
-  threadsafe_function::{ThreadsafeFunction, ThreadsafeFunctionCallMode},
-};
+use napi::bindgen_prelude::Result;
 use napi_derive::napi;
 use objc2::runtime::AnyObject;
 
 use crate::{
   audio_buffer::InputAndOutputAudioBufferList,
+  audio_callback::AudioCallback,
   ca_tap_description::CATapDescription,
   cf_types::CFDictionaryBuilder,
   device::get_device_uid,
@@ -220,7 +218,7 @@ impl AggregateDevice {
   /// Implementation for the AggregateDevice to start processing audio
   pub fn start(
     &mut self,
-    audio_stream_callback: Arc<ThreadsafeFunction<Float32Array, (), Float32Array, Status, true>>,
+    audio_stream_callback: AudioCallback,
     // Add original_audio_stats to ensure consistent target rate
     original_audio_stats: AudioStats,
   ) -> Result<AudioTapStream> {
@@ -275,8 +273,8 @@ impl AggregateDevice {
             return kAudioHardwareBadStreamError as i32;
           };
 
-          // Send the processed audio data to JavaScript
-          audio_stream_callback.call(Ok(mixed_samples.into()), ThreadsafeFunctionCallMode::NonBlocking);
+          // Send the processed audio data to the configured sink
+          audio_stream_callback.call(mixed_samples);
 
           kAudioHardwareNoError as i32
         },
@@ -527,7 +525,7 @@ pub struct AggregateDeviceManager {
   app_id: Option<AudioObjectID>,
   excluded_processes: Vec<AudioObjectID>,
   active_stream: Option<Arc<std::sync::Mutex<Option<AudioTapStream>>>>,
-  audio_callback: Option<Arc<ThreadsafeFunction<Float32Array, (), Float32Array, Status, true>>>,
+  audio_callback: Option<AudioCallback>,
   original_audio_stats: Option<AudioStats>,
 }
 
@@ -565,10 +563,7 @@ impl AggregateDeviceManager {
   }
 
   /// This sets up the initial stream and listeners.
-  pub fn start_capture(
-    &mut self,
-    audio_stream_callback: Arc<ThreadsafeFunction<Float32Array, (), Float32Array, Status, true>>,
-  ) -> Result<()> {
+  pub fn start_capture(&mut self, audio_stream_callback: AudioCallback) -> Result<()> {
     // Store the callback for potential device switch later
     self.audio_callback = Some(audio_stream_callback.clone());