feat: DevicePlugin Task3 — Linux ARM64 Backend(Display/SleepInhibit/Backlight)

src/plugins/device/linux_arm64.rs

@@ -0,0 +1,168 @@
+//! Linux ARM64 设备后端实现
+//!
+//! 支持 Linux ARM64 平台的设备操作，包括显示信息、背光控制、防息屏等功能。
+
+use crate::core::message::{DeviceCapability, DeviceCommand, DeviceResponse, PixelFormat};
+use crate::plugins::device::backend::DeviceBackend;
+use anyhow::Result;
+use std::fs;
+use std::process::{Child, Command, Stdio};
+
+/// Linux ARM64 设备后端
+///
+/// 通过 sysfs 和 systemd-inhibit 实现设备控制。
+pub struct LinuxArm64Backend {
+    /// systemd-inhibit 子进程（用于防息屏）
+    wake_lock_child: Option<Child>,
+    /// 显示宽度
+    display_width: u32,
+    /// 显示高度
+    display_height: u32,
+    /// 背光状态
+    backlight_enabled: bool,
+}
+
+impl LinuxArm64Backend {
+    /// 创建新的 Linux ARM64 后端实例
+    pub fn new() -> Self {
+        Self {
+            wake_lock_child: None,
+            display_width: 1920, // 默认分辨率
+            display_height: 1080,
+            backlight_enabled: true,
+        }
+    }
+
+    /// 读取 framebuffer 分辨率
+    fn read_framebuffer_resolution(&mut self) -> Result<()> {
+        // 尝试从 /sys/class/graphics/fb0/virtual_size 读取分辨率
+        if let Ok(content) = fs::read_to_string("/sys/class/graphics/fb0/virtual_size") {
+            let parts: Vec<&str> = content.trim().split(',').collect();
+            if parts.len() == 2 {
+                if let (Ok(width), Ok(height)) = (parts[0].parse(), parts[1].parse()) {
+                    self.display_width = width;
+                    self.display_height = height;
+                    return Ok(());
+                }
+            }
+        }
+
+        // 如果读取失败，使用默认值（已在 new() 中设置）
+        Ok(())
+    }
+
+    /// 启动防息屏（systemd-inhibit）
+    fn start_sleep_inhibit(&mut self) -> Result<()> {
+        if self.wake_lock_child.is_some() {
+            return Ok(());
+        }
+
+        match Command::new("systemd-inhibit")
+            .arg("--what=idle:sleep")
+            .arg("--mode=block")
+            .arg("--who=ShowenV2")
+            .arg("--why=Device operation in progress")
+            .arg("sleep")
+            .arg("infinity")
+            .stdin(Stdio::null())
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .spawn()
+        {
+            Ok(child) => {
+                self.wake_lock_child = Some(child);
+                Ok(())
+            }
+            Err(e) => Err(anyhow::anyhow!("Failed to start systemd-inhibit: {}", e)),
+        }
+    }
+
+    /// 停止防息屏
+    fn stop_sleep_inhibit(&mut self) -> Result<()> {
+        if let Some(mut child) = self.wake_lock_child.take() {
+            child.kill()?;
+            child.wait()?;
+        }
+        Ok(())
+    }
+
+    /// 设置背光状态
+    fn set_backlight(&mut self, enabled: bool) -> Result<()> {
+        self.backlight_enabled = enabled;
+
+        // 尝试写入 /sys/class/backlight/*/brightness
+        // 首先查找 backlight 设备
+        if let Ok(entries) = fs::read_dir("/sys/class/backlight") {
+            for entry in entries.flatten() {
+                let brightness_path = entry.path().join("brightness");
+                let max_brightness_path = entry.path().join("max_brightness");
+
+                // 读取最大亮度
+                if let Ok(max_str) = fs::read_to_string(&max_brightness_path) {
+                    if let Ok(max_brightness) = max_str.trim().parse::<u32>() {
+                        // 设置亮度：开启时设为最大值，关闭时设为 0
+                        let value = if enabled { max_brightness } else { 0 };
+                        if fs::write(&brightness_path, value.to_string()).is_ok() {
+                            return Ok(());
+                        }
+                    }
+                }
+            }
+        }
+
+        // 如果没有找到 backlight 设备，返回成功（某些设备可能不支持）
+        Ok(())
+    }
+}
+
+impl DeviceBackend for LinuxArm64Backend {
+    fn name(&self) -> &str {
+        "linux-arm64"
+    }
+
+    fn init(&mut self, _config: &serde_json::Value) -> Result<()> {
+        // 读取 framebuffer 分辨率
+        self.read_framebuffer_resolution()?;
+        Ok(())
+    }
+
+    fn capabilities(&self) -> Vec<DeviceCapability> {
+        vec![
+            DeviceCapability::Display,
+            DeviceCapability::Backlight,
+            DeviceCapability::Framebuffer,
+        ]
+    }
+
+    fn handle_command(&mut self, cmd: DeviceCommand) -> Result<DeviceResponse> {
+        match cmd {
+            DeviceCommand::GetDisplayInfo => Ok(DeviceResponse::DisplayInfo {
+                width: self.display_width,
+                height: self.display_height,
+                format: PixelFormat::RGB888,
+            }),
+
+            DeviceCommand::SetSleepInhibit(enable) => {
+                if enable {
+                    self.start_sleep_inhibit()?;
+                } else {
+                    self.stop_sleep_inhibit()?;
+                }
+                Ok(DeviceResponse::Ok)
+            }
+
+            DeviceCommand::SetBacklight(enabled) => {
+                self.set_backlight(enabled)?;
+                Ok(DeviceResponse::Ok)
+            }
+
+            _ => Ok(DeviceResponse::Error("Not implemented".to_string())),
+        }
+    }
+
+    fn shutdown(&mut self) -> Result<()> {
+        // 清理 wake_lock_child
+        self.stop_sleep_inhibit()?;
+        Ok(())
+    }
+}

src/plugins/device/mod.rs

@@ -12,6 +12,11 @@ use anyhow::Result;
 pub mod backend;
 pub use backend::DeviceBackend;
 
+#[cfg(target_os = "linux")]
+pub mod linux_arm64;
+#[cfg(target_os = "linux")]
+pub use linux_arm64::LinuxArm64Backend;
+
 /// DevicePlugin 结构体
 ///
 /// 统一设备管理插件，负责处理所有设备相关的操作。
@@ -59,6 +64,19 @@ impl DevicePlugin {
     pub fn new(backend: Box<dyn DeviceBackend>) -> Self {
         Self { ctx: None, backend }
     }
+
+    /// 创建使用默认平台后端的 DevicePlugin 实例
+    ///
+    /// 根据当前平台自动选择合适的后端实现。
+    ///
+    /// # 示例
+    /// ```ignore
+    /// let plugin = DevicePlugin::new_default();
+    /// ```
+    #[cfg(target_os = "linux")]
+    pub fn new_default() -> Self {
+        Self::new(Box::new(LinuxArm64Backend::new()))
+    }
 }
 
 impl Plugin for DevicePlugin {