Tauri 2.0 Notifications Desktop Push Notifications

// src-tauri/tauri.conf.json
// Enable notification permissions
{
  "tauri": {
    "allowlist": {
      "notification": {
        "all": true
      }
    },
    "bundle": {
      "identifier": "com.example.myapp"
    }
  }
}

// src-tauri/Cargo.toml
// Notification dependencies included by default
[dependencies]
tauri = { version = "2.0", features = ["notification"] }

// Frontend: Check and request permissions
import {
  isPermissionGranted,
  requestPermission,
  sendNotification,
} from "@tauri-apps/api/notification";

// Check if permission already granted
let permissionGranted = await isPermissionGranted();

if (!permissionGranted) {
  // Request permission from user
  const permission = await requestPermission();
  permissionGranted = permission === "granted";
}

if (permissionGranted) {
  // Permission granted, can send notifications
  await sendNotification({
    title: "Welcome!",
    body: "Notifications are now enabled",
  });
} else {
  console.log("Notification permission denied");
}

// Rust: Send notifications from backend
use tauri::api::notification::Notification;

#[tauri::command]
fn send_notification_from_rust(
    app: tauri::AppHandle,
    title: String,
    body: String,
) -> Result<(), String> {
    Notification::new(&app.config().tauri.bundle.identifier)
        .title(title)
        .body(body)
        .show()
        .map_err(|e| e.to_string())?;
    
    Ok(())
}

fn main() {
    tauri::Builder::default()
        .invoke_handler(tauri::generate_handler![
            send_notification_from_rust
        ])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

// Frontend: Send notifications from JavaScript
import { sendNotification } from "@tauri-apps/api/notification";

// Simple notification
await sendNotification({
  title: "Task Complete",
  body: "Your export has finished successfully",
});

// Notification with icon
await sendNotification({
  title: "New Message",
  body: "John: Hey, are you available?",
  icon: "icons/message.png",
});

// Utility function for different notification types
class NotificationService {
  static async info(title: string, body: string) {
    await sendNotification({
      title: `ℹ️ ${title}`,
      body,
    });
  }

  static async success(title: string, body: string) {
    await sendNotification({
      title: `✅ ${title}`,
      body,
    });
  }

  static async warning(title: string, body: string) {
    await sendNotification({
      title: `⚠️ ${title}`,
      body,
    });
  }

  static async error(title: string, body: string) {
    await sendNotification({
      title: `❌ ${title}`,
      body,
    });
  }
}

// Usage
await NotificationService.success(
  "Upload Complete",
  "Your file has been uploaded successfully"
);

await NotificationService.warning(
  "Low Storage",
  "You have less than 10% storage remaining"
);

await NotificationService.error(
  "Connection Failed",
  "Unable to connect to the server"
);

// Rust: Advanced notification builder
use tauri::api::notification::Notification;

struct NotificationBuilder {
    app_id: String,
}

impl NotificationBuilder {
    fn new(app: &tauri::AppHandle) -> Self {
        NotificationBuilder {
            app_id: app.config().tauri.bundle.identifier.clone(),
        }
    }

    fn send(
        &self,
        title: &str,
        body: &str,
        icon: Option<&str>,
    ) -> Result<(), String> {
        let mut notification = Notification::new(&self.app_id)
            .title(title)
            .body(body);

        if let Some(icon_path) = icon {
            notification = notification.icon(icon_path);
        }

        notification.show().map_err(|e| e.to_string())
    }

    fn info(&self, title: &str, body: &str) -> Result<(), String> {
        self.send(&format!("ℹ️ {}", title), body, None)
    }

    fn success(&self, title: &str, body: &str) -> Result<(), String> {
        self.send(&format!("✅ {}", title), body, None)
    }

    fn warning(&self, title: &str, body: &str) -> Result<(), String> {
        self.send(&format!("⚠️ {}", title), body, None)
    }

    fn error(&self, title: &str, body: &str) -> Result<(), String> {
        self.send(&format!("❌ {}", title), body, None)
    }
}

#[tauri::command]
fn notify_task_complete(
    app: tauri::AppHandle,
    task_name: String,
) -> Result<(), String> {
    let notifier = NotificationBuilder::new(&app);
    notifier.success(
        "Task Complete",
        &format!("{} has finished successfully", task_name),
    )
}

#[tauri::command]
fn notify_error(
    app: tauri::AppHandle,
    error_msg: String,
) -> Result<(), String> {
    let notifier = NotificationBuilder::new(&app);
    notifier.error("Error Occurred", &error_msg)
}

// Rust: Handle notification clicks with events
use tauri::Manager;
use serde::{Deserialize, Serialize};

#[derive(Clone, Serialize, Deserialize)]
struct NotificationData {
    id: String,
    action: String,
    data: serde_json::Value,
}

#[tauri::command]
fn send_clickable_notification(
    app: tauri::AppHandle,
    title: String,
    body: String,
    notification_id: String,
) -> Result<(), String> {
    use tauri::api::notification::Notification;
    
    // Send notification
    Notification::new(&app.config().tauri.bundle.identifier)
        .title(&title)
        .body(&body)
        .show()
        .map_err(|e| e.to_string())?;
    
    // Store notification data for click handling
    // In production, use proper state management
    app.emit_all("notification-sent", NotificationData {
        id: notification_id,
        action: "show_window".to_string(),
        data: serde_json::json!({ "title": title }),
    })
    .map_err(|e| e.to_string())?;
    
    Ok(())
}

// Frontend: Listen for notification interactions
import { listen } from "@tauri-apps/api/event";
import { sendNotification } from "@tauri-apps/api/notification";
import { getCurrent } from "@tauri-apps/api/window";

// Send notification with action data
async function sendActionableNotification(
  title: string,
  body: string,
  action: string,
  data: any
) {
  // Store action data in localStorage or state
  const notificationId = `notif-${Date.now()}`;
  localStorage.setItem(
    notificationId,
    JSON.stringify({ action, data })
  );

  // Send notification
  await sendNotification({ title, body });

  // On click, notification will activate window
  // Handle action in window focus event
}

// Handle notification clicks by detecting window focus
const appWindow = getCurrent();

await appWindow.listen("tauri://focus", () => {
  console.log("Window focused - possibly from notification click");
  
  // Check for pending notification actions
  const pendingActions = getPendingNotificationActions();
  pendingActions.forEach((action) => {
    handleNotificationAction(action);
  });
});

function getPendingNotificationActions() {
  // Retrieve stored notification actions
  const actions = [];
  for (let i = 0; i < localStorage.length; i++) {
    const key = localStorage.key(i);
    if (key?.startsWith("notif-")) {
      const data = JSON.parse(localStorage.getItem(key)!);
      actions.push({ id: key, ...data });
      localStorage.removeItem(key);
    }
  }
  return actions;
}

function handleNotificationAction(action: any) {
  switch (action.action) {
    case "open_chat":
      openChat(action.data.userId);
      break;
    case "show_task":
      showTask(action.data.taskId);
      break;
    case "open_file":
      openFile(action.data.filePath);
      break;
    default:
      console.log("Unknown action:", action);
  }
}

// Example: Message notification
async function notifyNewMessage(sender: string, message: string, userId: string) {
  await sendActionableNotification(
    `New message from ${sender}`,
    message,
    "open_chat",
    { userId }
  );
}

// Example: Task reminder
async function notifyTaskDue(taskName: string, taskId: string) {
  await sendActionableNotification(
    "Task Due",
    `${taskName} is due now`,
    "show_task",
    { taskId }
  );
}

// Rust: Notification queue with rate limiting
use std::collections::VecDeque;
use std::sync::Mutex;
use std::time::{Duration, Instant};
use tauri::api::notification::Notification;
use tauri::AppHandle;

struct NotificationQueue {
    queue: Mutex<VecDeque<QueuedNotification>>,
    last_sent: Mutex<Option<Instant>>,
    min_interval: Duration,
}

struct QueuedNotification {
    title: String,
    body: String,
    icon: Option<String>,
    priority: NotificationPriority,
}

#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
enum NotificationPriority {
    Low = 0,
    Normal = 1,
    High = 2,
    Urgent = 3,
}

impl NotificationQueue {
    fn new(min_interval_secs: u64) -> Self {
        NotificationQueue {
            queue: Mutex::new(VecDeque::new()),
            last_sent: Mutex::new(None),
            min_interval: Duration::from_secs(min_interval_secs),
        }
    }

    fn add(
        &self,
        title: String,
        body: String,
        icon: Option<String>,
        priority: NotificationPriority,
    ) {
        let mut queue = self.queue.lock().unwrap();
        
        let notification = QueuedNotification {
            title,
            body,
            icon,
            priority,
        };
        
        // Insert based on priority
        let insert_pos = queue
            .iter()
            .position(|n| n.priority < priority)
            .unwrap_or(queue.len());
        
        queue.insert(insert_pos, notification);
    }

    fn process(&self, app: &AppHandle) -> Result<(), String> {
        let mut last_sent = self.last_sent.lock().unwrap();
        let mut queue = self.queue.lock().unwrap();
        
        // Check rate limit
        if let Some(last) = *last_sent {
            if last.elapsed() < self.min_interval {
                return Ok(()); // Too soon, skip this cycle
            }
        }
        
        // Send next notification
        if let Some(notification) = queue.pop_front() {
            let mut notif = Notification::new(
                &app.config().tauri.bundle.identifier
            )
            .title(&notification.title)
            .body(&notification.body);
            
            if let Some(icon) = notification.icon {
                notif = notif.icon(icon);
            }
            
            notif.show().map_err(|e| e.to_string())?;
            *last_sent = Some(Instant::now());
        }
        
        Ok(())
    }

    fn clear(&self) {
        let mut queue = self.queue.lock().unwrap();
        queue.clear();
    }

    fn count(&self) -> usize {
        let queue = self.queue.lock().unwrap();
        queue.len()
    }
}

#[tauri::command]
fn queue_notification(
    app: tauri::AppHandle,
    queue: tauri::State<NotificationQueue>,
    title: String,
    body: String,
    priority: String,
) -> Result<(), String> {
    let priority = match priority.as_str() {
        "low" => NotificationPriority::Low,
        "high" => NotificationPriority::High,
        "urgent" => NotificationPriority::Urgent,
        _ => NotificationPriority::Normal,
    };
    
    queue.add(title, body, None, priority);
    queue.process(&app)?;
    
    Ok(())
}

#[tauri::command]
fn get_pending_count(
    queue: tauri::State<NotificationQueue>,
) -> usize {
    queue.count()
}

// Initialize with background task
fn main() {
    let notification_queue = NotificationQueue::new(3); // 3 seconds minimum
    
    tauri::Builder::default()
        .manage(notification_queue)
        .setup(|app| {
            let app_handle = app.handle();
            let queue: tauri::State<NotificationQueue> = app_handle.state();
            
            // Process queue periodically
            std::thread::spawn(move || {
                loop {
                    std::thread::sleep(Duration::from_secs(1));
                    let _ = queue.process(&app_handle);
                }
            });
            
            Ok(())
        })
        .invoke_handler(tauri::generate_handler![
            queue_notification,
            get_pending_count,
        ])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

// Complete messaging notification system
use tauri::{AppHandle, Manager};
use std::sync::Mutex;
use std::collections::HashMap;

struct MessagingNotifications {
    unread_counts: Mutex<HashMap<String, u32>>,
    notification_queue: NotificationQueue,
}

impl MessagingNotifications {
    fn new() -> Self {
        MessagingNotifications {
            unread_counts: Mutex::new(HashMap::new()),
            notification_queue: NotificationQueue::new(2),
        }
    }
}

#[tauri::command]
fn notify_new_message(
    app: AppHandle,
    messaging: tauri::State<MessagingNotifications>,
    sender_id: String,
    sender_name: String,
    message: String,
    preview_enabled: bool,
) -> Result<(), String> {
    use tauri::api::notification::Notification;
    
    // Update unread count
    {
        let mut counts = messaging.unread_counts.lock().unwrap();
        let count = counts.entry(sender_id.clone()).or_insert(0);
        *count += 1;
    }
    
    // Prepare notification
    let body = if preview_enabled {
        if message.len() > 100 {
            format!("{}...", &message[..97])
        } else {
            message.clone()
        }
    } else {
        "New message received".to_string()
    };
    
    let title = format!("Message from {}", sender_name);
    
    // Send notification
    messaging.notification_queue.add(
        title,
        body,
        Some("icons/message.png".to_string()),
        NotificationPriority::Normal,
    );
    
    messaging.notification_queue.process(&app)?;
    
    // Update tray icon with unread count
    let total_unread: u32 = {
        let counts = messaging.unread_counts.lock().unwrap();
        counts.values().sum()
    };
    
    if total_unread > 0 {
        app.tray_handle()
            .set_tooltip(&format!("{} unread messages", total_unread))
            .ok();
    }
    
    Ok(())
}

#[tauri::command]
fn mark_messages_read(
    app: AppHandle,
    messaging: tauri::State<MessagingNotifications>,
    sender_id: String,
) -> Result<(), String> {
    // Clear unread count
    {
        let mut counts = messaging.unread_counts.lock().unwrap();
        counts.remove(&sender_id);
    }
    
    // Update tray
    let total_unread: u32 = {
        let counts = messaging.unread_counts.lock().unwrap();
        counts.values().sum()
    };
    
    if total_unread == 0 {
        app.tray_handle()
            .set_tooltip("No unread messages")
            .ok();
    } else {
        app.tray_handle()
            .set_tooltip(&format!("{} unread messages", total_unread))
            .ok();
    }
    
    Ok(())
}

#[tauri::command]
fn get_unread_count(
    messaging: tauri::State<MessagingNotifications>,
) -> u32 {
    let counts = messaging.unread_counts.lock().unwrap();
    counts.values().sum()
}

// Frontend integration
import { invoke } from "@tauri-apps/api/core";
import { listen } from "@tauri-apps/api/event";

// Send message notification
async function onNewMessage(
  senderId: string,
  senderName: string,
  message: string
) {
  const previewEnabled = getNotificationPreferencesFromSettings();
  
  await invoke("notify_new_message", {
    sender_id: senderId,
    sender_name: senderName,
    message,
    preview_enabled: previewEnabled,
  });
}

// Mark as read when chat opened
async function openChat(senderId: string) {
  await invoke("mark_messages_read", { sender_id: senderId });
  // Open chat UI
}

// Get unread count for badge
async function updateUnreadBadge() {
  const count = await invoke("get_unread_count");
  updateUIBadge(count);
}