wayclip-core 0.1.4

Core module for the Wayclip ecosystem: models, settings, and methods for App
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

use crate::{
    models::{daemon::notifications::sound::NotificationSound, error::WayclipError},
    settings::notifications::NotificationSettings,
    t,
};
use strum_macros::FromRepr;

/// The sound module, will play sounds in addition to notifications being sent
pub mod sound;

/// The manager for sending out system-wide notifications
pub struct NotificationManager;

/// A single notification event
#[derive(Debug, Clone)]
#[allow(missing_docs)]
pub enum NotificationEvent {
    SaveSuccess,
    SaveError,
    DaemonStart,
    DaemonStop,
    /// Used soley for doctor
    Test,
}

/// Urgency of the notification (may not work on some compositors and distros)
#[derive(Debug, Clone, Copy, FromRepr)]
#[allow(missing_docs)]
pub enum Urgency {
    Normal = 1,
    Critical = 2,
}

impl From<Urgency> for notify_rust::Urgency {
    fn from(value: Urgency) -> Self {
        match value {
            Urgency::Normal => Self::Normal,
            Urgency::Critical => Self::Critical,
        }
    }
}

impl NotificationEvent {
    /// Retrive a translated summary of the notification based on the event
    pub fn get_summary(&self) -> String {
        match self {
            Self::DaemonStop => t!("notification.daemon_stop.summary"),
            Self::DaemonStart => t!("notification.daemon_start.summary"),
            Self::SaveError => t!("notification.save_error.summary"),
            Self::SaveSuccess => t!("notification.save_success.summary"),
            Self::Test => t!("notification.test.summary"),
        }
    }

    /// Retrive the translated body of the notification based on the event
    pub fn get_body(&self, content: String) -> String {
        match self {
            Self::SaveSuccess => t!("notification.save_success.body", content = content),
            Self::SaveError => t!("notification.save_error.body", content = content),
            Self::DaemonStart => t!("notification.daemon_start.body"),
            Self::DaemonStop => t!("notification.daemon_stop.body"),
            Self::Test => t!("notification.test.body", content = content),
        }
    }

    /// Get the wayclip icon, which will only work if icon is stored in /usr/share/icons/hicolor/
    pub fn get_icon(&self) -> &'static str {
        "wayclip"
    }

    /// The timeout, in milliseconds, for which the notification will stay on screen for
    pub fn get_timeout_ms(&self) -> i32 {
        match self {
            Self::DaemonStop | Self::DaemonStart => 1500,
            Self::SaveError => 4000,
            Self::SaveSuccess => 1000,
            Self::Test => 500,
        }
    }

    /// Maps the event to urgency
    pub fn get_urgency(&self) -> Urgency {
        match self {
            Self::SaveError => Urgency::Critical,
            _ => Urgency::Normal,
        }
    }
}

impl NotificationManager {
    /// Send outa test notification
    pub async fn test_notification(
        event: NotificationEvent,
        content: String,
    ) -> Result<(), WayclipError> {
        tokio::task::spawn_blocking(move || Self::send_notification(event, content)).await??;
        Ok(())
    }

    /// Send event to be processed and sent
    pub fn send_event(
        event: NotificationEvent,
        settings: &NotificationSettings,
        content: String,
    ) -> Result<(), WayclipError> {
        log::info!("Notification Event Triggered: {:?}", event);
        NotificationSound::process_audio_event(&event, settings);
        NotificationManager::process_message_event(&event, settings, content);

        Ok(())
    }

    fn process_message_event(
        event: &NotificationEvent,
        settings: &NotificationSettings,
        content: String,
    ) {
        let send_msg = match event {
            NotificationEvent::SaveError => settings.message.on_save_error,
            NotificationEvent::SaveSuccess => settings.message.on_save_success,
            NotificationEvent::DaemonStart => settings.message.on_daemon_start,
            NotificationEvent::DaemonStop => settings.message.on_daemon_stop,
            _ => false,
        };

        if send_msg {
            let event_clone = event.clone();
            let content_clone = content.clone();
            tokio::task::spawn_blocking(move || {
                if let Err(e) = Self::send_notification(event_clone, content_clone) {
                    log::error!("Notification Error: {}", e);
                }
            });
        }
    }

    // dont directly expose as pub, has to be done as blocking...
    fn send_notification(event: NotificationEvent, content: String) -> Result<(), WayclipError> {
        let summary = event.get_summary();
        let body = event.get_body(content);
        let urgency = event.get_urgency();
        let icon = event.get_icon();
        let timeout_ms = event.get_timeout_ms();

        notify_rust::Notification::new()
            .appname("Wayclip")
            .summary(&summary)
            .urgency(urgency.into())
            .body(&body)
            .icon(icon)
            .timeout(notify_rust::Timeout::Milliseconds(timeout_ms as u32))
            .show()
            .map_err(|e| WayclipError::Validation(e.to_string().into()))?;

        Ok(())
    }
}