# How Meetily's Notification System Respects User Preferences: A Technical Deep Dive

> Discover how Meetily's Rust-based notification system respects user preferences. Explore consent flags, Do-Not-Disturb settings, and granular controls.

- Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily)
- Tags: deep-dive
- Published: 2026-07-25

---

**Meetily's notification system enforces user consent through a multi-layered Rust architecture that verifies consent flags, checks Do-Not-Disturb settings, and applies granular notification type controls before dispatching any alert.**

Meetily is an open-source meeting assistant built with Tauri and Rust that prioritizes user privacy and control. Its notification subsystem, located in `frontend/src-tauri/src/notifications/`, implements a comprehensive preference enforcement mechanism to ensure users receive only the alerts they've explicitly authorized. This article examines how the notification system respects user preferences through the `ConsentManager`, `NotificationSettings`, and `SystemHandler` components according to the Zackriya-Solutions/meetily source code.

## Core Components of the Preference System

### NotificationSettings and ConsentManager

The `NotificationSettings` struct defined in [`frontend/src-tauri/src/notifications/settings.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/notifications/settings.rs) encapsulates all user-configurable options. This includes boolean flags for `respect_do_not_disturb` and `manual_dnd_mode`, alongside a nested `NotificationPreferences` struct that controls specific alert types like recording notifications and meeting reminders.

The `ConsentManager` struct in the same file handles persistence, reading from and writing to a [`notifications.json`](https://github.com/Zackriya-Solutions/meetily/blob/main/notifications.json) file. It exposes helper methods including `has_consent()`, `has_system_permission()`, and `set_dnd_mode()` that the system queries before displaying any notification. According to the source code, methods like `set_dnd_mode()` read and write the JSON file while logging actions for transparency.

### SystemHandler and NotificationManager

The `SystemHandler` in [`frontend/src-tauri/src/notifications/system.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/notifications/system.rs) implements the low-level logic for respecting user preferences. Its `is_dnd_active()` method (line 51) checks both OS-level Do-Not-Disturb status and the user's manual DND flag. The `should_respect_dnd()` function (lines 84-85) filters notifications based on priority, ensuring that only non-critical notifications are suppressed when DND is active.

The `NotificationManager` in [`manager.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/manager.rs) serves as the central orchestrator. Before calling the system notification plugin, it verifies consent through `ConsentManager` and checks DND status via `SystemHandler`, short-circuiting the request if preferences prohibit the alert. The command layer in [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs) exposes Tauri commands like `show_notification` and `is_dnd_active` that the frontend UI invokes.

## How the Notification System Respects User Preferences

### 1. Consent and Permission Verification

Before any notification renders, the system calls `ConsentManager::has_consent()` and `ConsentManager::has_system_permission()` to verify the user has granted both application-level consent and system-level notification permissions. These flags are persisted to disk and checked on every notification request, ensuring revoked permissions are respected immediately without requiring an application restart.

### 2. Do-Not-Disturb Handling

The DND logic operates at two levels. First, `SystemHandler::is_dnd_active()` checks both the OS DND state and the `manual_dnd_mode` flag from `NotificationSettings`. Then, `should_respect_dnd()` evaluates the notification's priority—only non-critical notifications are suppressed when DND is active, ensuring urgent alerts still reach the user while respecting the user's desire for minimal interruptions.

### 3. Granular Notification Type Controls

Each notification type has a corresponding boolean flag in the `NotificationPreferences` struct. The manager checks `settings.notification_preferences.show_recording_started` (and similar flags) before constructing the notification object. If the specific type is disabled, the notification is silently discarded without reaching the system layer. The system also respects `notification_sound` toggles and `meeting_reminder_minutes` timing configurations, allowing users to disable sounds or adjust reminder lead times.

### 4. Persistence and Runtime Updates

All preference changes are written to [`notifications.json`](https://github.com/Zackriya-Solutions/meetily/blob/main/notifications.json) via `ConsentManager::save_settings()`. The system reloads these settings on each notification request, ensuring real-time respect for modifications made through the UI. This guarantees that disabling a notification type or enabling DND takes effect immediately.

## Implementation Examples

The following Rust examples demonstrate how the notification system respects user preferences in practice.

To conditionally show a recording notification based on user preferences:

```rust
async fn maybe_show_recording_started(manager: &NotificationManager) -> Result<()> {
    // Load current preferences from disk
    let settings = manager.consent_manager.load_settings().await?;
    
    // Check both specific preference and global consent
    if settings.notification_preferences.show_recording_started && settings.consent_given {
        let notification = Notification::new(
            "Recording Started",
            "Your meeting is now being captured.",
            NotificationType::Info,
        );
        manager.show_notification(notification).await?;
    }
    Ok(())
}

```

To programmatically enable manual Do-Not-Disturb mode:

```rust
async fn enable_manual_dnd(manager: &NotificationManager) -> Result<()> {
    // Sets manual_dnd_mode and respects the respect_do_not_disturb flag
    manager
        .consent_manager
        .set_dnd_mode(true)
        .await?;
    Ok(())
}

```

## Summary

- Meetily's notification system uses a three-tier architecture: **NotificationSettings** for configuration, **ConsentManager** for persistence, and **SystemHandler** for enforcement.
- All notifications require explicit user consent verified through `has_consent()` and system permissions checked via `has_system_permission()` before display.
- Do-Not-Disturb logic respects both OS-level states and manual user overrides, with priority-based filtering in `should_respect_dnd()` to ensure critical alerts bypass DND.
- Granular controls in `NotificationPreferences` allow users to disable specific notification types (like recording alerts or meeting reminders) while keeping others enabled.
- Preferences are persisted to [`notifications.json`](https://github.com/Zackriya-Solutions/meetily/blob/main/notifications.json) and reloaded on every request, ensuring real-time updates without application restarts.

## Frequently Asked Questions

### How does Meetily handle Do-Not-Disturb mode?

Meetily checks both the operating system's DND status and an application-specific `manual_dnd_mode` flag through the `SystemHandler::is_dnd_active()` method. The `should_respect_dnd()` function then filters non-critical notifications, ensuring only high-priority alerts bypass DND settings while routine notifications are suppressed.

### Where are notification preferences stored?

User preferences are serialized to a [`notifications.json`](https://github.com/Zackriya-Solutions/meetily/blob/main/notifications.json) file on disk through the `ConsentManager` struct in [`frontend/src-tauri/src/notifications/settings.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/notifications/settings.rs). This file stores consent flags, DND settings, and the `NotificationPreferences` struct containing individual notification type toggles.

### Can users disable specific notification types while keeping others enabled?

Yes. The `NotificationPreferences` struct contains boolean flags for specific notification types such as `show_recording_started`. The `NotificationManager` checks these individual flags before dispatching, allowing users to disable recording alerts while keeping meeting reminders active, with each preference persisted independently.

### How does the system verify user consent before showing notifications?

The system calls `ConsentManager::has_consent()` to verify application-level permission and `has_system_permission()` to confirm OS-level notification rights. Both checks must pass in [`manager.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/manager.rs) before the notification reaches the `SystemHandler` for display, ensuring no alert appears without explicit authorization.