app_ui/

mic_ipc.rs

//! JS-bridge bindings for the M-MIC.1 / AUT-278 microphone commands
//! (M-MIC.2 / AUT-279).
//!
//! Mirrors [`crate::camera_ipc`] for the audio path. Each function
//! invokes a `__screen*` helper declared in `index.html`'s inline
//! script, which wraps `window.__TAURI__.core.invoke(...)`.
//!
//! Returned values are deserialised from `JsValue` into typed Rust
//! structs via `serde_wasm_bindgen` — same pattern as the camera +
//! player IPC modules.

use serde::{Deserialize, Serialize};
use wasm_bindgen::JsCast;
use wasm_bindgen::JsValue;
use wasm_bindgen::prelude::*;

use crate::camera_ipc::CameraPermission;

/// Mirror of `crates/app/src/commands.rs::MicrophoneView` (M-MIC.1).
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct MicrophoneView {
    /// Stable device id (`mic-…`).
    pub id: String,
    /// Human-readable label.
    pub label: String,
    /// `true` for the OS-default mic.
    pub is_default: bool,
    /// Native channel count from the gst caps line. `0` = unknown.
    pub channels: u8,
    /// Native sample rate from the gst caps line. `0` = unknown.
    pub sample_rate_hz: u32,
    /// Platform-native device identifier (M-MIC.3 / AUT-284).
    /// Round-tripped — the Rust side uses it to route to the
    /// per-OS gst element. Empty when gst didn't expose
    /// `unique-id` for this device.
    #[serde(default)]
    pub native_id: String,
}

/// Mirror of `crates/app/src/audio/mod.rs::MicLifecycle`. Tagged
/// representation matches the Rust enum's default serde shape (one
/// of `"Idle"` / `"Starting"` / `"Running"` / `"Stopping"`).
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
pub enum MicLifecycle {
    /// No worker running.
    #[default]
    Idle,
    /// Worker spawned; awaiting first chunk.
    Starting,
    /// Worker is producing chunks.
    Running,
    /// Worker is being torn down.
    Stopping,
}

#[wasm_bindgen]
extern "C" {
    /// `__screenListMicrophones()` — returns `Promise<MicrophoneView[]>`.
    #[wasm_bindgen(js_name = __screenListMicrophones, catch)]
    pub async fn list_microphones_js() -> Result<JsValue, JsValue>;

    /// `__screenStartMicCapture(micId)` — returns `Promise<void>`.
    #[wasm_bindgen(js_name = __screenStartMicCapture, catch)]
    pub async fn start_mic_capture_js(mic_id: String) -> Result<JsValue, JsValue>;

    /// `__screenStopMicCapture()` — returns `Promise<void>`.
    #[wasm_bindgen(js_name = __screenStopMicCapture, catch)]
    pub async fn stop_mic_capture_js() -> Result<JsValue, JsValue>;

    /// `__screenMicStatus()` — returns `Promise<MicLifecycle>`.
    #[wasm_bindgen(js_name = __screenMicStatus, catch)]
    pub async fn mic_status_js() -> Result<JsValue, JsValue>;

    /// `__screenMicrophonePermissionStatus()` — returns
    /// `Promise<CameraPermission>` (same three-variant shape).
    #[wasm_bindgen(js_name = __screenMicrophonePermissionStatus, catch)]
    pub async fn microphone_permission_status_js() -> Result<JsValue, JsValue>;

    /// `__screenOpenSettingsMicrophone()` (M-RECP.8 / AUT-286) —
    /// shells out to open System Settings → Privacy & Security →
    /// Microphone.
    #[wasm_bindgen(js_name = __screenOpenSettingsMicrophone, catch)]
    pub async fn open_settings_microphone_js() -> Result<JsValue, JsValue>;
}

/// Async helper: list every microphone the OS exposes.
///
/// Returns an empty `Vec` when running outside Tauri (plain
/// `trunk serve` browser preview), or when no mics are attached.
pub async fn list_microphones() -> Vec<MicrophoneView> {
    match list_microphones_js().await {
        Ok(value) => serde_wasm_bindgen::from_value(value).unwrap_or_default(),
        Err(_) => Vec::new(),
    }
}

/// Async helper: kick off `start_mic_capture` for the given mic id.
///
/// Failures are silently swallowed — the picker UX reads back the
/// effect via [`mic_status`] (and, in a follow-up, via the
/// `audio-levels` event when the meter wires up). The IPC layer's
/// re-entrant contract (M-MIC.1) means calling this with a new id
/// while an older session is running cleanly tears down the previous
/// pipeline.
pub async fn start_mic_capture(mic_id: String) {
    let _ = start_mic_capture_js(mic_id).await;
}

/// Async helper: tear down the active mic worker.
pub async fn stop_mic_capture() {
    let _ = stop_mic_capture_js().await;
}

/// Async helper: snapshot the worker lifecycle.
///
/// Returns `Idle` when running outside Tauri.
pub async fn mic_status() -> MicLifecycle {
    match mic_status_js().await {
        Ok(value) => serde_wasm_bindgen::from_value(value).unwrap_or_default(),
        Err(_) => MicLifecycle::Idle,
    }
}

/// Async helper: probe OS microphone permission state.
///
/// Returns `Granted` when running outside Tauri so the picker
/// renders normally during `trunk serve` dev.
pub async fn microphone_permission_status() -> CameraPermission {
    match microphone_permission_status_js().await {
        Ok(value) => serde_wasm_bindgen::from_value(value).unwrap_or(CameraPermission::Granted),
        Err(_) => CameraPermission::Granted,
    }
}

/// Async helper: shell out to open System Settings → Microphone
/// (M-RECP.8 / AUT-286). Same shape + silent-failure semantics as
/// [`crate::camera_ipc::open_settings_camera`].
pub async fn open_settings_microphone() {
    let _ = open_settings_microphone_js().await;
}

/// Subscribe to the `mic-level` Tauri event (M-AUDIO.METER /
/// AUT-287) emitted by `MicCapturePipeline` at ~20 Hz. The handler
/// receives an EMA-smoothed RMS in `[0.0, ~1.0]`.
///
/// Returns immediately; the listener runs for the lifetime of the
/// app (no cancellation today — the worker stops emitting when
/// `stop_mic_capture` drops the pipeline, which is sufficient
/// cleanup).
pub fn subscribe_mic_level(handler: impl Fn(f32) + 'static) {
    use wasm_bindgen::closure::Closure;
    let Some(window) = web_sys::window() else {
        return;
    };
    let Ok(tauri) = js_sys::Reflect::get(&window, &"__TAURI__".into()) else {
        return;
    };
    let Ok(event) = js_sys::Reflect::get(&tauri, &"event".into()) else {
        return;
    };
    let Ok(listen) = js_sys::Reflect::get(&event, &"listen".into()) else {
        return;
    };
    let Ok(listen_fn) = listen.dyn_into::<js_sys::Function>() else {
        return;
    };
    let cb = Closure::wrap(Box::new(move |payload: JsValue| {
        // payload shape from Tauri: { event, id, payload }
        #[allow(
            clippy::cast_possible_truncation,
            reason = "RMS in [0, 1] easily fits f32"
        )]
        let level = js_sys::Reflect::get(&payload, &"payload".into())
            .ok()
            .and_then(|v| v.as_f64())
            .map_or(0.0_f32, |v| v as f32);
        handler(level);
    }) as Box<dyn Fn(JsValue)>);
    let _ = listen_fn.call2(&event, &"mic-level".into(), cb.as_ref().unchecked_ref());
    // Leak the closure so the listener stays alive forever — matches
    // the app's "no cleanup until process exit" event-listener pattern
    // already established in player_ipc.rs.
    cb.forget();
}