ockam_app_lib 0.146.0

Ockam's desktop application library
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

//! Similarly to [`ApplicationState`] the notification structure has been implemented in rust
//! and C. The idea is to work using rust structure from within the library and convert into C
//! when needed.

#[repr(C)]
#[allow(dead_code)]
pub enum Kind {
    Information = 0,
    Warning = 1,
    Error = 2,
}

pub mod rust {
    pub use crate::api::notification::Kind;

    pub struct Notification {
        pub(crate) kind: Kind,
        pub(crate) title: String,
        pub(crate) message: String,
    }

    /// Sends a notification to the application.
    #[derive(Clone)]
    pub struct NotificationCallback(
        unsafe extern "C" fn(notification: super::c::Notification) -> (),
    );
    impl NotificationCallback {
        pub fn new(
            callback: unsafe extern "C" fn(notification: super::c::Notification) -> (),
        ) -> Self {
            Self(callback)
        }
        pub fn call(&self, notification: Notification) {
            unsafe {
                (self.0)(super::convert_to_c(notification));
            }
        }
    }
}

pub(super) mod c {
    pub use crate::api::notification::Kind;
    use std::ffi::c_char;

    #[repr(C)]
    pub struct Notification {
        pub(super) kind: Kind,
        pub(super) title: *const c_char,
        pub(super) message: *const c_char,
    }
}

use crate::api::to_c_string;

/// Convert the instance into c representation.
/// Manual call to [free] must be performed to reclaim memory.
fn convert_to_c(notification: rust::Notification) -> c::Notification {
    c::Notification {
        kind: notification.kind,
        title: to_c_string(notification.title),
        message: to_c_string(notification.message),
    }
}