refactor: 删除部分多余的代码和注释

src/otg/manager.rs

@@ -1,6 +1,3 @@
-//! OTG Gadget Manager - unified management for USB Gadget functions
-
-use std::collections::HashMap;
 use std::fs;
 use std::path::PathBuf;
 use tracing::{debug, error, info, warn};
@@ -11,14 +8,13 @@ use super::configfs::{
     DEFAULT_USB_VENDOR_ID, USB_BCD_USB,
 };
 use super::endpoint::{EndpointAllocator, DEFAULT_MAX_ENDPOINTS};
-use super::function::{FunctionMeta, GadgetFunction};
+use super::function::GadgetFunction;
 use super::hid::HidFunction;
 use super::msd::MsdFunction;
 use crate::error::{AppError, Result};
 
 const REBIND_DELAY_MS: u64 = 300;
 
-/// USB Gadget device descriptor configuration
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct GadgetDescriptor {
     pub vendor_id: u16,
@@ -42,44 +38,28 @@ impl Default for GadgetDescriptor {
     }
 }
 
-/// OTG Gadget Manager - unified management for HID and MSD
 pub struct OtgGadgetManager {
-    /// Gadget name
     gadget_name: String,
-    /// Gadget path in ConfigFS
     gadget_path: PathBuf,
-    /// Configuration path
     config_path: PathBuf,
-    /// Device descriptor
     descriptor: GadgetDescriptor,
-    /// Endpoint allocator
     endpoint_allocator: EndpointAllocator,
-    /// HID instance counter
     hid_instance: u8,
-    /// MSD instance counter
     msd_instance: u8,
-    /// Registered functions
     functions: Vec<Box<dyn GadgetFunction>>,
-    /// Function metadata
-    meta: HashMap<String, FunctionMeta>,
-    /// Bound UDC name
     bound_udc: Option<String>,
-    /// Whether gadget was created by us
     created_by_us: bool,
 }
 
 impl OtgGadgetManager {
-    /// Create a new gadget manager with default settings
     pub fn new() -> Self {
         Self::with_config(DEFAULT_GADGET_NAME, DEFAULT_MAX_ENDPOINTS)
     }
 
-    /// Create a new gadget manager with custom configuration
     pub fn with_config(gadget_name: &str, max_endpoints: u8) -> Self {
         Self::with_descriptor(gadget_name, max_endpoints, GadgetDescriptor::default())
     }
 
-    /// Create a new gadget manager with custom descriptor
     pub fn with_descriptor(
         gadget_name: &str,
         max_endpoints: u8,
@@ -96,30 +76,24 @@ impl OtgGadgetManager {
             endpoint_allocator: EndpointAllocator::new(max_endpoints),
             hid_instance: 0,
             msd_instance: 0,
-            // Pre-allocate for typical use: 3 HID (keyboard, rel mouse, abs mouse) + 1 MSD
             functions: Vec::with_capacity(4),
-            meta: HashMap::with_capacity(4),
             bound_udc: None,
             created_by_us: false,
         }
     }
 
-    /// Check if ConfigFS is available
     pub fn is_available() -> bool {
         is_configfs_available()
     }
 
-    /// Find available UDC
     pub fn find_udc() -> Option<String> {
         find_udc()
     }
 
-    /// Check if gadget exists
     pub fn gadget_exists(&self) -> bool {
         self.gadget_path.exists()
     }
 
-    /// Check if gadget is bound to UDC
     pub fn is_bound(&self) -> bool {
         let udc_file = self.gadget_path.join("UDC");
         if let Ok(content) = fs::read_to_string(&udc_file) {
@@ -129,8 +103,6 @@ impl OtgGadgetManager {
         }
     }
 
-    /// Add keyboard function
-    /// Returns the expected device path (e.g., /dev/hidg0)
     pub fn add_keyboard(&mut self, keyboard_leds: bool) -> Result<PathBuf> {
         let func = HidFunction::keyboard(self.hid_instance, keyboard_leds);
         let device_path = func.device_path();
@@ -139,7 +111,6 @@ impl OtgGadgetManager {
         Ok(device_path)
     }
 
-    /// Add relative mouse function
     pub fn add_mouse_relative(&mut self) -> Result<PathBuf> {
         let func = HidFunction::mouse_relative(self.hid_instance);
         let device_path = func.device_path();
@@ -148,7 +119,6 @@ impl OtgGadgetManager {
         Ok(device_path)
     }
 
-    /// Add absolute mouse function
     pub fn add_mouse_absolute(&mut self) -> Result<PathBuf> {
         let func = HidFunction::mouse_absolute(self.hid_instance);
         let device_path = func.device_path();
@@ -157,7 +127,6 @@ impl OtgGadgetManager {
         Ok(device_path)
     }
 
-    /// Add consumer control function (multimedia keys)
     pub fn add_consumer_control(&mut self) -> Result<PathBuf> {
         let func = HidFunction::consumer_control(self.hid_instance);
         let device_path = func.device_path();
@@ -166,7 +135,6 @@ impl OtgGadgetManager {
         Ok(device_path)
     }
 
-    /// Add MSD function (returns MsdFunction handle for LUN configuration)
     pub fn add_msd(&mut self) -> Result<MsdFunction> {
         let func = MsdFunction::new(self.msd_instance);
         let func_clone = func.clone();
@@ -175,11 +143,9 @@ impl OtgGadgetManager {
         Ok(func_clone)
     }
 
-    /// Add a generic function
     fn add_function(&mut self, func: Box<dyn GadgetFunction>) -> Result<()> {
         let endpoints = func.endpoints_required();
 
-        // Check endpoint availability
         if !self.endpoint_allocator.can_allocate(endpoints) {
             return Err(AppError::Internal(format!(
                 "Not enough endpoints for function {}: need {}, available {}",
@@ -189,30 +155,22 @@ impl OtgGadgetManager {
             )));
         }
 
-        // Allocate endpoints
         self.endpoint_allocator.allocate(endpoints)?;
 
-        // Store metadata
-        self.meta.insert(func.name().to_string(), func.meta());
-
-        // Store function
         self.functions.push(func);
 
         Ok(())
     }
 
-    /// Setup the gadget (create directories and configure)
     pub fn setup(&mut self) -> Result<()> {
         info!("Setting up OTG USB Gadget: {}", self.gadget_name);
 
-        // Check ConfigFS availability
         if !Self::is_available() {
             return Err(AppError::Internal(
                 "ConfigFS not available. Is it mounted at /sys/kernel/config?".to_string(),
             ));
         }
 
-        // Check if gadget already exists and is bound
         if self.gadget_exists() {
             if self.is_bound() {
                 info!("Gadget already exists and is bound, skipping setup");
@@ -222,20 +180,15 @@ impl OtgGadgetManager {
             self.cleanup()?;
         }
 
-        // Create gadget directory
         create_dir(&self.gadget_path)?;
         self.created_by_us = true;
 
-        // Set device descriptors
         self.set_device_descriptors()?;
 
-        // Create strings
         self.create_strings()?;
 
-        // Create configuration
         self.create_configuration()?;
 
-        // Create and link all functions
         for func in &self.functions {
             func.create(&self.gadget_path)?;
             func.link(&self.config_path, &self.gadget_path)?;
@@ -245,9 +198,7 @@ impl OtgGadgetManager {
         Ok(())
     }
 
-    /// Bind gadget to a specific UDC
     pub fn bind(&mut self, udc: &str) -> Result<()> {
-        // Recreate config symlinks before binding to avoid kernel gadget issues after rebind
         if let Err(e) = self.recreate_config_links() {
             warn!("Failed to recreate gadget config links before bind: {}", e);
         }
@@ -260,7 +211,6 @@ impl OtgGadgetManager {
         Ok(())
     }
 
-    /// Unbind gadget from UDC
     pub fn unbind(&mut self) -> Result<()> {
         if self.is_bound() {
             write_file(&self.gadget_path.join("UDC"), "")?;
@@ -271,7 +221,6 @@ impl OtgGadgetManager {
         Ok(())
     }
 
-    /// Cleanup all resources
     pub fn cleanup(&mut self) -> Result<()> {
         if !self.gadget_exists() {
             return Ok(());
@@ -279,29 +228,23 @@ impl OtgGadgetManager {
 
         info!("Cleaning up OTG USB Gadget: {}", self.gadget_name);
 
-        // Unbind from UDC first
         let _ = self.unbind();
 
-        // Unlink and cleanup functions
         for func in self.functions.iter().rev() {
             let _ = func.unlink(&self.config_path);
         }
 
-        // Remove config strings
         let config_strings = self.config_path.join("strings/0x409");
         let _ = remove_dir(&config_strings);
         let _ = remove_dir(&self.config_path);
 
-        // Cleanup functions
         for func in self.functions.iter().rev() {
             let _ = func.cleanup(&self.gadget_path);
         }
 
-        // Remove gadget strings
         let gadget_strings = self.gadget_path.join("strings/0x409");
         let _ = remove_dir(&gadget_strings);
 
-        // Remove gadget directory
         if let Err(e) = remove_dir(&self.gadget_path) {
             warn!("Could not remove gadget directory: {}", e);
         }
@@ -311,7 +254,6 @@ impl OtgGadgetManager {
         Ok(())
     }
 
-    /// Set USB device descriptors
     fn set_device_descriptors(&self) -> Result<()> {
         write_file(
             &self.gadget_path.join("idVendor"),
@@ -329,14 +271,13 @@ impl OtgGadgetManager {
             &self.gadget_path.join("bcdUSB"),
             &format!("0x{:04x}", USB_BCD_USB),
         )?;
-        write_file(&self.gadget_path.join("bDeviceClass"), "0x00")?; // Composite device
+        write_file(&self.gadget_path.join("bDeviceClass"), "0x00")?;
         write_file(&self.gadget_path.join("bDeviceSubClass"), "0x00")?;
         write_file(&self.gadget_path.join("bDeviceProtocol"), "0x00")?;
         debug!("Set device descriptors");
         Ok(())
     }
 
-    /// Create USB strings
     fn create_strings(&self) -> Result<()> {
         let strings_path = self.gadget_path.join("strings/0x409");
         create_dir(&strings_path)?;
@@ -354,41 +295,23 @@ impl OtgGadgetManager {
         Ok(())
     }
 
-    /// Create configuration
     fn create_configuration(&self) -> Result<()> {
         create_dir(&self.config_path)?;
 
-        // Create config strings
         let strings_path = self.config_path.join("strings/0x409");
         create_dir(&strings_path)?;
         write_file(&strings_path.join("configuration"), "Config 1: HID + MSD")?;
 
-        // Set max power (500mA)
         write_file(&self.config_path.join("MaxPower"), "500")?;
 
         debug!("Created configuration c.1");
         Ok(())
     }
 
-    /// Get function metadata
-    pub fn get_meta(&self) -> &HashMap<String, FunctionMeta> {
-        &self.meta
-    }
-
-    /// Get endpoint usage info
-    pub fn endpoint_info(&self) -> (u8, u8) {
-        (
-            self.endpoint_allocator.used(),
-            self.endpoint_allocator.max(),
-        )
-    }
-
-    /// Get gadget path
     pub fn gadget_path(&self) -> &PathBuf {
         &self.gadget_path
     }
 
-    /// Recreate config symlinks from functions directory
     fn recreate_config_links(&self) -> Result<()> {
         let functions_path = self.gadget_path.join("functions");
         if !functions_path.exists() || !self.config_path.exists() {
@@ -450,15 +373,10 @@ impl Drop for OtgGadgetManager {
     }
 }
 
-/// Wait for HID devices to become available
-///
-/// Uses exponential backoff starting from 10ms, capped at 100ms,
-/// to reduce CPU usage while still providing fast response.
 pub async fn wait_for_hid_devices(device_paths: &[PathBuf], timeout_ms: u64) -> bool {
     let start = std::time::Instant::now();
     let timeout = std::time::Duration::from_millis(timeout_ms);
 
-    // Exponential backoff: start at 10ms, double each time, cap at 100ms
     let mut delay_ms = 10u64;
     const MAX_DELAY_MS: u64 = 100;
 
@@ -467,7 +385,6 @@ pub async fn wait_for_hid_devices(device_paths: &[PathBuf], timeout_ms: u64) ->
             return true;
         }
 
-        // Calculate remaining time to avoid overshooting timeout
         let remaining = timeout.saturating_sub(start.elapsed());
         let sleep_duration = std::time::Duration::from_millis(delay_ms).min(remaining);
 
@@ -477,7 +394,6 @@ pub async fn wait_for_hid_devices(device_paths: &[PathBuf], timeout_ms: u64) ->
 
         tokio::time::sleep(sleep_duration).await;
 
-        // Exponential backoff with cap
         delay_ms = (delay_ms * 2).min(MAX_DELAY_MS);
     }
 
@@ -492,18 +408,16 @@ mod tests {
     fn test_manager_creation() {
         let manager = OtgGadgetManager::new();
         assert_eq!(manager.gadget_name, DEFAULT_GADGET_NAME);
-        assert!(!manager.gadget_exists()); // Won't exist in test environment
+        assert!(!manager.gadget_exists());
     }
 
     #[test]
     fn test_endpoint_tracking() {
         let mut manager = OtgGadgetManager::with_config("test", 8);
 
-        // Keyboard uses 1 endpoint
         let _ = manager.add_keyboard(false);
         assert_eq!(manager.endpoint_allocator.used(), 1);
 
-        // Mouse uses 1 endpoint each
         let _ = manager.add_mouse_relative();
         let _ = manager.add_mouse_absolute();
         assert_eq!(manager.endpoint_allocator.used(), 3);