quickgui-system 0.1.6

Cross-platform operating-system services for QuickGUI
Documentation
use std::{mem, ptr, time::Duration};

use windows_sys::Win32::{
    Foundation::{CloseHandle, HANDLE},
    System::{
        Power::{
            CallNtPowerInformation, GetSystemPowerStatus, PROCESSOR_POWER_INFORMATION,
            PowerClearRequest, PowerCreateRequest, PowerRequestDisplayRequired,
            PowerRequestSystemRequired, PowerSetRequest, ProcessorInformation, SYSTEM_POWER_STATUS,
        },
        RemoteDesktop::{
            WTS_CURRENT_SERVER_HANDLE, WTS_CURRENT_SESSION, WTS_SESSIONSTATE_LOCK,
            WTS_SESSIONSTATE_UNLOCK, WTSFreeMemory, WTSINFOEXW, WTSQuerySessionInformationW,
            WTSSessionInfoEx,
        },
        SystemInformation::GetTickCount64,
        Threading::{POWER_REQUEST_CONTEXT_SIMPLE_STRING, REASON_CONTEXT, REASON_CONTEXT_0},
    },
    UI::Input::KeyboardAndMouse::{GetLastInputInfo, LASTINPUTINFO},
};

use super::{
    BatteryState, BatteryStatus, PowerAssertionKind, PowerSource, PowerState, Result, SessionState,
    ThermalState,
};
use crate::platform;

const BATTERY_FLAG_CHARGING: u8 = 8;
const BATTERY_FLAG_NO_BATTERY: u8 = 128;
const UNKNOWN_BYTE: u8 = u8::MAX;

pub(super) struct PlatformPowerAssertion {
    handle: HANDLE,
    requests: [i32; 2],
    request_count: usize,
}

impl PlatformPowerAssertion {
    pub(super) fn acquire(kind: PowerAssertionKind, reason: &str) -> Result<Self> {
        let mut reason: Vec<u16> = reason.encode_utf16().chain([0]).collect();
        let context = REASON_CONTEXT {
            Version: 0,
            Flags: POWER_REQUEST_CONTEXT_SIMPLE_STRING,
            Reason: REASON_CONTEXT_0 {
                SimpleReasonString: reason.as_mut_ptr(),
            },
        };
        let handle = unsafe { PowerCreateRequest(&context) };
        if handle.is_null() || handle == -1_isize as HANDLE {
            return Err(platform(std::io::Error::last_os_error()));
        }
        let (requests, request_count) = match kind {
            PowerAssertionKind::PreventApplicationSuspension => {
                ([PowerRequestSystemRequired, 0], 1)
            }
            PowerAssertionKind::PreventDisplaySleep => {
                ([PowerRequestSystemRequired, PowerRequestDisplayRequired], 2)
            }
        };
        let mut acquired = 0_usize;
        while acquired < request_count {
            if unsafe { PowerSetRequest(handle, requests[acquired]) } == 0 {
                let error = std::io::Error::last_os_error();
                while acquired > 0 {
                    acquired -= 1;
                    unsafe {
                        PowerClearRequest(handle, requests[acquired]);
                    }
                }
                unsafe {
                    CloseHandle(handle);
                }
                return Err(platform(error));
            }
            acquired += 1;
        }
        Ok(Self {
            handle,
            requests,
            request_count,
        })
    }

    pub(super) fn release(mut self) -> Result<()> {
        let mut error = None;
        while self.request_count > 0 {
            self.request_count -= 1;
            if unsafe { PowerClearRequest(self.handle, self.requests[self.request_count]) } == 0 {
                error.get_or_insert_with(std::io::Error::last_os_error);
            }
        }
        unsafe {
            CloseHandle(self.handle);
        }
        self.handle = ptr::null_mut();
        error.map_or(Ok(()), |error| Err(platform(error)))
    }
}

pub(super) fn snapshot() -> Result<PowerState> {
    let mut status = SYSTEM_POWER_STATUS::default();
    if unsafe { GetSystemPowerStatus(&mut status) } == 0 {
        return Err(platform(std::io::Error::last_os_error()));
    }
    let source = match status.ACLineStatus {
        0 => PowerSource::Battery,
        1 => PowerSource::Ac,
        _ => PowerSource::Unknown,
    };
    let battery = if status.BatteryFlag == UNKNOWN_BYTE
        || status.BatteryFlag & BATTERY_FLAG_NO_BATTERY != 0
    {
        None
    } else {
        let percent = (status.BatteryLifePercent != UNKNOWN_BYTE)
            .then_some(status.BatteryLifePercent.min(100));
        let battery_status = if status.BatteryFlag & BATTERY_FLAG_CHARGING != 0 {
            BatteryStatus::Charging
        } else if percent == Some(100) && source == PowerSource::Ac {
            BatteryStatus::Full
        } else if source == PowerSource::Battery {
            BatteryStatus::Discharging
        } else if source == PowerSource::Ac {
            BatteryStatus::NotCharging
        } else {
            BatteryStatus::Unknown
        };
        Some(BatteryState::new(percent, battery_status))
    };
    Ok(PowerState::new(
        source,
        battery,
        ThermalState::Unknown,
        Some(status.SystemStatusFlag != 0),
        processor_speed_limit(),
    ))
}

pub(super) fn system_idle_time() -> Result<Duration> {
    let mut input = LASTINPUTINFO {
        cbSize: mem::size_of::<LASTINPUTINFO>() as u32,
        dwTime: 0,
    };
    if unsafe { GetLastInputInfo(&mut input) } == 0 {
        return Err(platform(std::io::Error::last_os_error()));
    }
    let now = unsafe { GetTickCount64() } as u32;
    Ok(Duration::from_millis(now.wrapping_sub(input.dwTime).into()))
}

pub(super) fn session_state() -> Result<SessionState> {
    let mut buffer = ptr::null_mut();
    let mut bytes = 0_u32;
    if unsafe {
        WTSQuerySessionInformationW(
            WTS_CURRENT_SERVER_HANDLE,
            WTS_CURRENT_SESSION,
            WTSSessionInfoEx,
            &mut buffer,
            &mut bytes,
        )
    } == 0
    {
        return Ok(SessionState::Unknown);
    }
    let state = if bytes as usize >= mem::size_of::<WTSINFOEXW>() {
        let info = unsafe { &*buffer.cast::<WTSINFOEXW>() };
        if info.Level == 1 {
            let info = unsafe { info.Data.WTSInfoExLevel1 };
            match info.SessionFlags as u32 {
                WTS_SESSIONSTATE_LOCK => SessionState::Locked,
                WTS_SESSIONSTATE_UNLOCK => SessionState::Active,
                _ => SessionState::Unknown,
            }
        } else {
            SessionState::Unknown
        }
    } else {
        SessionState::Unknown
    };
    unsafe {
        WTSFreeMemory(buffer.cast());
    }
    Ok(state)
}

fn processor_speed_limit() -> Option<u8> {
    let count = std::thread::available_parallelism().ok()?.get().min(256);
    let mut processors = vec![PROCESSOR_POWER_INFORMATION::default(); count];
    let bytes = processors
        .len()
        .checked_mul(mem::size_of::<PROCESSOR_POWER_INFORMATION>())?;
    let bytes = u32::try_from(bytes).ok()?;
    let status = unsafe {
        CallNtPowerInformation(
            ProcessorInformation,
            ptr::null(),
            0,
            processors.as_mut_ptr().cast(),
            bytes,
        )
    };
    if status != 0 {
        return None;
    }
    processors
        .iter()
        .filter(|processor| processor.MaxMhz > 0 && processor.MhzLimit > 0)
        .map(|processor| {
            processor
                .MhzLimit
                .saturating_mul(100)
                .checked_div(processor.MaxMhz)
                .unwrap_or(100)
                .min(100) as u8
        })
        .min()
}