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

//! Get a users idle time.
//!
//! The time returned is the time since the last user input event.
//!
//! See the [`README.md`](https://github.com/olback/user-idle-rs/blob/master/README.md) for more information.
//!
//! Example:
//! ```rust
//! use user_idle::UserIdle;
//! let idle = UserIdle::get_time().unwrap();
//! let idle_seconds = idle.as_seconds();
//! let idle_minutes = idle.as_minutes();
//! // Check the documentation for more methods
//! ```

use std::time::Duration;
mod error;
pub use error::Error;

#[cfg(all(target_os = "linux", not(feature = "dbus")))]
mod x11_impl;

#[cfg(all(target_os = "linux", feature = "dbus"))]
mod dbus_impl;

#[cfg(target_os = "windows")]
mod windows_impl;

#[cfg(target_os = "macos")]
mod macos_impl;

pub struct UserIdle {
    duration: Duration
}

impl UserIdle {

    /// Get the idle time
    pub fn get_time() -> Result<Self, Error> {

        #[cfg(all(target_os = "linux", not(feature = "dbus")))]
        let duration = x11_impl::get_idle_time()?;

        #[cfg(all(target_os = "linux", feature = "dbus"))]
        let duration = dbus_impl::get_idle_time()?;

        #[cfg(target_os = "windows")]
        let duration = windows_impl::get_idle_time()?;

        #[cfg(target_os = "macos")]
        let duration = macos_impl::get_idle_time()?;

        Ok(UserIdle {
            duration,
        })

    }

    /// Get time in milliseconds
    ///
    /// Note: Only MacOS provides this level of resolution,
    /// other Operating Systems will provide the same value as
    /// `self.as_milliseconds() * 1_000_000`
    pub fn as_nanoseconds(&self) -> u128 {
        self.duration.as_nanos()
    }

    /// Get time in milliseconds
    ///
    /// Note: Not all of the dbus screen savers provided
    /// this level of resolution, in those cases this will
    /// provide the same value as `self.as_seconds() * 1000`
    pub fn as_milliseconds(&self) -> u128 {
        self.duration.as_millis()
    }

    /// Get time in seconds
    pub fn as_seconds(&self) -> u64 {
        self.duration.as_secs()
    }

    /// Get time in minutes
    pub fn as_minutes(&self) -> u64 {
        self.as_seconds() / 60
    }

    /// Get time in hours
    pub fn as_hours(&self) -> u64 {
        self.as_minutes() / 60
    }

    /// Get time in days
    pub fn as_days(&self) -> u64 {
        self.as_hours() / 24
    }

    /// Get time in weeks
    pub fn as_weeks(&self) -> u64 {
        self.as_days() / 7
    }

    /// Get time in months
    pub fn as_months(&self) -> u64 {
        self.as_weeks() / 4
    }

    /// Get time in years
    pub fn as_years(&self) -> u64 {
        self.as_months() / 12
    }

    /// Convert to a std::time::Duration
    pub fn duration(&self) -> Duration {
        self.duration
    }

}

// #[cfg(test)]
// mod tests {

//     use super::UserIdle;

//     #[test]
//     fn main() {

//         std::thread::sleep(std::time::Duration::from_secs(10));

//         let idle = UserIdle::get_time().unwrap();

//         println!("Idle for: {} seconds", idle.as_seconds());

//     }

// }