feat: implement desktop notifications with comprehensive filtering

Implemented Phase 10 (Desktop Notifications) with three stages: notify-rust integration, smart filtering, and production polish. Stage 1 - Base Implementation: - Add NotificationManager module (src/notifications.rs, 350+ lines) - Integrate notify-rust 4.11 with feature flag "notifications" - Implement NotificationsConfig in config.toml (enabled, only_mentions, show_preview) - Add notification_manager field to TdClient - Create configure_notifications() method for config integration - Hook into handle_new_message_update() to send notifications - Send notifications for messages outside current chat - Format notification body with sender name and message preview Stage 2 - Smart Filtering: - Sync muted chats from Telegram (sync_muted_chats method) - Filter muted chats from notifications automatically - Add MessageInfo::has_mention() to detect @username mentions - Implement only_mentions filter (notify only when mentioned) - Beautify media labels with emojis (📷 📹 🎤 🎨 📎 etc.) - Support 10+ media types in notification preview Stage 3 - Production Polish: - Add graceful error handling (no panics on notification failure) - Implement comprehensive logging (tracing::debug!/warn!) - Add timeout_ms configuration (0 = system default) - Add urgency configuration (low/normal/critical, Linux only) - Platform-specific #[cfg] for urgency support - Log all notification skip reasons at debug level Hotkey Change: - Move profile view from 'i' to Ctrl+i to avoid conflicts Technical Details: - Cross-platform support (macOS, Linux, Windows) - Feature flag for optional notifications support - Graceful fallback when notifications unavailable - LRU-friendly muted chats sync - Test coverage for all core notification logic - All 75 tests passing Files Changed: - NEW: src/notifications.rs - Complete NotificationManager - NEW: config.example.toml - Example configuration with notifications - Modified: Cargo.toml - Add notify-rust 4.11 dependency - Modified: src/config/mod.rs - Add NotificationsConfig struct - Modified: src/tdlib/types.rs - Add has_mention() method - Modified: src/tdlib/client.rs - Add notification integration - Modified: src/tdlib/update_handlers.rs - Hook notifications - Modified: src/config/keybindings.rs - Change profile to Ctrl+i - Modified: tests/* - Add notification config to tests Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
2026-02-05 01:27:44 +03:00
parent 1cc61ea026
commit bea0bcbed0
20 changed files with 1249 additions and 26 deletions
--- a/src/notifications.rs
+++ b/src/notifications.rs
@@ -0,0 +1,352 @@
+//! Desktop notifications module
+//!
+//! Provides cross-platform desktop notifications for new messages.
+
+use crate::tdlib::{ChatInfo, MessageInfo};
+use crate::types::ChatId;
+use std::collections::HashSet;
+
+#[cfg(feature = "notifications")]
+use notify_rust::{Notification, Timeout};
+
+/// Manages desktop notifications
+pub struct NotificationManager {
+    /// Whether notifications are enabled
+    enabled: bool,
+    /// Set of muted chat IDs (don't notify for these chats)
+    muted_chats: HashSet<ChatId>,
+    /// Only notify for mentions (@username)
+    only_mentions: bool,
+    /// Show message preview text
+    show_preview: bool,
+    /// Notification timeout in milliseconds (0 = system default)
+    timeout_ms: i32,
+    /// Notification urgency level
+    urgency: String,
+}
+
+impl NotificationManager {
+    /// Creates a new notification manager with default settings
+    pub fn new() -> Self {
+        Self {
+            enabled: true,
+            muted_chats: HashSet::new(),
+            only_mentions: false,
+            show_preview: true,
+            timeout_ms: 5000,
+            urgency: "normal".to_string(),
+        }
+    }
+
+    /// Creates a notification manager with custom settings
+    pub fn with_config(
+        enabled: bool,
+        only_mentions: bool,
+        show_preview: bool,
+    ) -> Self {
+        Self {
+            enabled,
+            muted_chats: HashSet::new(),
+            only_mentions,
+            show_preview,
+            timeout_ms: 5000,
+            urgency: "normal".to_string(),
+        }
+    }
+
+    /// Sets whether notifications are enabled
+    pub fn set_enabled(&mut self, enabled: bool) {
+        self.enabled = enabled;
+    }
+
+    /// Sets whether to only notify for mentions
+    pub fn set_only_mentions(&mut self, only_mentions: bool) {
+        self.only_mentions = only_mentions;
+    }
+
+    /// Sets notification timeout in milliseconds
+    pub fn set_timeout(&mut self, timeout_ms: i32) {
+        self.timeout_ms = timeout_ms;
+    }
+
+    /// Sets notification urgency level
+    pub fn set_urgency(&mut self, urgency: String) {
+        self.urgency = urgency;
+    }
+
+    /// Adds a chat to the muted list
+    pub fn mute_chat(&mut self, chat_id: ChatId) {
+        self.muted_chats.insert(chat_id);
+    }
+
+    /// Removes a chat from the muted list
+    pub fn unmute_chat(&mut self, chat_id: ChatId) {
+        self.muted_chats.remove(&chat_id);
+    }
+
+    /// Checks if a chat should be muted based on Telegram mute status
+    pub fn sync_muted_chats(&mut self, chats: &[ChatInfo]) {
+        self.muted_chats.clear();
+        for chat in chats {
+            if chat.is_muted {
+                self.muted_chats.insert(chat.id);
+            }
+        }
+    }
+
+    /// Sends a notification for a new message
+    ///
+    /// # Arguments
+    ///
+    /// * `chat` - Chat information
+    /// * `message` - Message information
+    /// * `sender_name` - Name of the message sender
+    ///
+    /// Returns `Ok(())` if notification was sent or skipped, `Err` if failed
+    pub fn notify_new_message(
+        &self,
+        chat: &ChatInfo,
+        message: &MessageInfo,
+        sender_name: &str,
+    ) -> Result<(), String> {
+        // Check if notifications are enabled
+        if !self.enabled {
+            tracing::debug!("Notifications disabled, skipping");
+            return Ok(());
+        }
+
+        // Don't notify for outgoing messages
+        if message.is_outgoing() {
+            tracing::debug!("Outgoing message, skipping notification");
+            return Ok(());
+        }
+
+        // Check if chat is muted
+        if self.muted_chats.contains(&chat.id) {
+            tracing::debug!("Chat {} is muted, skipping notification", chat.title);
+            return Ok(());
+        }
+
+        // Check if we only notify for mentions
+        if self.only_mentions && !message.has_mention() {
+            tracing::debug!("only_mentions=true but no mention found, skipping");
+            return Ok(());
+        }
+
+        // Format the notification
+        let title = &chat.title;
+        let body = self.format_message_body(sender_name, message);
+
+        tracing::debug!("Sending notification for chat: {}", title);
+
+        // Send the notification
+        self.send_notification(title, &body)?;
+
+        Ok(())
+    }
+
+    /// Formats the message body for notification
+    fn format_message_body(&self, sender_name: &str, message: &MessageInfo) -> String {
+        // For groups, include sender name. For private chats, sender name is in title
+        let prefix = if !sender_name.is_empty() && sender_name != message.sender_name() {
+            format!("{}: ", sender_name)
+        } else {
+            String::new()
+        };
+
+        let content = if self.show_preview {
+            let text = message.text();
+
+            // Check if message is empty (media, sticker, etc.)
+            if text.is_empty() {
+                "Новое сообщение".to_string()
+            } else {
+                // Beautify media labels with emojis
+                let beautified = Self::beautify_media_labels(text);
+
+                // Limit preview length
+                if beautified.len() > 150 {
+                    format!("{}...", &beautified[..147])
+                } else {
+                    beautified
+                }
+            }
+        } else {
+            "Новое сообщение".to_string()
+        };
+
+        format!("{}{}", prefix, content)
+    }
+
+    /// Replaces text media labels with emoji-enhanced versions
+    fn beautify_media_labels(text: &str) -> String {
+        text.replace("[Фото]", "📷 Фото")
+            .replace("[Видео]", "🎥 Видео")
+            .replace("[GIF]", "🎞️ GIF")
+            .replace("[Голосовое]", "🎤 Голосовое")
+            .replace("[Стикер:", "🎨 Стикер:")
+            .replace("[Файл:", "📎 Файл:")
+            .replace("[Аудио:", "🎵 Аудио:")
+            .replace("[Аудио]", "🎵 Аудио")
+            .replace("[Видеосообщение]", "📹 Видеосообщение")
+            .replace("[Локация]", "📍 Локация")
+            .replace("[Контакт:", "👤 Контакт:")
+            .replace("[Опрос:", "📊 Опрос:")
+            .replace("[Место встречи:", "📍 Место встречи:")
+            .replace("[Неподдерживаемый тип сообщения]", "📨 Сообщение")
+    }
+
+    /// Sends a desktop notification
+    ///
+    /// Returns `Ok(())` if notification was sent successfully or skipped.
+    /// Logs errors but doesn't fail - notifications are not critical for app functionality.
+    #[cfg(feature = "notifications")]
+    fn send_notification(&self, title: &str, body: &str) -> Result<(), String> {
+        // Don't send if notifications are disabled
+        if !self.enabled {
+            return Ok(());
+        }
+
+        // Determine timeout
+        let timeout = if self.timeout_ms <= 0 {
+            Timeout::Default
+        } else {
+            Timeout::Milliseconds(self.timeout_ms as u32)
+        };
+
+        // Build notification
+        let mut notification = Notification::new();
+        notification
+            .summary(title)
+            .body(body)
+            .icon("telegram")
+            .appname("tele-tui")
+            .timeout(timeout);
+
+        // Set urgency if supported
+        #[cfg(all(unix, not(target_os = "macos")))]
+        {
+            use notify_rust::Urgency;
+            let urgency_level = match self.urgency.to_lowercase().as_str() {
+                "low" => Urgency::Low,
+                "critical" => Urgency::Critical,
+                _ => Urgency::Normal,
+            };
+            notification.urgency(urgency_level);
+        }
+
+        match notification.show() {
+            Ok(_) => Ok(()),
+            Err(e) => {
+                // Log error but don't fail - notifications are optional
+                tracing::warn!("Failed to send desktop notification: {}", e);
+                // Return Ok to not break the app flow
+                Ok(())
+            }
+        }
+    }
+
+    /// Fallback when notifications feature is disabled
+    #[cfg(not(feature = "notifications"))]
+    fn send_notification(&self, _title: &str, _body: &str) -> Result<(), String> {
+        Ok(())
+    }
+}
+
+impl Default for NotificationManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_notification_manager_creation() {
+        let manager = NotificationManager::new();
+        assert!(manager.enabled);
+        assert!(!manager.only_mentions);
+        assert!(manager.show_preview);
+    }
+
+    #[test]
+    fn test_mute_unmute() {
+        let mut manager = NotificationManager::new();
+        let chat_id = ChatId::new(123);
+
+        manager.mute_chat(chat_id);
+        assert!(manager.muted_chats.contains(&chat_id));
+
+        manager.unmute_chat(chat_id);
+        assert!(!manager.muted_chats.contains(&chat_id));
+    }
+
+    #[test]
+    fn test_disabled_notifications() {
+        let mut manager = NotificationManager::new();
+        manager.set_enabled(false);
+
+        // Should return Ok without sending notification
+        let result = manager.send_notification("Test", "Body");
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_only_mentions_setting() {
+        let mut manager = NotificationManager::new();
+        assert!(!manager.only_mentions);
+
+        manager.set_only_mentions(true);
+        assert!(manager.only_mentions);
+
+        manager.set_only_mentions(false);
+        assert!(!manager.only_mentions);
+    }
+
+    #[test]
+    fn test_beautify_media_labels() {
+        // Test photo
+        assert_eq!(
+            NotificationManager::beautify_media_labels("[Фото]"),
+            "📷 Фото"
+        );
+
+        // Test video
+        assert_eq!(
+            NotificationManager::beautify_media_labels("[Видео]"),
+            "🎥 Видео"
+        );
+
+        // Test sticker with emoji
+        assert_eq!(
+            NotificationManager::beautify_media_labels("[Стикер: 😊]"),
+            "🎨 Стикер: 😊]"
+        );
+
+        // Test audio with title
+        assert_eq!(
+            NotificationManager::beautify_media_labels("[Аудио: Artist - Song]"),
+            "🎵 Аудио: Artist - Song]"
+        );
+
+        // Test file
+        assert_eq!(
+            NotificationManager::beautify_media_labels("[Файл: document.pdf]"),
+            "📎 Файл: document.pdf]"
+        );
+
+        // Test regular text (no changes)
+        assert_eq!(
+            NotificationManager::beautify_media_labels("Hello, world!"),
+            "Hello, world!"
+        );
+
+        // Test mixed content
+        assert_eq!(
+            NotificationManager::beautify_media_labels("[Фото] Check this out!"),
+            "📷 Фото Check this out!"
+        );
+    }
+}