azizo_core/
lib.rs

1//! Unofficial Rust API for ASUS Splendid display control.
2//!
3//! This crate provides programmatic access to ASUS display settings on Windows laptops
4//! with Splendid display support.
5//!
6//! # Requirements
7//!
8//! - Windows 10/11
9//! - ASUS laptop with Splendid display support
10//! - ASUS PC Assistant installed
11//!
12//! # Example
13//!
14//! ```no_run
15//! use azizo_core::{AsusController, DisplayController, NormalMode, EyeCareMode};
16//!
17//! fn main() -> Result<(), azizo_core::ControllerError> {
18//!     // Create the controller (only one instance allowed)
19//!     let controller = AsusController::new()?;
20//!
21//!     // Sync state from hardware
22//!     controller.sync_all_sliders()?;
23//!
24//!     // Get current state
25//!     let state = controller.get_state();
26//!     println!("Current dimming: {}%", AsusController::dimming_to_percent(state.dimming));
27//!
28//!     // Set a mode
29//!     controller.set_mode(&NormalMode::new())?;
30//!
31//!     // Set eye care mode with level 2
32//!     controller.set_mode(&EyeCareMode::new(2)?)?;
33//!
34//!     // Toggle e-reading mode
35//!     controller.toggle_e_reading()?;
36//!
37//!     // Adjust dimming (0-100%)
38//!     controller.set_dimming_percent(75)?;
39//!
40//!     Ok(())
41//! }
42//! ```
43//!
44//! # Testing
45//!
46//! Use [`MockController`] to test code without hardware:
47//!
48//! ```
49//! use azizo_core::{MockController, DisplayController, NormalMode};
50//!
51//! let mock = MockController::new();
52//! mock.set_mode(&NormalMode::new()).unwrap();
53//! assert_eq!(mock.get_state().mode_id, 1);
54//! ```
55//!
56//! # Disclaimer
57//!
58//! This is an **unofficial** library. It is not affiliated with or endorsed by ASUS.
59//! Use at your own risk.
60
61#![warn(missing_docs)]
62
63mod controller;
64mod error;
65mod mock;
66mod modes;
67mod state;
68
69// Re-export public API
70pub use controller::{AsusController, DisplayController};
71pub use error::ControllerError;
72pub use mock::MockController;
73pub use modes::{DisplayMode, EReadingMode, EyeCareMode, ManualMode, NormalMode, VividMode};
74pub use state::ControllerState;
75
76#[cfg(test)]
77mod tests {
78    use super::*;
79
80    #[test]
81    fn test_mock_controller_toggle_ereading() {
82        let mock = MockController::new();
83
84        let mode = mock.get_current_mode().unwrap();
85        assert!(!mode.is_ereading());
86        assert_eq!(mode.mode_id(), 1);
87
88        let mode = mock.toggle_e_reading().unwrap();
89        assert!(mode.is_ereading());
90
91        let mode = mock.toggle_e_reading().unwrap();
92        assert!(!mode.is_ereading());
93        assert_eq!(mode.mode_id(), 1);
94    }
95
96    #[test]
97    fn test_mock_controller_dimming() {
98        let mock = MockController::new();
99
100        mock.set_dimming(80).unwrap();
101        assert_eq!(mock.get_state().dimming, 80);
102
103        mock.set_dimming_percent(50).unwrap();
104        let expected = AsusController::percent_to_dimming(50);
105        assert_eq!(mock.get_state().dimming, expected);
106    }
107
108    #[test]
109    fn test_dimming_conversion() {
110        assert_eq!(AsusController::percent_to_dimming(0), 40);
111        assert_eq!(AsusController::percent_to_dimming(100), 100);
112        assert_eq!(AsusController::percent_to_dimming(50), 70);
113
114        assert_eq!(AsusController::dimming_to_percent(40), 0);
115        assert_eq!(AsusController::dimming_to_percent(100), 100);
116        assert_eq!(AsusController::dimming_to_percent(70), 50);
117    }
118
119    #[test]
120    fn test_mode_from_controller_state() {
121        let state = ControllerState {
122            manual_slider: 75,
123            eyecare_level: 3,
124            ereading_grayscale: 2,
125            ereading_temp: 60,
126            ..Default::default()
127        };
128
129        let manual = ManualMode::from_controller_state(&state);
130        assert_eq!(manual.value, 75);
131
132        let eyecare = EyeCareMode::from_controller_state(&state);
133        assert_eq!(eyecare.level, 3);
134
135        let ereading = EReadingMode::from_controller_state(&state);
136        assert_eq!(ereading.grayscale, 2);
137        assert_eq!(ereading.temp, 60);
138    }
139}