# How to Implement Recording Start/Stop Notifications in Meetily > Learn how to implement recording start/stop notifications in Meetily. This tutorial details using Tauri events and OS-level alerts in your Rust backend for seamless user feedback. - Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily) - Tags: how-to-guide - Published: 2026-07-14 --- **Meetily implements recording notifications through a Rust Tauri backend that emits Tauri events and displays OS-level notifications via the `NotificationManager`, while respecting user preferences stored in the local database.** Meetily is an open-source meeting assistant built with Tauri and React that requires real-time user feedback when recording sessions change state. Implementing **recording start/stop notifications** involves coordinating the audio command layer, a dedicated notification manager, and user preference settings. This guide walks through the exact implementation using the actual source code from the Zackriya-Solutions/meetily repository. ## How Meetily's Notification Architecture Works The notification system spans both the Rust backend and React frontend. According to the Meetily source code, the `NotificationManager` in [`frontend/src-tauri/src/notifications/manager.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/notifications/manager.rs) acts as the central authority for displaying OS notifications. When recording commands execute in [`frontend/src-tauri/src/audio/recording_commands.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_commands.rs), they emit Tauri events and simultaneously trigger the notification manager to show alerts. ### Core Components - **NotificationManager**: Handles OS notification display via `tauri-plugin-notification` - **Recording Commands**: Emit lifecycle events (`recording-started`, `recording-stopped`, etc.) - **User Settings**: Control which notifications appear via [`frontend/src-tauri/src/notifications/settings.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/notifications/settings.rs) - **Frontend Listeners**: React hooks consume events for UI updates ## Triggering Notifications from Recording Commands Recording lifecycle events originate in [`frontend/src-tauri/src/audio/recording_commands.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_commands.rs). After successfully starting, stopping, pausing, or resuming a recording, the command emits a Tauri event and invokes the notification manager. ```rust // frontend/src-tauri/src/audio/recording_commands.rs pub async fn start_recording(app: &AppHandle) -> Result<()> { // ... audio pipeline start logic ... let meeting = current_meeting_name().await; // e.g., Some("Team Sync") // Emit event for frontend consumption app.emit_all("recording-started", &meeting)?; // Show OS notification (respects user settings) let notif_mgr = NotificationManager::new(app.clone()).await?; notif_mgr.show_recording_started(meeting).await?; Ok(()) } ``` The same pattern applies to `stop_recording`, `pause_recording`, and `resume_recording`, emitting `recording-stopped`, `recording-paused`, and `recording-resumed` events respectively. ## Creating Notification Payloads The `Notification` enum in [`frontend/src-tauri/src/notifications/types.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/notifications/types.rs) defines the structure of alerts. Helper constructors format user-friendly messages that optionally include the meeting name. ```rust // frontend/src-tauri/src/notifications/types.rs pub enum Notification { RecordingStarted { meeting_name: Option }, RecordingStopped { meeting_name: Option }, RecordingPaused { meeting_name: Option }, RecordingResumed { meeting_name: Option }, } impl Notification { pub fn recording_started(meeting_name: Option) -> Self { Self::RecordingStarted { meeting_name } } // Returns title and body for the OS notification pub fn title(&self) -> String { match self { Self::RecordingStarted { .. } => "Recording Started".to_string(), Self::RecordingStopped { .. } => "Recording Stopped".to_string(), _ => "Recording Update".to_string(), } } pub fn body(&self) -> String { match self { Self::RecordingStarted { meeting_name } => { match meeting_name { Some(name) => format!("Meeting: {}", name), None => "Recording has begun".to_string(), } } // ... additional variants } } } ``` ## Respecting User Preferences Before displaying any notification, the `NotificationManager` checks user settings defined in [`frontend/src-tauri/src/notifications/settings.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/notifications/settings.rs). Users can disable the entire notification system or specific event types. Key settings structure: - `recording_notifications`: Master toggle for all recording alerts - `show_recording_started`: Specific toggle for start events - `show_recording_stopped`: Specific toggle for stop events - `show_recording_paused` and `show_recording_resumed`: Granular controls for pause/resume ```rust // frontend/src-tauri/src/notifications/manager.rs pub async fn show_recording_started(&self, meeting_name: Option) -> Result<()> { let settings = self.settings.lock().await; // Check if user disabled this specific notification if !settings.notification_preferences.show_recording_started { return Ok(()); // Silently skip } let notification = Notification::recording_started(meeting_name); self.send(notification).await } ``` ## Frontend Integration The React frontend listens for Tauri events to update UI state (such as showing toast badges) while the backend handles OS-level notifications. Listen for events in components like [`src/components/Sidebar/SidebarProvider.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/src/components/Sidebar/SidebarProvider.tsx). ```typescript // Frontend React component import { listen } from '@tauri-apps/api/event'; useEffect(() => { const unlisten = await listen('recording-started', (event) => { toast.success(`Recording started${event.payload ? `: ${event.payload}` : ''}`); // Update sidebar state or recording indicator }); return () => { unlisten(); }; }, []); ``` To trigger recording from the frontend and initiate the notification flow: ```typescript import { invoke } from '@tauri-apps/api/tauri'; await invoke('start_recording', { mic_device_name: selectedMic, system_device_name: selectedSystem, meeting_name: "Team Sync" }); ``` ## Complete Implementation Checklist To add notification support for recording events in Meetily: 1. **Emit Tauri events** from [`frontend/src-tauri/src/audio/recording_commands.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_commands.rs) using `app.emit_all()` 2. **Call notification methods** such as `NotificationManager::show_recording_started()` immediately after successful command execution 3. **Define notification payloads** in [`frontend/src-tauri/src/notifications/types.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/notifications/types.rs) with clear titles and optional meeting context 4. **Check user preferences** in [`frontend/src-tauri/src/notifications/settings.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/notifications/settings.rs) before displaying any OS notification 5. **Listen for events** in the frontend using Tauri's `listen` API to update React state and display in-app toasts ## Summary - Meetily uses a **Rust-based `NotificationManager`** to display OS notifications for recording events - Recording commands in [`frontend/src-tauri/src/audio/recording_commands.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_commands.rs) emit Tauri events (`recording-started`, `recording-stopped`, etc.) and trigger notification methods - User preferences in [`frontend/src-tauri/src/notifications/settings.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/notifications/settings.rs) control which notifications appear via granular toggles - The **React frontend** listens for Tauri events to synchronize UI state with recording status - Notification payloads are constructed in [`frontend/src-tauri/src/notifications/types.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/notifications/types.rs) with meeting-specific context ## Frequently Asked Questions ### Where does Meetily store notification preferences? Notification preferences are persisted in the local database via the settings repository at [`frontend/src-tauri/src/database/repositories/setting.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/database/repositories/setting.rs). The `NotificationSettings` struct in [`frontend/src-tauri/src/notifications/settings.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/notifications/settings.rs) defines the available toggles, including `recording_notifications` as the master switch and specific flags like `show_recording_started` for individual events. ### Can I customize the notification message content? Yes. Modify the `Notification` enum constructors in [`frontend/src-tauri/src/notifications/types.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/notifications/types.rs). The `recording_started` and `recording_stopped` helper methods accept an optional `meeting_name` parameter and format the notification title and body. You can extend these constructors to include additional context such as timestamps or participant counts. ### What events trigger notifications in Meetily? The system emits notifications for four recording lifecycle events: `recording-started`, `recording-stopped`, `recording-paused`, and `recording-resumed`. Each event corresponds to a command in [`frontend/src-tauri/src/audio/recording_commands.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_commands.rs) and has dedicated methods in the `NotificationManager` (e.g., `show_recording_started()`, `show_recording_stopped()`). ### How do I disable notifications for specific recording events only? Users can disable specific event types without turning off all notifications. The `NotificationManager` checks individual boolean flags from `settings.notification_preferences` (such as `show_recording_started` or `show_recording_stopped`) before displaying each notification type. Set these flags to `false` in the settings UI to suppress specific alerts while keeping others active.