whatawhat-lib 0.1.0

A collection of utils for windows and linux for collecting activity data
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
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

#[cfg(feature = "gnome")]
pub mod gnome;
#[cfg(feature = "kde")]
pub mod kde;
#[cfg(feature = "wayland")]
pub mod wayland_idle;
#[cfg(feature = "wayland")]
pub mod wayland_wlr;
#[cfg(feature = "win")]
pub mod win;
#[cfg(feature = "wayland")]
pub mod wl_connection;
#[cfg(feature = "x11")]
pub mod x11;

pub mod idle;
pub mod utils;

#[cfg(feature = "win")]
extern crate windows;

// #[cfg(feature = "x11")]
// extern crate xcb;

use std::{sync::Arc, time::Duration};

use anyhow::Result;
use async_trait::async_trait;
use tracing::info;

#[derive(Debug, Clone)]
pub struct ActiveWindowData {
    /// Name of the window. For example 'bash in hello' or 'Document 1' or 'Vibing in YouTube -
    /// Chrome'
    pub window_title: Arc<str>,
    /// Represents an identifier of the application.
    /// On windows it is a process name. For example `C:\Windows\System32\cmd.exe`
    /// On x11 it is a process name. For example `/home/etc/nvim``
    /// On wayland, gnome, and kde it's a resource class. For example `org.kde.kate`
    pub app_identifier: Arc<str>,
}

/// Intended to serve as a contract windows and linux systems must implement.
#[cfg_attr(test, mockall::automock)]
#[async_trait]
pub trait WindowManager {
    async fn get_active_window_data(&mut self) -> Result<ActiveWindowData>;

    /// Retrieve amount of time user has been inactive in milliseconds
    async fn is_idle(&mut self) -> Result<bool>;
}

/// Serves as a cross-compatible WindowManager implementation.
pub struct GenericWindowManager {
    inner: Box<dyn WindowManager + Send + Sync>,
}

impl GenericWindowManager {
    pub async fn new(idle_timeout: Duration) -> Result<Self> {
        #[cfg(feature = "win")]
        {
            use win::WindowsWindowManager;
            return Ok(Self {
                inner: Box::new(WindowsWindowManager::new(idle_timeout)),
            });
        }
        // TODO: Should try to select not select outright
        #[cfg(feature = "gnome")]
        {
            use gnome::GnomeWindowWatcher;
            let watcher = GnomeWindowWatcher::new(idle_timeout.into()).await;
            match watcher {
                Ok(watcher) => {
                    let result = Ok(Self {
                        inner: Box::new(watcher),
                    });
                    info!("Loaded Gnome Wayland watcher");
                    return result;
                }
                Err(e) => {
                    use tracing::warn;
                    warn!("Failed to load Gnome Wayland watcher: {e}");
                }
            }
        }
        #[cfg(feature = "kde")]
        {
            use kde::KdeWindowManager;
            let watcher = KdeWindowManager::new(idle_timeout).await;
            match watcher {
                Ok(watcher) => {
                    let result = Ok(Self {
                        inner: Box::new(watcher),
                    });
                    info!("Loaded Kde wayland watcher");
                    return result;
                }
                Err(e) => {
                    use tracing::warn;
                    warn!("Failed to load Gnome Wayland watcher: {e}");
                }
            }
        }
        #[cfg(feature = "wayland")]
        {
            use wayland_wlr::WaylandWindowWatcher;
            let watcher = WaylandWindowWatcher::new(idle_timeout).await;
            match watcher {
                Ok(watcher) => {
                    let result = Ok(Self {
                        inner: Box::new(watcher),
                    });
                    info!("Loaded Wayland window watcher");
                    return result;
                }
                Err(e) => {
                    use tracing::warn;
                    warn!("Failed to load Wayland window watcher: {e}");
                }
            }
        }
        #[cfg(feature = "x11")]
        {
            use x11::LinuxWindowManager;
            let watcher = LinuxWindowManager::new(idle_timeout);
            match watcher {
                Ok(watcher) => {
                    let result = Ok(Self {
                        inner: Box::new(watcher),
                    });
                    info!("Loaded X11 window manager");
                    return result;
                }
                Err(e) => {
                    use tracing::warn;
                    warn!("Failed to load X11 window manager: {e}");
                }
            }
        }
        #[allow(unreachable_code)]
        {
            Err(anyhow::anyhow!("No window manager was selected"))
        }
    }
}

#[async_trait]
impl WindowManager for GenericWindowManager {
    async fn get_active_window_data(&mut self) -> Result<ActiveWindowData> {
        self.inner.get_active_window_data().await
    }

    async fn is_idle(&mut self) -> Result<bool> {
        self.inner.is_idle().await
    }
}