hinoirisetr 1.5.5

A daemon to dim the screen at night
Documentation 
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

use std::ffi::{CString, NulError, c_char, c_void};
use std::marker::PhantomData;
use std::sync::Arc;

use libloading::Library;
use libloading::os::unix::Symbol as UnixSymbol;

type NotifyInit = unsafe extern "C" fn(*const c_char) -> bool;
type NotifyUninit = unsafe extern "C" fn();
type NotifyNotificationNew =
    unsafe extern "C" fn(*const c_char, *const c_char, *const c_char) -> *mut c_void;
type NotifyNotificationShow = unsafe extern "C" fn(*mut c_void, *mut *mut c_void) -> i32;
type NotifyNotificationSetTimeout = unsafe extern "C" fn(*mut c_void, i32);

/// Represents an uninitialized notification system
struct NotificationSystem {
    _lib: Library,
    notify_init: UnixSymbol<NotifyInit>,
    notify_uninit: UnixSymbol<NotifyUninit>,
    notify_notification_new: UnixSymbol<NotifyNotificationNew>,
    notify_notification_show: UnixSymbol<NotifyNotificationShow>,
    notify_notification_set_timeout: UnixSymbol<NotifyNotificationSetTimeout>,
}

/// Represents an initialized notification system with working notifications
#[derive(Clone)]
pub struct InitializedNotificationSystem {
    inner: Arc<NotificationSystem>,
    _marker: PhantomData<()>,
}

impl NotificationSystem {
    pub fn new() -> Result<Self, libloading::Error> {
        unsafe {
            let lib = Library::new("libnotify.so.4")?;

            Ok(Self {
                notify_init: lib.get::<NotifyInit>(b"notify_init\0")?.into_raw(),
                notify_uninit: lib.get::<NotifyUninit>(b"notify_uninit\0")?.into_raw(),
                notify_notification_new: lib
                    .get::<NotifyNotificationNew>(b"notify_notification_new\0")?
                    .into_raw(),
                notify_notification_show: lib
                    .get::<NotifyNotificationShow>(b"notify_notification_show\0")?
                    .into_raw(),
                notify_notification_set_timeout: lib
                    .get::<NotifyNotificationSetTimeout>(b"notify_notification_set_timeout\0")?
                    .into_raw(),
                _lib: lib,
            })
        }
    }

    /// Initialize the notification system. Consumes the uninitialized version
    /// and returns an initialized version.
    pub fn init(self, app_name: &str) -> Result<InitializedNotificationSystem, NulError> {
        let app_name = CString::new(app_name)?;
        unsafe {
            if (self.notify_init)(app_name.as_ptr()) {
                Ok(InitializedNotificationSystem {
                    inner: Arc::new(self), // Wrap self in Arc
                    _marker: PhantomData,
                })
            } else {
                panic!("notify_init failed") // Convert to proper error type
            }
        }
    }
}

impl Drop for NotificationSystem {
    fn drop(&mut self) {
        // Safety: Last reference to the library is being dropped
        unsafe { (self.notify_uninit)() };
    }
}

impl InitializedNotificationSystem {
    pub fn new(app_name: &str) -> Result<Self, Box<dyn std::error::Error>> {
        let lib = NotificationSystem::new()?;
        Ok(lib.init(app_name)?)
    }

    pub fn show_notification(
        &self,
        summary: &str,
        body: &str,
        icon: &str,
        timeout_ms: i32,
    ) -> Result<(), NotificationError> {
        let summary = CString::new(summary)?;
        let body = CString::new(body)?;
        let icon = CString::new(icon)?;

        unsafe {
            let notification = (self.inner.notify_notification_new)(
                summary.as_ptr(),
                body.as_ptr(),
                icon.as_ptr(),
            );

            (self.inner.notify_notification_set_timeout)(notification, timeout_ms);

            // Handle potential errors from the C library
            let mut error_ptr: *mut c_void = std::ptr::null_mut();
            let success = (self.inner.notify_notification_show)(notification, &raw mut error_ptr);

            if success != 0 {
                Ok(())
            } else {
                Err(NotificationError::NativeError(error_ptr))
            }
        }
    }
}

#[derive(Debug)]
pub enum NotificationError {
    NullByteInString(NulError),
    NativeError(*mut c_void),
}

impl From<NulError> for NotificationError {
    fn from(e: NulError) -> Self {
        Self::NullByteInString(e)
    }
}