Merge pull request 'feat: Replace screen capture with ScreenCaptureKit and fix performance issues' (#6) from replace-rust-swift-screencapture-with-screencapturekit into develop

Reviewed-on: #6

README.md

@@ -1,7 +1,188 @@
-# Tauri + Solid + Typescript
+# Display Ambient Light Desktop App
 
-This template should help get you started developing with Tauri, Solid and Typescript in Vite.
+A desktop application built with Tauri 2.0 for ambient light control, supporting multi-monitor screen sampling and LED strip control to create immersive ambient lighting effects.
 
-## Recommended IDE Setup
+## ✨ Features
 
-- [VS Code](https://code.visualstudio.com/) + [Tauri](https://marketplace.visualstudio.com/items?itemName=tauri-apps.tauri-vscode) + [rust-analyzer](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer)
+- 🖥️ **Multi-Monitor Support** - Automatic detection and configuration of multiple displays
+- 🎨 **Real-time Screen Sampling** - High-performance screen content capture and color analysis
+- 💡 **LED Strip Control** - Configurable LED strip layout and mapping support
+- ⚖️ **White Balance Calibration** - Built-in white balance adjustment tool with fullscreen mode
+- 🎛️ **Intuitive Configuration Interface** - Modern UI with drag-and-drop configuration support
+- 🔧 **Hardware Integration** - Display brightness control and audio device management
+- 📡 **Network Communication** - UDP and WebSocket communication support
+
+## 🛠️ Tech Stack
+
+### Frontend
+
+- **Framework**: [Solid.js](https://solidjs.com/) - High-performance reactive UI framework
+- **Build Tool**: [Vite](https://vitejs.dev/) - Fast frontend build tool
+- **Styling**: [Tailwind CSS](https://tailwindcss.com/) + [DaisyUI](https://daisyui.com/) - Modern UI component library
+- **Routing**: [@solidjs/router](https://github.com/solidjs/solid-router) - Client-side routing
+- **Language**: TypeScript - Type-safe JavaScript
+
+### Backend
+
+- **Framework**: [Tauri 2.0](https://tauri.app/) - Cross-platform desktop app framework
+- **Language**: Rust - High-performance systems programming language
+- **Screen Capture**: [screen-capture-kit](https://crates.io/crates/screen-capture-kit) - macOS native screen capture
+- **Display Control**: [ddc-hi](https://crates.io/crates/ddc-hi) - DDC/CI display control
+- **Audio**: [coreaudio-rs](https://crates.io/crates/coreaudio-rs) - macOS audio system integration
+- **Networking**: tokio + tokio-tungstenite - Async network communication
+
+## 📋 System Requirements
+
+- **Operating System**: macOS 13.0+ (primary supported platform)
+- **Memory**: 4GB+ recommended
+- **Graphics**: Hardware-accelerated graphics card
+- **Network**: For device discovery and communication
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+1. **Install Rust**
+
+   ```bash
+   curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+   source ~/.cargo/env
+   ```
+
+2. **Install Node.js and pnpm**
+
+   ```bash
+   # Install Node.js (recommended using nvm)
+   curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
+   nvm install node
+
+   # Install pnpm
+   npm install -g pnpm
+   ```
+
+3. **Install Tauri CLI**
+
+   ```bash
+   cargo install @tauri-apps/cli@next
+   ```
+
+### Development Setup
+
+1. **Clone the project**
+
+   ```bash
+   git clone <repository-url>
+   cd display-ambient-light/desktop
+   ```
+
+2. **Install dependencies**
+
+   ```bash
+   pnpm install
+   ```
+
+3. **Start development server**
+
+   ```bash
+   pnpm tauri dev
+   ```
+
+### Production Build
+
+```bash
+# Build the application
+pnpm tauri build
+
+# Build artifacts are located in src-tauri/target/release/bundle/
+```
+
+## 📱 Application Interface
+
+### Main Pages
+
+1. **System Info** (`/info`) - Display system and hardware information
+2. **Display Info** (`/displays`) - Monitor status and configuration
+3. **LED Strip Configuration** (`/led-strips-configuration`) - LED strip layout and mapping configuration
+4. **White Balance** (`/white-balance`) - Color calibration and white balance adjustment
+
+### Core Features
+
+- **Real-time Screen Preview** - WebSocket streaming of screen content
+- **LED Mapping Configuration** - Visual configuration of LED strip positions and quantities
+- **Color Calibration** - RGB adjustment panel with fullscreen comparison mode
+- **Device Management** - Automatic discovery and management of LED control devices
+
+## 🔧 Configuration Files
+
+Application configuration is stored in the user directory:
+
+```text
+~/Library/Application Support/cc.ivanli.ambient-light.desktop/
+├── config.toml          # Main configuration file
+├── led_strips.json      # LED strip configuration
+└── color_calibration.json # Color calibration data
+```
+
+## 🎯 Development Guide
+
+### Project Structure
+
+```text
+desktop/
+├── src/                 # Frontend source code (Solid.js)
+│   ├── components/      # UI components
+│   ├── stores/         # State management
+│   ├── models/         # Data models
+│   └── contexts/       # React Context
+├── src-tauri/          # Backend source code (Rust)
+│   ├── src/
+│   │   ├── ambient_light/  # Ambient light control
+│   │   ├── display/        # Display management
+│   │   ├── rpc/           # Network communication
+│   │   └── screenshot/    # Screen capture
+│   └── tauri.conf.json    # Tauri configuration
+└── package.json        # Frontend dependencies
+```
+
+### Development Workflow
+
+1. **Frontend Development**: Modify files under `src/`, supports hot reload
+2. **Backend Development**: Modify files under `src-tauri/src/`, requires dev server restart
+3. **Configuration Changes**: Restart required after modifying `tauri.conf.json`
+
+### Debugging Tips
+
+- Use browser developer tools to debug frontend
+- Use `console.log` and Rust's `println!` for debugging
+- Check Tauri console output for backend logs
+
+## 🤝 Contributing
+
+1. Fork the project
+2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
+3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
+4. Push to the branch (`git push origin feature/AmazingFeature`)
+5. Open a Pull Request
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🔗 Related Links
+
+- [Tauri Official Documentation](https://tauri.app/)
+- [Solid.js Official Documentation](https://solidjs.com/)
+- [Rust Official Documentation](https://doc.rust-lang.org/)
+- [Tailwind CSS Documentation](https://tailwindcss.com/docs)
+
+## 📞 Support
+
+If you encounter issues or have suggestions, please:
+
+- Create an [Issue](../../issues)
+- Check the [Wiki](../../wiki) for more information
+- Contact the developer
+
+---
+
+**Note**: This application is primarily optimized for macOS platform, support for other platforms may be limited.

debug_displays.rs

@@ -0,0 +1,16 @@
+use display_info;
+
+fn main() {
+    match display_info::DisplayInfo::all() {
+        Ok(displays) => {
+            println!("Found {} displays:", displays.len());
+            for (index, display) in displays.iter().enumerate() {
+                println!("  Display {}: ID={}, Scale={}, Width={}, Height={}", 
+                    index, display.id, display.scale_factor, display.width, display.height);
+            }
+        }
+        Err(e) => {
+            println!("Error getting display info: {}", e);
+        }
+    }
+}

package.json

@@ -11,23 +11,26 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@solidjs/router": "^0.8.2",
+    "@solidjs/router": "^0.8.4",
-    "@tauri-apps/api": "^1.3.0",
+    "@tauri-apps/api": "^2.6.0",
-    "debug": "^4.3.4",
+    "debug": "^4.4.1",
-    "solid-icons": "^1.0.4",
+    "solid-icons": "^1.1.0",
-    "solid-js": "^1.7.4",
+    "solid-js": "^1.9.7",
     "solid-tippy": "^0.2.1",
     "tippy.js": "^6.3.7"
   },
   "devDependencies": {
-    "@tauri-apps/cli": "^1.3.0",
+    "@tailwindcss/postcss": "^4.1.11",
-    "@types/debug": "^4.1.7",
+    "@tailwindcss/vite": "^4.1.11",
-    "@types/node": "^18.16.3",
+    "@tauri-apps/cli": "^2.6.2",
-    "autoprefixer": "^10.4.14",
+    "@types/debug": "^4.1.12",
-    "postcss": "^8.4.23",
+    "@types/node": "^24.0.7",
-    "tailwindcss": "^3.3.2",
+    "autoprefixer": "^10.4.21",
+    "daisyui": "^5.0.43",
+    "postcss": "^8.5.6",
+    "tailwindcss": "^4.1.11",
     "typescript": "^4.9.5",
-    "vite": "^4.3.4",
+    "vite": "^6.3.5",
-    "vite-plugin-solid": "^2.7.0"
+    "vite-plugin-solid": "^2.11.7"
   }
 }

postcss.config.js

@@ -1,6 +1,5 @@
 module.exports = {
   plugins: {
-    tailwindcss: {},
     autoprefixer: {},
   },
 }

src-tauri/Cargo.toml

@@ -10,11 +10,14 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [build-dependencies]
-tauri-build = { version = "1.2", features = [] }
+tauri-build = { version = "2.0", features = [] }
 
 [dependencies]
-tauri = { version = "1.2", features = ["shell-open"] }
+tauri = { version = "2.0", features = ["tray-icon"] }
+tauri-plugin-shell = "2.0"
 serde = { version = "1.0", features = ["derive"] }
+dirs = "5.0"
+regex = "1.0"
 serde_json = "1.0"
 core-graphics = "0.22.3"
 display-info = "0.4.1"
@@ -28,8 +31,8 @@ url-build-parse = "9.0.0"
 color_space = "0.5.3"
 hex = "0.4.3"
 toml = "0.7.3"
-paho-mqtt = "0.12.1"
+# paho-mqtt = "0.12.1"  # Temporarily disabled due to CMake issues
-time = {version="0.3.20", features= ["formatting"] }
+time = {version="0.3.35", features= ["formatting"] }
 itertools = "0.10.5"
 core-foundation = "0.9.3"
 tokio-stream = "0.1.14"
@@ -37,6 +40,11 @@ mdns-sd = "0.7.2"
 futures = "0.3.28"
 ddc-hi = "0.4.1"
 coreaudio-rs = "0.11.2"
+screen-capture-kit = "0.3.1"
+image = { version = "0.24", features = ["jpeg"] }
+tokio-tungstenite = "0.20"
+futures-util = "0.3"
+sha1 = "0.10"
 
 [features]
 # this feature is used for production builds or when `devPath` points to the filesystem

src-tauri/capabilities/default.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "../gen/schemas/desktop-schema.json",
+  "identifier": "default",
+  "description": "Capability for the main application window",
+  "windows": ["main"],
+  "permissions": [
+    "core:default",
+    "shell:allow-open",
+    "core:window:allow-set-fullscreen",
+    "core:window:allow-is-fullscreen"
+  ]
+}

src-tauri/gen/schemas/capabilities.json

@@ -0,0 +1 @@
+{"default":{"identifier":"default","description":"Capability for the main application window","local":true,"windows":["main"],"permissions":["core:default","shell:allow-open","core:window:allow-set-fullscreen","core:window:allow-is-fullscreen"]}}

src-tauri/src-tauri/.gitignore

@@ -0,0 +1,3 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/

src-tauri/src-tauri/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "app"
+version = "0.1.0"
+description = "A Tauri App"
+authors = ["you"]
+license = ""
+repository = ""
+default-run = "app"
+edition = "2021"
+rust-version = "1.60"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[build-dependencies]
+tauri-build = { version = "1.5.6" }
+
+[dependencies]
+serde_json = "1.0"
+serde = { version = "1.0", features = ["derive"] }
+tauri = { version = "1.8.2" }
+
+[features]
+# this feature is used for production builds or when `devPath` points to the filesystem and the built-in dev server is disabled.
+# If you use cargo directly instead of tauri's cli you can use this feature flag to switch between tauri's `dev` and `build` modes.
+# DO NOT REMOVE!!
+custom-protocol = [ "tauri/custom-protocol" ]

src-tauri/src-tauri/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+  tauri_build::build()
+}

src-tauri/src-tauri/src/main.rs

@@ -0,0 +1,8 @@
+// Prevents additional console window on Windows in release, DO NOT REMOVE!!
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+fn main() {
+  tauri::Builder::default()
+    .run(tauri::generate_context!())
+    .expect("error while running tauri application");
+}

src-tauri/src-tauri/tauri.conf.json

@@ -0,0 +1,65 @@
+{
+  "build": {
+    "beforeBuildCommand": "npm run build",
+    "beforeDevCommand": "npm run dev",
+    "devPath": "http://localhost:4000",
+    "distDir": "../dist"
+  },
+  "package": {
+    "productName": "Tauri App",
+    "version": "0.1.0"
+  },
+  "tauri": {
+    "allowlist": {
+      "all": false
+    },
+    "bundle": {
+      "active": true,
+      "category": "DeveloperTool",
+      "copyright": "",
+      "deb": {
+        "depends": []
+      },
+      "externalBin": [],
+      "icon": [
+        "icons/32x32.png",
+        "icons/128x128.png",
+        "icons/128x128@2x.png",
+        "icons/icon.icns",
+        "icons/icon.ico"
+      ],
+      "identifier": "com.tauri.dev",
+      "longDescription": "",
+      "macOS": {
+        "entitlements": null,
+        "exceptionDomain": "",
+        "frameworks": [],
+        "providerShortName": null,
+        "signingIdentity": null
+      },
+      "resources": [],
+      "shortDescription": "",
+      "targets": "all",
+      "windows": {
+        "certificateThumbprint": null,
+        "digestAlgorithm": "sha256",
+        "timestampUrl": ""
+      }
+    },
+    "security": {
+      "csp": null
+    },
+    "updater": {
+      "active": false
+    },
+    "windows": [
+      {
+        "fullscreen": false,
+        "height": 600,
+        "resizable": true,
+        "title": "Tauri",
+        "width": 800
+      }
+    ]
+  }
+}

src-tauri/src/ambient_light/config.rs

@@ -3,7 +3,6 @@ use std::env::current_dir;
 use display_info::DisplayInfo;
 use paris::{error, info};
 use serde::{Deserialize, Serialize};
-use tauri::api::path::config_dir;
 
 use crate::screenshot::LedSamplePoints;
 
@@ -55,7 +54,7 @@ impl LedStripConfigGroup {
         let displays = DisplayInfo::all()?;
 
         // config path
-        let path = config_dir()
+        let path = dirs::config_dir()
             .unwrap_or(current_dir().unwrap())
             .join(CONFIG_FILE_NAME);
 
@@ -83,7 +82,7 @@ impl LedStripConfigGroup {
     }
 
     pub async fn write_config(configs: &Self) -> anyhow::Result<()> {
-        let path = config_dir()
+        let path = dirs::config_dir()
             .unwrap_or(current_dir().unwrap())
             .join(CONFIG_FILE_NAME);
 

src-tauri/src/ambient_light/config_manager.rs

@@ -1,7 +1,7 @@
 use std::{borrow::BorrowMut, sync::Arc};
 
 use tauri::async_runtime::RwLock;
-use tokio::sync::OnceCell;
+use tokio::{sync::OnceCell, task::yield_now};
 
 use crate::ambient_light::{config, LedStripConfigGroup};
 
@@ -9,7 +9,6 @@ use super::{Border, SamplePointMapper, ColorCalibration};
 
 pub struct ConfigManager {
     config: Arc<RwLock<LedStripConfigGroup>>,
-    config_update_receiver: tokio::sync::watch::Receiver<LedStripConfigGroup>,
     config_update_sender: tokio::sync::watch::Sender<LedStripConfigGroup>,
 }
 
@@ -22,10 +21,12 @@ impl ConfigManager {
                 let (config_update_sender, config_update_receiver) =
                     tokio::sync::watch::channel(configs.clone());
 
-                    config_update_sender.send(configs.clone()).unwrap();
+                    if let Err(err) = config_update_sender.send(configs.clone()) {
+                        log::error!("Failed to send config update when read config first time: {}", err);
+                    }
+                drop(config_update_receiver);
                 ConfigManager {
                     config: Arc::new(RwLock::new(configs)),
-                    config_update_receiver,
                     config_update_sender,
                 }
             })
@@ -46,8 +47,9 @@ impl ConfigManager {
         self.config_update_sender
             .send(configs.clone())
             .map_err(|e| anyhow::anyhow!("Failed to send config update: {}", e))?;
+        yield_now().await;
 
-        // log::info!("config updated: {:?}", configs);
+        log::debug!("config updated: {:?}", configs);
 
         Ok(())
     }
@@ -221,7 +223,7 @@ impl ConfigManager {
     pub fn clone_config_update_receiver(
         &self,
     ) -> tokio::sync::watch::Receiver<LedStripConfigGroup> {
-        self.config_update_receiver.clone()
+        self.config_update_sender.subscribe()
     }
 
     pub async fn set_color_calibration(&self, color_calibration: ColorCalibration) -> anyhow::Result<()> {

src-tauri/src/ambient_light/publisher.rs

@@ -1,4 +1,4 @@
-use std::{collections::HashMap, sync::Arc, time::Duration};
+use std::{borrow::Borrow, collections::HashMap, sync::Arc, time::Duration};
 
 use paris::warn;
 use tauri::async_runtime::RwLock;
@@ -11,8 +11,9 @@ use tokio::{
 use crate::{
     ambient_light::{config, ConfigManager},
     led_color::LedColor,
-    screenshot::LedSamplePoints,
+    rpc::UdpRpc,
-    screenshot_manager::{self, ScreenshotManager}, rpc::UdpRpc,
+    screenshot::{self, LedSamplePoints},
+    screenshot_manager::{self, ScreenshotManager},
 };
 
 use itertools::Itertools;
@@ -48,75 +49,44 @@ impl LedColorsPublisher {
             .await
     }
 
-    fn start_one_display_colors_fetcher(
+    async fn start_one_display_colors_fetcher(
         &self,
         display_id: u32,
-        sample_points: Vec<Vec<LedSamplePoints>>,
+        sample_points: Vec<LedSamplePoints>,
         bound_scale_factor: f32,
         mappers: Vec<SamplePointMapper>,
         display_colors_tx: broadcast::Sender<(u32, Vec<u8>)>,
     ) {
         let internal_tasks_version = self.inner_tasks_version.clone();
+        let screenshot_manager = ScreenshotManager::global().await;
+
+        let screenshot_rx = screenshot_manager.subscribe_by_display_id(display_id).await;
+
+        if let Err(err) = screenshot_rx {
+            log::error!("{}", err);
+            return;
+        }
+        let mut screenshot_rx = screenshot_rx.unwrap();
 
         tokio::spawn(async move {
-            let colors = screenshot_manager::get_display_colors(
-                display_id,
-                &sample_points,
-                bound_scale_factor,
-            );
-
-            if let Err(err) = colors {
-                warn!("Failed to get colors: {}", err);
-                return;
-            }
-
-            let mut interval = tokio::time::interval(Duration::from_millis(33));
             let init_version = internal_tasks_version.read().await.clone();
 
-            loop {
+            while screenshot_rx.changed().await.is_ok() {
-                interval.tick().await;
+                let screenshot = screenshot_rx.borrow().clone();
-                tokio::time::sleep(Duration::from_millis(1)).await;
+                let colors = screenshot.get_colors_by_sample_points(&sample_points).await;
-
-                let version = internal_tasks_version.read().await.clone();
-
-                if version != init_version {
-                    log::info!(
-                        "inner task version changed, stop.  {} != {}",
-                        internal_tasks_version.read().await.clone(),
-                        init_version
-                    );
-
-                    break;
-                }
-
-                let colors = screenshot_manager::get_display_colors(
-                    display_id,
-                    &sample_points,
-                    bound_scale_factor,
-                );
-
-                if let Err(err) = colors {
-                    warn!("Failed to get colors: {}", err);
-                    sleep(Duration::from_millis(100)).await;
-                    continue;
-                }
-
-                let colors: Vec<crate::led_color::LedColor> = colors.unwrap();
 
                 let colors_copy = colors.clone();
 
                 let mappers = mappers.clone();
 
-                tokio::spawn(async move {
+                match Self::send_colors_by_display(colors, mappers).await {
-                    match Self::send_colors_by_display(colors, mappers).await {
+                    Ok(_) => {
-                        Ok(_) => {
+                        // log::info!("sent colors: #{: >15}", display_id);
-                            // log::info!("sent colors: #{: >15}", display_id);
-                        }
-                        Err(err) => {
-                            warn!("Failed to send colors:  #{: >15}\t{}", display_id, err);
-                        }
                     }
-                });
+                    Err(err) => {
+                        warn!("Failed to send colors:  #{: >15}\t{}", display_id, err);
+                    }
+                }
 
                 match display_colors_tx.send((
                     display_id,
@@ -133,6 +103,18 @@ impl LedColorsPublisher {
                         warn!("Failed to send display_colors: {}", err);
                     }
                 };
+
+                // Check if the inner task version changed
+                let version = internal_tasks_version.read().await.clone();
+                if version != init_version {
+                    log::info!(
+                        "inner task version changed, stop.  {} != {}",
+                        internal_tasks_version.read().await.clone(),
+                        init_version
+                    );
+
+                    break;
+                }
             }
         });
     }
@@ -145,7 +127,7 @@ impl LedColorsPublisher {
     ) {
         let sorted_colors_tx = self.sorted_colors_tx.clone();
         let colors_tx = self.colors_tx.clone();
-        log::debug!("start all_colors_worker");
+
 
         tokio::spawn(async move {
             for _ in 0..10 {
@@ -155,7 +137,7 @@ impl LedColorsPublisher {
                 let mut all_colors: Vec<Option<Vec<u8>>> = vec![None; display_ids.len()];
                 let mut start: tokio::time::Instant = tokio::time::Instant::now();
 
-                log::debug!("start all_colors_worker task");
+
                 loop {
                     let color_info = display_colors_rx.recv().await;
 
@@ -204,7 +186,7 @@ impl LedColorsPublisher {
                                 warn!("Failed to send sorted colors: {}", err);
                             }
                         };
-                        log::debug!("tick: {}ms", start.elapsed().as_millis());
+
                         start = tokio::time::Instant::now();
                     }
                 }
@@ -212,58 +194,59 @@ impl LedColorsPublisher {
         });
     }
 
-    pub fn start(&self) {
+    pub async fn start(&self) {
+
+
+        let config_manager = ConfigManager::global().await;
+        let mut config_receiver = config_manager.clone_config_update_receiver();
+        let configs = config_receiver.borrow().clone();
+
+        self.handle_config_change(configs).await;
+
+        while config_receiver.changed().await.is_ok() {
+            let configs = config_receiver.borrow().clone();
+            self.handle_config_change(configs).await;
+        }
+    }
+
+    async fn handle_config_change(&self, configs: LedStripConfigGroup) {
         let inner_tasks_version = self.inner_tasks_version.clone();
+        let configs = Self::get_colors_configs(&configs).await;
 
-        tokio::spawn(async move {
+        if let Err(err) = configs {
-            let publisher = Self::global().await;
+            warn!("Failed to get configs: {}", err);
+            sleep(Duration::from_millis(100)).await;
+            return;
+        }
 
-            let config_manager = ConfigManager::global().await;
+        let configs = configs.unwrap();
-            let mut config_receiver = config_manager.clone_config_update_receiver();
 
-            log::info!("waiting for config update...");
+        let mut inner_tasks_version = inner_tasks_version.write().await;
+        *inner_tasks_version = inner_tasks_version.overflowing_add(1).0;
+        drop(inner_tasks_version);
 
-            while config_receiver.changed().await.is_ok() {
+        let (display_colors_tx, display_colors_rx) = broadcast::channel::<(u32, Vec<u8>)>(8);
-                log::info!("config updated, restart inner tasks...");
-                let configs = config_receiver.borrow().clone();
-                let configs = Self::get_colors_configs(&configs).await;
 
-                if let Err(err) = configs {
+        for sample_point_group in configs.sample_point_groups.clone() {
-                    warn!("Failed to get configs: {}", err);
+            let display_id = sample_point_group.display_id;
-                    sleep(Duration::from_millis(100)).await;
+            let sample_points = sample_point_group.points;
-                    continue;
+            let bound_scale_factor = sample_point_group.bound_scale_factor;
-                }
+            self.start_one_display_colors_fetcher(
+                display_id,
+                sample_points,
+                bound_scale_factor,
+                sample_point_group.mappers,
+                display_colors_tx.clone(),
+            )
+            .await;
+        }
 
-                let configs = configs.unwrap();
+        let display_ids = configs.sample_point_groups;
-
+        self.start_all_colors_worker(
-                let mut inner_tasks_version = inner_tasks_version.write().await;
+            display_ids.iter().map(|c| c.display_id).collect(),
-                *inner_tasks_version = inner_tasks_version.overflowing_add(1).0;
+            configs.mappers,
-                drop(inner_tasks_version);
+            display_colors_rx,
-
+        );
-                let (display_colors_tx, display_colors_rx) =
-                    broadcast::channel::<(u32, Vec<u8>)>(8);
-
-                for sample_point_group in configs.sample_point_groups.clone() {
-                    let display_id = sample_point_group.display_id;
-                    let sample_points = sample_point_group.points;
-                    let bound_scale_factor = sample_point_group.bound_scale_factor;
-                    publisher.start_one_display_colors_fetcher(
-                        display_id,
-                        sample_points,
-                        bound_scale_factor,
-                        sample_point_group.mappers,
-                        display_colors_tx.clone(),
-                    );
-                }
-
-                let display_ids = configs.sample_point_groups;
-                publisher.start_all_colors_worker(
-                    display_ids.iter().map(|c| c.display_id).collect(),
-                    configs.mappers,
-                    display_colors_rx,
-                );
-            }
-        });
     }
 
     pub async fn send_colors(offset: u16, mut payload: Vec<u8>) -> anyhow::Result<()> {
@@ -313,18 +296,50 @@ impl LedColorsPublisher {
             let mut buffer = Vec::<u8>::with_capacity(group_size * 3);
 
             if group.end > group.start {
-                for i in group.pos - display_led_offset..group_size + group.pos - display_led_offset
+                // Prevent integer underflow by using saturating subtraction
-                {
+                let start_index = if group.pos >= display_led_offset {
-                    let bytes = colors[i].as_bytes();
+                    group.pos - display_led_offset
-                    buffer.append(&mut bytes.to_vec());
+                } else {
+                    0
+                };
+                let end_index = if group.pos + group_size >= display_led_offset {
+                    group_size + group.pos - display_led_offset
+                } else {
+                    0
+                };
+
+                for i in start_index..end_index {
+                    if i < colors.len() {
+                        let bytes = colors[i].as_bytes();
+                        buffer.append(&mut bytes.to_vec());
+                    } else {
+                        log::warn!("Index {} out of bounds for colors array of length {}", i, colors.len());
+                        // Add black color as fallback
+                        buffer.append(&mut vec![0, 0, 0]);
+                    }
                 }
             } else {
-                for i in (group.pos - display_led_offset
+                // Prevent integer underflow by using saturating subtraction
-                    ..group_size + group.pos - display_led_offset)
+                let start_index = if group.pos >= display_led_offset {
-                    .rev()
+                    group.pos - display_led_offset
-                {
+                } else {
-                    let bytes = colors[i].as_bytes();
+                    0
-                    buffer.append(&mut bytes.to_vec());
+                };
+                let end_index = if group.pos + group_size >= display_led_offset {
+                    group_size + group.pos - display_led_offset
+                } else {
+                    0
+                };
+
+                for i in (start_index..end_index).rev() {
+                    if i < colors.len() {
+                        let bytes = colors[i].as_bytes();
+                        buffer.append(&mut bytes.to_vec());
+                    } else {
+                        log::warn!("Index {} out of bounds for colors array of length {}", i, colors.len());
+                        // Add black color as fallback
+                        buffer.append(&mut vec![0, 0, 0]);
+                    }
                 }
             }
 
@@ -365,7 +380,7 @@ impl LedColorsPublisher {
         let mut screenshots = HashMap::new();
 
         loop {
-            log::info!("waiting merged screenshot...");
+
             let screenshot = merged_screenshot_receiver.recv().await;
 
             if let Err(err) = screenshot {
@@ -397,11 +412,12 @@ impl LedColorsPublisher {
                         .filter(|(_, c)| c.display_id == display_id);
 
                     let screenshot = screenshots.get(&display_id).unwrap();
-                    log::debug!("screenshot updated: {:?}", display_id);
+
 
                     let points: Vec<_> = led_strip_configs
                         .clone()
                         .map(|(_, config)| screenshot.get_sample_points(&config))
+                        .flatten()
                         .collect();
 
                     if points.len() == 0 {
@@ -426,7 +442,7 @@ impl LedColorsPublisher {
                     led_start = led_end;
                 }
 
-                log::debug!("got all colors configs: {:?}", colors_configs.len());
+
 
                 return Ok(AllColorConfig {
                     sample_point_groups: colors_configs,
@@ -451,7 +467,7 @@ pub struct AllColorConfig {
 #[derive(Debug, Clone)]
 pub struct DisplaySamplePointGroup {
     pub display_id: u32,
-    pub points: Vec<Vec<LedSamplePoints>>,
+    pub points: Vec<LedSamplePoints>,
     pub bound_scale_factor: f32,
     pub mappers: Vec<config::SamplePointMapper>,
 }

src-tauri/src/display/display_handler.rs

@@ -5,18 +5,36 @@ use tokio::sync::RwLock;
 
 use super::DisplayState;
 
+// Safe wrapper for Display that implements Send + Sync
+pub struct SafeDisplay {
+    display: Display,
+}
+
+unsafe impl Send for SafeDisplay {}
+unsafe impl Sync for SafeDisplay {}
+
+impl SafeDisplay {
+    pub fn new(display: Display) -> Self {
+        Self { display }
+    }
+
+    pub fn get_mut(&mut self) -> &mut Display {
+        &mut self.display
+    }
+}
+
 pub struct DisplayHandler {
     pub state: Arc<RwLock<DisplayState>>,
-    pub controller: Arc<RwLock<Display>>,
+    pub controller: Arc<RwLock<SafeDisplay>>,
 }
 
 impl DisplayHandler {
     pub async fn fetch_state(&self) {
         let mut controller = self.controller.write().await;
 
-        let mut temp_state = DisplayState::default();
+        let mut temp_state = self.state.read().await.clone();
 
-        match controller.handle.get_vcp_feature(0x10) {
+        match controller.get_mut().handle.get_vcp_feature(0x10) {
             Ok(value) => {
                 temp_state.max_brightness = value.maximum();
                 temp_state.min_brightness = 0;
@@ -24,7 +42,7 @@ impl DisplayHandler {
             }
             Err(_) => {}
         };
-        match controller.handle.get_vcp_feature(0x12) {
+        match controller.get_mut().handle.get_vcp_feature(0x12) {
             Ok(value) => {
                 temp_state.max_contrast = value.maximum();
                 temp_state.min_contrast = 0;
@@ -32,7 +50,7 @@ impl DisplayHandler {
             }
             Err(_) => {}
         };
-        match controller.handle.get_vcp_feature(0xdc) {
+        match controller.get_mut().handle.get_vcp_feature(0xdc) {
             Ok(value) => {
                 temp_state.max_mode = value.maximum();
                 temp_state.min_mode = 0;
@@ -52,6 +70,7 @@ impl DisplayHandler {
         let mut state = self.state.write().await;
 
         controller
+            .get_mut()
             .handle
             .set_vcp_feature(0x10, brightness)
             .map_err(|err| anyhow::anyhow!("can not set brightness. {:?}", err))?;
@@ -69,6 +88,7 @@ impl DisplayHandler {
         let mut state = self.state.write().await;
 
         controller
+            .get_mut()
             .handle
             .set_vcp_feature(0x12, contrast)
             .map_err(|err| anyhow::anyhow!("can not set contrast. {:?}", err))?;
@@ -84,6 +104,7 @@ impl DisplayHandler {
         let mut state = self.state.write().await;
 
         controller
+            .get_mut()
             .handle
             .set_vcp_feature(0xdc, mode)
             .map_err(|err| anyhow::anyhow!("can not set mode. {:?}", err))?;

src-tauri/src/display/display_state.rs

@@ -34,3 +34,15 @@ impl DisplayState {
         }
     }
 }
+
+#[derive(Clone, Serialize, Deserialize, Debug)]
+pub struct DisplayStateWrapper {
+    pub version: u8,
+    pub states: Vec<DisplayState>,
+}
+
+impl DisplayStateWrapper {
+    pub fn new(states: Vec<DisplayState>) -> Self {
+        Self { version: 1, states }
+    }
+}

src-tauri/src/display/manager.rs

@@ -1,20 +1,27 @@
-use std::{
+use std::{env::current_dir, sync::Arc, time::Duration};
-    sync::Arc,
-    time::{Duration, SystemTime},
-};
 
 use ddc_hi::Display;
 use paris::{error, info, warn};
-use tokio::{sync::{watch, OnceCell, RwLock}, task::yield_now};
+use dirs::config_dir;
+use tokio::{
+    sync::{broadcast, watch, OnceCell, RwLock},
+    task::yield_now,
+};
 
-use crate::rpc::{BoardMessageChannels, DisplaySetting};
+use crate::{
+    display::DisplayStateWrapper,
+    rpc::{BoardMessageChannels, DisplaySetting},
+};
 
-use super::{display_handler::DisplayHandler, display_state::DisplayState};
+use super::{display_handler::{DisplayHandler, SafeDisplay}, display_state::DisplayState};
+
+const CONFIG_FILE_NAME: &str = "cc.ivanli.ambient_light/displays.toml";
 
 pub struct DisplayManager {
     displays: Arc<RwLock<Vec<Arc<RwLock<DisplayHandler>>>>>,
     setting_request_handler: Option<tokio::task::JoinHandle<()>>,
     displays_changed_sender: Arc<watch::Sender<Vec<DisplayState>>>,
+    auto_save_state_handler: Option<tokio::task::JoinHandle<()>>,
 }
 
 impl DisplayManager {
@@ -32,12 +39,45 @@ impl DisplayManager {
             displays: Arc::new(RwLock::new(Vec::new())),
             setting_request_handler: None,
             displays_changed_sender,
+            auto_save_state_handler: None,
         };
         instance.fetch_displays().await;
+        instance.restore_states().await;
+        instance.fetch_state_of_displays().await;
         instance.subscribe_setting_request();
+        instance.auto_save_state_of_displays();
         instance
     }
 
+    fn auto_save_state_of_displays(&mut self) {
+        let displays = self.displays.clone();
+
+        let handler = tokio::spawn(async move {
+            loop {
+                tokio::time::sleep(Duration::from_secs(10)).await;
+                Self::save_states(displays.clone()).await;
+                Self::send_displays_changed(displays.clone()).await;
+            }
+        });
+
+        self.auto_save_state_handler = Some(handler);
+    }
+
+    async fn send_displays_changed(displays: Arc<RwLock<Vec<Arc<RwLock<DisplayHandler>>>>>) {
+        let mut states = Vec::new();
+
+        for display in displays.read().await.iter() {
+            let state = display.read().await.state.read().await.clone();
+            states.push(state);
+        }
+
+        let channel = BoardMessageChannels::global().await;
+        let tx = channel.displays_changed_sender.clone();
+        if let Err(err) = tx.send(states) {
+            error!("Failed to send displays changed: {}", err);
+        }
+    }
+
     async fn fetch_displays(&self) {
         let mut displays = self.displays.write().await;
         displays.clear();
@@ -45,19 +85,27 @@ impl DisplayManager {
         let controllers = Display::enumerate();
 
         for display in controllers {
-            let controller = Arc::new(RwLock::new(display));
+            let safe_display = SafeDisplay::new(display);
+            let controller = Arc::new(RwLock::new(safe_display));
             let state = Arc::new(RwLock::new(DisplayState::default()));
             let handler = DisplayHandler {
                 state: state.clone(),
                 controller: controller.clone(),
             };
 
-            handler.fetch_state().await;
-
             displays.push(Arc::new(RwLock::new(handler)));
         }
     }
 
+    async fn fetch_state_of_displays(&self) {
+        let displays = self.displays.read().await;
+
+        for display in displays.iter() {
+            let display = display.read().await;
+            display.fetch_state().await;
+        }
+    }
+
     pub async fn get_displays(&self) -> Vec<DisplayState> {
         let displays = self.displays.read().await;
         let mut states = Vec::new();
@@ -75,7 +123,22 @@ impl DisplayManager {
             let channels = BoardMessageChannels::global().await;
             let mut request_rx = channels.display_setting_request_sender.subscribe();
 
-            while let Ok(message) = request_rx.recv().await {
+            loop {
+                if let Err(err) = request_rx.recv().await {
+                    match err {
+                        broadcast::error::RecvError::Closed => {
+                            info!("display setting request channel closed");
+                            break;
+                        }
+                        broadcast::error::RecvError::Lagged(_) => {
+                            warn!("display setting request channel lagged");
+                            continue;
+                        }
+                    }
+                }
+
+                let message = request_rx.recv().await.unwrap();
+
                 let displays = displays.write().await;
 
                 let display = displays.get(message.display_index);
@@ -84,7 +147,6 @@ impl DisplayManager {
                     continue;
                 }
 
-
                 let display = display.unwrap().write().await;
                 let result = match message.setting {
                     DisplaySetting::Brightness(value) => display.set_brightness(value as u16).await,
@@ -115,6 +177,93 @@ impl DisplayManager {
         self.setting_request_handler = Some(handler);
     }
 
+    async fn restore_states(&self) {
+        let path = config_dir()
+            .unwrap_or(current_dir().unwrap())
+            .join(CONFIG_FILE_NAME);
+
+        if !path.exists() {
+            log::info!("config file not found: {}. skip read.", path.display());
+            return;
+        }
+
+        let text = std::fs::read_to_string(path);
+        if let Err(err) = text {
+            log::error!("failed to read config file: {}", err);
+            return;
+        }
+
+        let text = text.unwrap();
+        let wrapper = toml::from_str::<DisplayStateWrapper>(&text);
+
+        if let Err(err) = wrapper {
+            log::error!("failed to parse display states file: {}", err);
+            return;
+        }
+
+        let states = wrapper.unwrap().states;
+
+        let displays = self.displays.read().await;
+        for (index, display) in displays.iter().enumerate() {
+            let display = display.read().await;
+            let mut state = display.state.write().await;
+            let saved = states.get(index);
+            if let Some(saved) = saved {
+                state.brightness = saved.brightness;
+                state.contrast = saved.contrast;
+                state.mode = saved.mode;
+                log::info!("restore display config. display#{}: {:?}", index, state);
+            }
+        }
+
+        log::info!(
+            "restore display config. store displays: {}, online displays: {}",
+            states.len(),
+            displays.len()
+        );
+    }
+
+    async fn save_states(displays: Arc<RwLock<Vec<Arc<RwLock<DisplayHandler>>>>>) {
+        let path = config_dir()
+            .unwrap_or(current_dir().unwrap())
+            .join(CONFIG_FILE_NAME);
+
+        let displays = displays.read().await;
+        let mut states = Vec::new();
+        for display in displays.iter() {
+            let state = display.read().await.state.read().await.clone();
+            states.push(state);
+        }
+
+        let wrapper = DisplayStateWrapper::new(states);
+
+        let text = toml::to_string(&wrapper);
+        if let Err(err) = text {
+            log::error!("failed to serialize display states: {}", err);
+            log::error!("display states: {:?}", &wrapper);
+            return;
+        }
+
+        let text = text.unwrap();
+        if path.exists() {
+            if let Err(err) = std::fs::remove_file(&path) {
+                log::error!("failed to remove old config file: {}", err);
+                return;
+            }
+        }
+
+        if let Err(err) = std::fs::write(&path, text) {
+            log::error!("failed to write config file: {}", err);
+            return;
+        }
+
+        log::debug!(
+            "save display config. store displays: {}, online displays: {}",
+            wrapper.states.len(),
+            displays.len()
+        );
+    }
+
     pub fn subscribe_displays_changed(&self) -> watch::Receiver<Vec<DisplayState>> {
         self.displays_changed_sender.subscribe()
     }
@@ -122,8 +271,13 @@ impl DisplayManager {
 
 impl Drop for DisplayManager {
     fn drop(&mut self) {
+        log::info!("dropping display manager=============");
         if let Some(handler) = self.setting_request_handler.take() {
             handler.abort();
         }
+
+        if let Some(handler) = self.auto_save_state_handler.take() {
+            handler.abort();
+        }
     }
 }

src-tauri/src/main.rs

@@ -7,20 +7,23 @@ mod led_color;
 mod rpc;
 mod screenshot;
 mod screenshot_manager;
+mod screen_stream;
 mod volume;
 
 use ambient_light::{Border, ColorCalibration, LedStripConfig, LedStripConfigGroup};
 use display::{DisplayManager, DisplayState};
 use display_info::DisplayInfo;
 use paris::{error, info, warn};
-use rpc::{BoardInfo, MqttRpc, UdpRpc};
+use rpc::{BoardInfo, UdpRpc};
 use screenshot::Screenshot;
 use screenshot_manager::ScreenshotManager;
+
 use serde::{Deserialize, Serialize};
 use serde_json::to_string;
-use tauri::{http::ResponseBuilder, regex, Manager};
+use tauri::{Manager, Emitter, Runtime};
+use regex;
+use tauri::http::{Request, Response};
 use volume::VolumeManager;
-
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "DisplayInfo")]
 struct DisplayInfoDef {
@@ -88,7 +91,7 @@ async fn get_led_strips_sample_points(
     let screenshot_manager = ScreenshotManager::global().await;
     let channels = screenshot_manager.channels.read().await;
     if let Some(rx) = channels.get(&config.display_id) {
-        let rx = rx.clone();
+        let rx = rx.read().await;
         let screenshot = rx.borrow().clone();
         let sample_points = screenshot.get_sample_points(&config);
         Ok(sample_points)
@@ -105,7 +108,7 @@ async fn get_one_edge_colors(
     let screenshot_manager = ScreenshotManager::global().await;
     let channels = screenshot_manager.channels.read().await;
     if let Some(rx) = channels.get(&display_id) {
-        let rx = rx.clone();
+        let rx = rx.read().await;
         let screenshot = rx.borrow().clone();
         let bytes = screenshot.bytes.read().await.to_owned();
         let colors =
@@ -213,21 +216,165 @@ async fn get_displays() -> Vec<DisplayState> {
     display_manager.get_displays().await
 }
 
+// Protocol handler for ambient-light://
+fn handle_ambient_light_protocol<R: Runtime>(
+    _ctx: tauri::UriSchemeContext<R>,
+    request: Request<Vec<u8>>
+) -> Response<Vec<u8>> {
+    let url = request.uri();
+    // info!("Handling ambient-light protocol request: {}", url);
+
+    // Parse the URL to extract parameters
+    let url_str = url.to_string();
+    let re = regex::Regex::new(r"ambient-light://displays/(\d+)\?width=(\d+)&height=(\d+)").unwrap();
+
+    if let Some(captures) = re.captures(&url_str) {
+        let display_id: u32 = captures[1].parse().unwrap_or(0);
+        let width: u32 = captures[2].parse().unwrap_or(400);
+        let height: u32 = captures[3].parse().unwrap_or(300);
+
+        // info!("Efficient screenshot request for display {}, {}x{}", display_id, width, height);
+
+        // Optimized screenshot processing with much smaller intermediate size
+        // info!("Screenshot request received: display_id={}, width={}, height={}", display_id, width, height);
+
+        let screenshot_data = tokio::task::block_in_place(|| {
+            tokio::runtime::Handle::current().block_on(async {
+                let screenshot_manager = ScreenshotManager::global().await;
+                let channels = screenshot_manager.channels.read().await;
+
+                if let Some(rx) = channels.get(&display_id) {
+                    let rx = rx.read().await;
+                    let screenshot = rx.borrow().clone();
+                    let bytes = screenshot.bytes.read().await.to_owned();
+
+                    // Use much smaller intermediate resolution for performance
+                    let intermediate_width = 800;  // Much smaller than original 5120
+                    let intermediate_height = 450; // Much smaller than original 2880
+
+                    // Convert BGRA to RGBA format
+                    let mut rgba_bytes = bytes.as_ref().clone();
+                    for chunk in rgba_bytes.chunks_exact_mut(4) {
+                        chunk.swap(0, 2); // Swap B and R channels
+                    }
+
+                    let image_result = image::RgbaImage::from_raw(
+                        screenshot.width as u32,
+                        screenshot.height as u32,
+                        rgba_bytes,
+                    );
+
+                    if let Some(img) = image_result {
+                        // Step 1: Fast downscale to intermediate size
+                        let intermediate_image = image::imageops::resize(
+                            &img,
+                            intermediate_width,
+                            intermediate_height,
+                            image::imageops::FilterType::Nearest, // Fastest possible
+                        );
+
+                        // Step 2: Scale to final target size
+                        let final_image = if width == intermediate_width && height == intermediate_height {
+                            intermediate_image
+                        } else {
+                            image::imageops::resize(
+                                &intermediate_image,
+                                width,
+                                height,
+                                image::imageops::FilterType::Triangle,
+                            )
+                        };
+
+                        let raw_data = final_image.into_raw();
+                        // info!("Efficient resize completed: {}x{}, {} bytes", width, height, raw_data.len());
+                        Ok(raw_data)
+                    } else {
+                        error!("Failed to create image from raw bytes");
+                        Err("Failed to create image from raw bytes".to_string())
+                    }
+                } else {
+                    error!("Display {} not found", display_id);
+                    Err(format!("Display {} not found", display_id))
+                }
+            })
+        });
+
+        match screenshot_data {
+            Ok(data) => {
+                Response::builder()
+                    .header("Content-Type", "application/octet-stream")
+                    .header("Access-Control-Allow-Origin", "*")
+                    .header("X-Image-Width", width.to_string())
+                    .header("X-Image-Height", height.to_string())
+                    .body(data)
+                    .unwrap_or_else(|_| {
+                        Response::builder()
+                            .status(500)
+                            .body("Failed to build response".as_bytes().to_vec())
+                            .unwrap()
+                    })
+            }
+            Err(e) => {
+                error!("Failed to get screenshot: {}", e);
+                Response::builder()
+                    .status(500)
+                    .body(format!("Error: {}", e).into_bytes())
+                    .unwrap()
+            }
+        }
+    } else {
+        warn!("Invalid ambient-light URL format: {}", url_str);
+        Response::builder()
+            .status(400)
+            .body("Invalid URL format".as_bytes().to_vec())
+            .unwrap()
+    }
+}
+
+
+
 #[tokio::main]
 async fn main() {
     env_logger::init();
 
-    let screenshot_manager = ScreenshotManager::global().await;
+    // Debug: Print available displays
-    screenshot_manager.start().unwrap();
+    match display_info::DisplayInfo::all() {
+        Ok(displays) => {
+            println!("=== AVAILABLE DISPLAYS ===");
+            for (index, display) in displays.iter().enumerate() {
+                println!("  Display {}: ID={}, Scale={}, Width={}, Height={}",
+                    index, display.id, display.scale_factor, display.width, display.height);
+            }
+            println!("=== END DISPLAYS ===");
+        }
+        Err(e) => {
+            println!("Error getting display info: {}", e);
+        }
+    }
 
-    let led_color_publisher = ambient_light::LedColorsPublisher::global().await;
+    tokio::spawn(async move {
-    led_color_publisher.start();
+        let screenshot_manager = ScreenshotManager::global().await;
+        screenshot_manager.start().await.unwrap_or_else(|e| {
+            error!("can not start screenshot manager: {}", e);
+        })
+    });
 
-    let _mqtt = MqttRpc::global().await;
+    tokio::spawn(async move {
+        let led_color_publisher = ambient_light::LedColorsPublisher::global().await;
+        led_color_publisher.start().await;
+    });
+
+    // Start WebSocket server for screen streaming
+    tokio::spawn(async move {
+        if let Err(e) = start_websocket_server().await {
+            error!("Failed to start WebSocket server: {}", e);
+        }
+    });
 
     let _volume = VolumeManager::global().await;
 
     tauri::Builder::default()
+        .plugin(tauri_plugin_shell::init())
         .invoke_handler(tauri::generate_handler![
             greet,
             list_display_info,
@@ -244,139 +391,14 @@ async fn main() {
             get_boards,
             get_displays
         ])
-        .register_uri_scheme_protocol("ambient-light", move |_app, request| {
+        .register_uri_scheme_protocol("ambient-light", handle_ambient_light_protocol)
-            let response = ResponseBuilder::new().header("Access-Control-Allow-Origin", "*");
 
-            let uri = request.uri();
-            let uri = percent_encoding::percent_decode_str(uri)
-                .decode_utf8()
-                .unwrap()
-                .to_string();
 
-            let url = url_build_parse::parse_url(uri.as_str());
-
-            if let Err(err) = url {
-                error!("url parse error: {}", err);
-                return response
-                    .status(500)
-                    .mimetype("text/plain")
-                    .body("Parse uri failed.".as_bytes().to_vec());
-            }
-
-            let url = url.unwrap();
-
-            let re = regex::Regex::new(r"^/displays/(\d+)$").unwrap();
-            let path = url.path;
-            let captures = re.captures(path.as_str());
-
-            if let None = captures {
-                error!("path not matched: {:?}", path);
-                return response
-                    .status(404)
-                    .mimetype("text/plain")
-                    .body("Path Not Found.".as_bytes().to_vec());
-            }
-
-            let captures = captures.unwrap();
-
-            let display_id = captures[1].parse::<u32>().unwrap();
-
-            let bytes = tokio::task::block_in_place(move || {
-                tauri::async_runtime::block_on(async move {
-                    let screenshot_manager = ScreenshotManager::global().await;
-                    let channels = screenshot_manager.channels.read().await;
-                    if let Some(rx) = channels.get(&display_id) {
-                        let rx = rx.clone();
-                        let screenshot = rx.borrow().clone();
-                        let bytes = screenshot.bytes.read().await;
-
-                        let (scale_factor_x, scale_factor_y, width, height) = if url.query.is_some()
-                            && url.query.as_ref().unwrap().contains_key("height")
-                            && url.query.as_ref().unwrap().contains_key("width")
-                        {
-                            let width = url.query.as_ref().unwrap()["width"]
-                                .parse::<u32>()
-                                .map_err(|err| {
-                                    warn!("width parse error: {}", err);
-                                    err
-                                })?;
-                            let height = url.query.as_ref().unwrap()["height"]
-                                .parse::<u32>()
-                                .map_err(|err| {
-                                    warn!("height parse error: {}", err);
-                                    err
-                                })?;
-                            (
-                                screenshot.width as f32 / width as f32,
-                                screenshot.height as f32 / height as f32,
-                                width,
-                                height,
-                            )
-                        } else {
-                            log::debug!("scale by scale_factor");
-                            let scale_factor = screenshot.scale_factor;
-                            (
-                                scale_factor,
-                                scale_factor,
-                                (screenshot.width as f32 / scale_factor) as u32,
-                                (screenshot.height as f32 / scale_factor) as u32,
-                            )
-                        };
-                        log::debug!(
-                            "scale by query. width: {}, height: {}, scale_factor: {}, len: {}",
-                            width,
-                            height,
-                            screenshot.width as f32 / width as f32,
-                            width * height * 4,
-                        );
-
-                        let bytes_per_row = screenshot.bytes_per_row as f32;
-
-                        let mut rgba_buffer = vec![0u8; (width * height * 4) as usize];
-
-                        for y in 0..height {
-                            for x in 0..width {
-                                let offset = ((y as f32) * scale_factor_y).floor() as usize
-                                    * bytes_per_row as usize
-                                    + ((x as f32) * scale_factor_x).floor() as usize * 4;
-                                let b = bytes[offset];
-                                let g = bytes[offset + 1];
-                                let r = bytes[offset + 2];
-                                let a = bytes[offset + 3];
-                                let offset_2 = (y * width + x) as usize * 4;
-                                rgba_buffer[offset_2] = r;
-                                rgba_buffer[offset_2 + 1] = g;
-                                rgba_buffer[offset_2 + 2] = b;
-                                rgba_buffer[offset_2 + 3] = a;
-                            }
-                        }
-
-                        Ok(rgba_buffer.clone())
-                    } else {
-                        anyhow::bail!("Display#{}: not found", display_id);
-                    }
-                })
-            });
-
-            if let Ok(bytes) = bytes {
-                return response
-                    .mimetype("octet/stream")
-                    .status(200)
-                    .body(bytes.to_vec());
-            }
-            let err = bytes.unwrap_err();
-            error!("request screenshot bin data failed: {}", err);
-            return response
-                .mimetype("text/plain")
-                .status(500)
-                .body(err.to_string().into_bytes());
-        })
         .setup(move |app| {
             let app_handle = app.handle().clone();
             tokio::spawn(async move {
                 let config_manager = ambient_light::ConfigManager::global().await;
-                let config_update_receiver = config_manager.clone_config_update_receiver();
+                let mut config_update_receiver = config_manager.clone_config_update_receiver();
-                let mut config_update_receiver = config_update_receiver;
                 loop {
                     if let Err(err) = config_update_receiver.changed().await {
                         error!("config update receiver changed error: {}", err);
@@ -387,7 +409,7 @@ async fn main() {
 
                     let config = config_update_receiver.borrow().clone();
 
-                    app_handle.emit_all("config_changed", config).unwrap();
+                    app_handle.emit("config_changed", config).unwrap();
                 }
             });
 
@@ -404,7 +426,7 @@ async fn main() {
                     let publisher = publisher_update_receiver.borrow().clone();
 
                     app_handle
-                        .emit_all("led_sorted_colors_changed", publisher)
+                        .emit("led_sorted_colors_changed", publisher)
                         .unwrap();
                 }
             });
@@ -422,7 +444,7 @@ async fn main() {
                     let publisher = publisher_update_receiver.borrow().clone();
 
                     app_handle
-                        .emit_all("led_colors_changed", publisher)
+                        .emit("led_colors_changed", publisher)
                         .unwrap();
                 }
             });
@@ -443,7 +465,7 @@ async fn main() {
 
                                 let boards = boards.into_iter().collect::<Vec<_>>();
 
-                                app_handle.emit_all("boards_changed", boards).unwrap();
+                                app_handle.emit("boards_changed", boards).unwrap();
                             }
                         }
                         Err(err) => {
@@ -457,14 +479,14 @@ async fn main() {
             let app_handle = app.handle().clone();
             tokio::spawn(async move {
                 let display_manager = DisplayManager::global().await;
-                let mut rx =display_manager.subscribe_displays_changed();
+                let mut rx = display_manager.subscribe_displays_changed();
 
                 while rx.changed().await.is_ok() {
                     let displays = rx.borrow().clone();
 
                     log::info!("displays changed. emit displays_changed event.");
 
-                    app_handle.emit_all("displays_changed", displays).unwrap();
+                    app_handle.emit("displays_changed", displays).unwrap();
                 }
             });
 
@@ -473,3 +495,30 @@ async fn main() {
         .run(tauri::generate_context!())
         .expect("error while running tauri application");
 }
+
+// WebSocket server for screen streaming
+async fn start_websocket_server() -> anyhow::Result<()> {
+    use tokio::net::TcpListener;
+
+    let listener = TcpListener::bind("127.0.0.1:8765").await?;
+    info!("WebSocket server listening on ws://127.0.0.1:8765");
+
+    while let Ok((stream, addr)) = listener.accept().await {
+        info!("New WebSocket connection from: {}", addr);
+
+        tokio::spawn(async move {
+            info!("Starting WebSocket handler for connection from: {}", addr);
+            match screen_stream::handle_websocket_connection(stream).await {
+                Ok(_) => {
+                    info!("WebSocket connection from {} completed successfully", addr);
+                }
+                Err(e) => {
+                    warn!("WebSocket connection error from {}: {}", addr, e);
+                }
+            }
+            info!("WebSocket handler task completed for: {}", addr);
+        });
+    }
+
+    Ok(())
+}

src-tauri/src/rpc/board.rs

@@ -3,15 +3,22 @@ use std::{sync::Arc, time::Duration};
 use paris::{error, info, warn};
 use tokio::{io, net::UdpSocket, sync::RwLock, task::yield_now, time::timeout};
 
-use crate::rpc::DisplaySettingRequest;
+use crate::{
+    ambient_light::{ConfigManager, LedStripConfig},
+    rpc::DisplaySettingRequest,
+    volume::{self, VolumeManager},
+};
 
-use super::{BoardConnectStatus, BoardInfo};
+use super::{BoardConnectStatus, BoardInfo, BoardMessageChannels};
 
 #[derive(Debug)]
 pub struct Board {
     pub info: Arc<RwLock<BoardInfo>>,
     socket: Option<Arc<UdpSocket>>,
     listen_handler: Option<tokio::task::JoinHandle<()>>,
+    volume_changed_subscriber_handler: Option<tokio::task::JoinHandle<()>>,
+    state_of_displays_changed_subscriber_handler: Option<tokio::task::JoinHandle<()>>,
+    led_strip_config_changed_subscriber_handler: Option<tokio::task::JoinHandle<()>>,
 }
 
 impl Board {
@@ -20,25 +27,23 @@ impl Board {
             info: Arc::new(RwLock::new(info)),
             socket: None,
             listen_handler: None,
+            volume_changed_subscriber_handler: None,
+            state_of_displays_changed_subscriber_handler: None,
+            led_strip_config_changed_subscriber_handler: None,
         }
     }
 
     pub async fn init_socket(&mut self) -> anyhow::Result<()> {
-        let info = self.info.read().await;
+        let info = self.info.clone();
+        let info = info.read().await;
         let socket = UdpSocket::bind("0.0.0.0:0").await?;
 
         socket.connect((info.address, info.port)).await?;
         let socket = Arc::new(socket);
         self.socket = Some(socket.clone());
 
-        let info = self.info.clone();
-
         let handler = tokio::spawn(async move {
             let mut buf = [0u8; 128];
-            if let Err(err) = socket.readable().await {
-                error!("socket read error: {:?}", err);
-                return;
-            }
 
             let board_message_channels = crate::rpc::channels::BoardMessageChannels::global().await;
 
@@ -49,7 +54,7 @@ impl Board {
                 board_message_channels.volume_setting_request_sender.clone();
 
             loop {
-                match socket.try_recv(&mut buf) {
+                match socket.recv(&mut buf).await {
                     Ok(len) => {
                         log::info!("recv: {:?}", &buf[..len]);
                         if buf[0] == 3 {
@@ -64,6 +69,9 @@ impl Board {
                             }
                         } else if buf[0] == 4 {
                             let result = volume_setting_request_sender.send(buf[1] as f32 / 100.0);
+                            if let Err(err) = result {
+                                error!("send volume setting request to channel failed: {:?}", err);
+                            }
                         }
                     }
                     Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
@@ -79,9 +87,156 @@ impl Board {
         });
         self.listen_handler = Some(handler);
 
+        self.subscribe_volume_changed().await;
+        self.subscribe_state_of_displays_changed().await;
+        self.subscribe_led_strip_config_changed().await;
+
         Ok(())
     }
 
+    async fn subscribe_volume_changed(&mut self) {
+        let channel = BoardMessageChannels::global().await;
+        let mut volume_changed_rx = channel.volume_changed_sender.subscribe();
+        let info = self.info.clone();
+        let socket = self.socket.clone();
+
+        let handler = tokio::spawn(async move {
+            loop {
+                let volume: Result<f32, tokio::sync::broadcast::error::RecvError> =
+                    volume_changed_rx.recv().await;
+                if let Err(err) = volume {
+                    match err {
+                        tokio::sync::broadcast::error::RecvError::Closed => {
+                            log::error!("volume changed channel closed");
+                            break;
+                        }
+                        tokio::sync::broadcast::error::RecvError::Lagged(_) => {
+                            log::info!("volume changed channel lagged");
+                            continue;
+                        }
+                    }
+                }
+
+                let volume = volume.unwrap();
+
+                let info = info.read().await;
+                if socket.is_none() || info.connect_status != BoardConnectStatus::Connected {
+                    log::info!("board is not connected, skip send volume changed");
+                    continue;
+                }
+
+                let socket = socket.as_ref().unwrap();
+
+                let mut buf = [0u8; 2];
+                buf[0] = 4;
+                buf[1] = (volume * 100.0) as u8;
+
+                if let Err(err) = socket.send(&buf).await {
+                    log::warn!("send volume changed failed: {:?}", err);
+                }
+            }
+        });
+
+        let volume_manager = VolumeManager::global().await;
+        let volume = volume_manager.get_volume().await;
+
+        if let Some(socket) = self.socket.as_ref() {
+            let buf = [4, (volume * 100.0) as u8];
+            if let Err(err) = socket.send(&buf).await {
+                log::warn!("send volume failed: {:?}", err);
+            }
+        } else {
+            log::warn!("socket is none, skip send volume");
+        }
+
+        self.volume_changed_subscriber_handler = Some(handler);
+    }
+
+    async fn subscribe_state_of_displays_changed(&mut self) {
+        let channel: &BoardMessageChannels = BoardMessageChannels::global().await;
+        let mut state_of_displays_changed_rx = channel.displays_changed_sender.subscribe();
+        let info = self.info.clone();
+        let socket = self.socket.clone();
+
+        let handler = tokio::spawn(async move {
+            loop {
+                let states: Result<
+                    Vec<crate::display::DisplayState>,
+                    tokio::sync::broadcast::error::RecvError,
+                > = state_of_displays_changed_rx.recv().await;
+                if let Err(err) = states {
+                    match err {
+                        tokio::sync::broadcast::error::RecvError::Closed => {
+                            log::error!("state of displays changed channel closed");
+                            break;
+                        }
+                        tokio::sync::broadcast::error::RecvError::Lagged(_) => {
+                            log::info!("state of displays changed channel lagged");
+                            continue;
+                        }
+                    }
+                }
+
+                let info = info.read().await;
+                if socket.is_none() || info.connect_status != BoardConnectStatus::Connected {
+                    log::info!("board is not connected, skip send state of displays changed");
+                    continue;
+                }
+
+                let socket = socket.as_ref().unwrap();
+
+                let mut buf = [0u8; 3];
+                let states = states.unwrap();
+                for (index, state) in states.iter().enumerate() {
+                    buf[0] = 3;
+                    buf[1] = index as u8;
+                    buf[2] = state.brightness as u8;
+
+                    log::info!("send state of displays changed: {:?}", &buf[..]);
+
+                    if let Err(err) = socket.send(&buf).await {
+                        log::warn!("send state of displays changed failed: {:?}", err);
+                    }
+                }
+            }
+        });
+
+        self.state_of_displays_changed_subscriber_handler = Some(handler);
+    }
+
+    async fn subscribe_led_strip_config_changed(&mut self) {
+        let config_manager = ConfigManager::global().await;
+        let mut led_strip_config_changed_rx = config_manager.clone_config_update_receiver();
+        let info = self.info.clone();
+        let socket = self.socket.clone();
+
+        let handler = tokio::spawn(async move {
+            while led_strip_config_changed_rx.changed().await.is_ok() {
+                let config = led_strip_config_changed_rx.borrow().clone();
+
+                let info = info.read().await;
+                if socket.is_none() || info.connect_status != BoardConnectStatus::Connected {
+                    log::info!("board is not connected, skip send led strip config changed");
+                    continue;
+                }
+
+                let socket = socket.as_ref().unwrap();
+
+                let mut buf = [0u8; 4];
+                buf[0] = 5;
+                buf[1..].copy_from_slice(&config.color_calibration.to_bytes());
+
+                log::info!("send led strip config changed: {:?}", &buf[..]);
+
+                if let Err(err) = socket.send(&buf).await {
+                    log::warn!("send led strip config changed failed: {:?}", err);
+                }
+            }
+        });
+
+        self.led_strip_config_changed_subscriber_handler = Some(handler);
+    }
+
     pub async fn send_colors(&self, buf: &[u8]) {
         let info = self.info.read().await;
         if self.socket.is_none() || info.connect_status != BoardConnectStatus::Connected {
@@ -152,12 +307,22 @@ impl Board {
 
 impl Drop for Board {
     fn drop(&mut self) {
+        info!("board drop");
+
         if let Some(handler) = self.listen_handler.take() {
-            info!("aborting listen handler");
+            handler.abort();
-            tokio::task::block_in_place(move || {
+        }
-                handler.abort();
+
-            });
+        if let Some(handler) = self.volume_changed_subscriber_handler.take() {
-            info!("listen handler aborted");
+            handler.abort();
+        }
+
+        if let Some(handler) = self.state_of_displays_changed_subscriber_handler.take() {
+            handler.abort();
+        }
+
+        if let Some(handler) = self.led_strip_config_changed_subscriber_handler.take() {
+            handler.abort();
         }
     }
 }

src-tauri/src/rpc/channels.rs

@@ -2,11 +2,15 @@ use std::sync::Arc;
 
 use tokio::sync::{broadcast, OnceCell};
 
+use crate::display::DisplayState;
+
 use super::DisplaySettingRequest;
 
 pub struct BoardMessageChannels {
     pub display_setting_request_sender: Arc<broadcast::Sender<DisplaySettingRequest>>,
     pub volume_setting_request_sender: Arc<broadcast::Sender<f32>>,
+    pub volume_changed_sender: Arc<broadcast::Sender<f32>>,
+    pub displays_changed_sender: Arc<broadcast::Sender<Vec<DisplayState>>>,
 }
 
 impl BoardMessageChannels {
@@ -23,9 +27,17 @@ impl BoardMessageChannels {
         let (volume_setting_request_sender, _) = broadcast::channel(16);
         let volume_setting_request_sender = Arc::new(volume_setting_request_sender);
 
+        let (volume_changed_sender, _) = broadcast::channel(2);
+        let volume_changed_sender = Arc::new(volume_changed_sender);
+
+        let (displays_changed_sender, _) = broadcast::channel(2);
+        let displays_changed_sender = Arc::new(displays_changed_sender);
+
         Self {
             display_setting_request_sender,
             volume_setting_request_sender,
+            volume_changed_sender,
+            displays_changed_sender,
         }
     }
 }

src-tauri/src/rpc/mod.rs

@@ -1,12 +1,10 @@
 mod board_info;
-mod mqtt;
 mod udp;
 mod board;
 mod display_setting_request;
 mod channels;
 
 pub use board_info::*;
-pub use mqtt::*;
 pub use udp::*;
 pub use board::*;
 pub use display_setting_request::*;

src-tauri/src/rpc/mqtt.rs

@@ -1,163 +0,0 @@
-use paho_mqtt as mqtt;
-use paris::{info, warn};
-use serde_json::json;
-use std::time::Duration;
-use time::{format_description, OffsetDateTime};
-use tokio::{sync::OnceCell, task};
-
-use crate::ambient_light::{ColorCalibration, ConfigManager};
-
-const DISPLAY_TOPIC: &'static str = "display-ambient-light/display";
-const DESKTOP_TOPIC: &'static str = "display-ambient-light/desktop";
-const COLOR_CALIBRATION: &'static str = "display-ambient-light/desktop/color-calibration";
-
-pub struct MqttRpc {
-    client: mqtt::AsyncClient,
-    // change_display_brightness_tx: broadcast::Sender<display::DisplayBrightness>,
-    // message_tx: broadcast::Sender<models::CmdMqMessage>,
-}
-
-impl MqttRpc {
-    pub async fn global() -> &'static Self {
-        static MQTT_RPC: OnceCell<MqttRpc> = OnceCell::const_new();
-
-        MQTT_RPC
-            .get_or_init(|| async {
-                let mqtt_rpc = MqttRpc::new().await.unwrap();
-                mqtt_rpc.initialize().await.unwrap();
-                mqtt_rpc
-            })
-            .await
-    }
-
-    pub async fn new() -> anyhow::Result<Self> {
-        let client = mqtt::AsyncClient::new("tcp://192.168.31.11:1883")
-            .map_err(|err| anyhow::anyhow!("can not create MQTT client. {:?}", err))?;
-
-        client.set_connected_callback(|client| {
-            info!("MQTT server connected.");
-
-            client.subscribe("display-ambient-light/board/#", mqtt::QOS_1);
-
-            client.subscribe(format!("{}/#", DISPLAY_TOPIC), mqtt::QOS_1);
-        });
-        client.set_connection_lost_callback(|_| {
-            info!("MQTT server connection lost.");
-        });
-        client.set_disconnected_callback(|_, a1, a2| {
-            info!("MQTT server disconnected. {:?} {:?}", a1, a2);
-        });
-
-        let mut last_will_payload = serde_json::Map::new();
-        last_will_payload.insert("message".to_string(), json!("offline"));
-        last_will_payload.insert(
-            "time".to_string(),
-            serde_json::Value::String(
-                OffsetDateTime::now_utc()
-                    .format(&time::format_description::well_known::iso8601::Iso8601::DEFAULT)
-                    .unwrap()
-                    .to_string(),
-            ),
-        );
-
-        let last_will = mqtt::Message::new(
-            format!("{}/status", DESKTOP_TOPIC),
-            serde_json::to_string(&last_will_payload)
-                .unwrap()
-                .as_bytes(),
-            mqtt::QOS_1,
-        );
-
-        let connect_options = mqtt::ConnectOptionsBuilder::new()
-            .keep_alive_interval(Duration::from_secs(5))
-            .will_message(last_will)
-            .automatic_reconnect(Duration::from_secs(1), Duration::from_secs(5))
-            .finalize();
-
-        let token = client.connect(connect_options);
-
-        token.await.map_err(|err| {
-            anyhow::anyhow!(
-                "can not connect MQTT server. wait for connect token failed. {:?}",
-                err
-            )
-        })?;
-
-        // let (change_display_brightness_tx, _) =
-        //     broadcast::channel::<display::DisplayBrightness>(16);
-        // let (message_tx, _) = broadcast::channel::<models::CmdMqMessage>(32);
-        Ok(Self { client })
-    }
-
-    pub async fn initialize(&self) -> anyhow::Result<()> {
-        self.broadcast_desktop_online();
-        Self::publish_color_calibration_worker();
-        anyhow::Ok(())
-    }
-
-    fn publish_color_calibration_worker() {
-        tokio::spawn(async move {
-            let mqtt = Self::global().await;
-            let config_manager = ConfigManager::global().await;
-            let mut config_receiver = config_manager.clone_config_update_receiver();
-
-            let config = config_manager.configs().await;
-            if let Err(err) = mqtt
-                .publish_color_calibration(config.color_calibration)
-                .await
-            {
-                warn!("can not publish color calibration. {}", err);
-            }
-
-            while config_receiver.changed().await.is_ok() {
-                let config = config_receiver.borrow().clone();
-                if let Err(err) = mqtt
-                    .publish_color_calibration(config.color_calibration)
-                    .await
-                {
-                    warn!("can not publish color calibration. {}", err);
-                }
-            }
-        });
-    }
-
-    fn broadcast_desktop_online(&self) {
-        let client = self.client.to_owned();
-        task::spawn(async move {
-            loop {
-                match OffsetDateTime::now_utc()
-                    .format(&format_description::well_known::Iso8601::DEFAULT)
-                {
-                    Ok(now_str) => {
-                        let msg = mqtt::Message::new(
-                            "display-ambient-light/desktop/online",
-                            now_str.as_bytes(),
-                            mqtt::QOS_0,
-                        );
-                        match client.publish(msg).await {
-                            Ok(_) => {}
-                            Err(error) => {
-                                warn!("can not publish last online time. {}", error)
-                            }
-                        }
-                    }
-                    Err(error) => {
-                        warn!("can not get time for now. {}", error);
-                    }
-                }
-                tokio::time::sleep(Duration::from_millis(1000)).await;
-            }
-        });
-    }
-
-     pub async fn publish_color_calibration(&self, payload: ColorCalibration) -> anyhow::Result<()> {
-        self.client
-            .publish(mqtt::Message::new(
-                COLOR_CALIBRATION,
-                payload.to_bytes(),
-                mqtt::QOS_1,
-            ))
-            .await
-            .map_err(|error| anyhow::anyhow!("mqtt publish color calibration failed. {}", error))
-    }
-}

src-tauri/src/rpc/udp.rs

@@ -54,7 +54,7 @@ impl UdpRpc {
                 }
             }
         });
-
+                
         let shared_self_for_check = shared_self.clone();
         tokio::spawn(async move {
             shared_self_for_check.check_boards().await;
@@ -99,7 +99,9 @@ impl UdpRpc {
                     }
 
                     if boards.insert(board_info.fullname.clone(), board).is_some() {
-                        info!("added board {:?}", board_info);
+                        info!("replace board {:?}", board_info);
+                    } else {
+                        info!("add board {:?}", board_info);
                     }
 
                     let tx_boards = boards

src-tauri/src/screen_stream.rs

@@ -0,0 +1,520 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use std::io::Cursor;
+
+use anyhow::Result;
+use image::{ImageFormat, RgbaImage};
+use tokio::sync::{broadcast, RwLock};
+use tokio::time::sleep;
+use tokio_tungstenite::{accept_async, tungstenite::Message};
+use futures_util::{SinkExt, StreamExt};
+
+use crate::screenshot::Screenshot;
+use crate::screenshot_manager::ScreenshotManager;
+
+#[derive(Debug, Clone)]
+pub struct StreamConfig {
+    pub display_id: u32,
+    pub target_width: u32,
+    pub target_height: u32,
+    pub quality: u8,  // JPEG quality 1-100
+    pub max_fps: u8,  // Maximum frames per second
+}
+
+impl Default for StreamConfig {
+    fn default() -> Self {
+        Self {
+            display_id: 0,
+            target_width: 320,  // Reduced from 400 for better performance
+            target_height: 180, // Reduced from 225 for better performance
+            quality: 50,  // Reduced from 75 for faster compression
+            max_fps: 15,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct StreamFrame {
+    pub display_id: u32,
+    pub timestamp: Instant,
+    pub jpeg_data: Vec<u8>,
+    pub width: u32,
+    pub height: u32,
+}
+
+pub struct ScreenStreamManager {
+    streams: Arc<RwLock<HashMap<u32, Arc<RwLock<StreamState>>>>>,
+}
+
+struct StreamState {
+    config: StreamConfig,
+    subscribers: Vec<broadcast::Sender<StreamFrame>>,
+    last_frame: Option<StreamFrame>,
+    last_screenshot_hash: Option<u64>,
+    last_force_send: Instant,
+    is_running: bool,
+}
+
+impl ScreenStreamManager {
+    pub fn new() -> Self {
+        Self {
+            streams: Arc::new(RwLock::new(HashMap::new())),
+        }
+    }
+
+    pub async fn start_stream(&self, config: StreamConfig) -> Result<broadcast::Receiver<StreamFrame>> {
+        let display_id = config.display_id;
+        let mut streams = self.streams.write().await;
+
+        if let Some(stream_state) = streams.get(&display_id) {
+            // Stream already exists, just add a new subscriber
+            let mut state = stream_state.write().await;
+            let (tx, rx) = broadcast::channel(10);
+            state.subscribers.push(tx);
+            return Ok(rx);
+        }
+
+        // Create new stream
+        let (tx, rx) = broadcast::channel(10);
+        let stream_state = Arc::new(RwLock::new(StreamState {
+            config: config.clone(),
+            subscribers: vec![tx],
+            last_frame: None,
+            last_screenshot_hash: None,
+            last_force_send: Instant::now(),
+            is_running: false,
+        }));
+
+        streams.insert(display_id, stream_state.clone());
+        drop(streams);
+
+        // Start the stream processing task
+        let streams_ref = self.streams.clone();
+        tokio::spawn(async move {
+            if let Err(e) = Self::run_stream(display_id, streams_ref).await {
+                log::error!("Stream {} error: {}", display_id, e);
+            }
+        });
+
+        Ok(rx)
+    }
+
+    async fn run_stream(display_id: u32, streams: Arc<RwLock<HashMap<u32, Arc<RwLock<StreamState>>>>>) -> Result<()> {
+        log::info!("Starting stream for display_id: {}", display_id);
+
+        let screenshot_manager = ScreenshotManager::global().await;
+
+        // If display_id is 0, try to get the first available display
+        let actual_display_id = if display_id == 0 {
+            // Get available displays and use the first one
+            let displays = display_info::DisplayInfo::all().map_err(|e| anyhow::anyhow!("Failed to get displays: {}", e))?;
+            if displays.is_empty() {
+                return Err(anyhow::anyhow!("No displays available"));
+            }
+            log::info!("Using first available display: {}", displays[0].id);
+            displays[0].id
+        } else {
+            display_id
+        };
+
+        log::info!("Attempting to subscribe to display_id: {}", actual_display_id);
+        let screenshot_rx = match screenshot_manager.subscribe_by_display_id(actual_display_id).await {
+            Ok(rx) => {
+                log::info!("Successfully subscribed to display_id: {}", actual_display_id);
+                rx
+            }
+            Err(e) => {
+                log::error!("Failed to subscribe to display_id {}: {}", actual_display_id, e);
+                return Err(e);
+            }
+        };
+        let mut screenshot_rx = screenshot_rx;
+
+        // Mark stream as running
+        {
+            let streams_lock = streams.read().await;
+            if let Some(stream_state) = streams_lock.get(&display_id) {
+                let mut state = stream_state.write().await;
+                state.is_running = true;
+            }
+        }
+
+        let mut last_process_time = Instant::now();
+
+        loop {
+            // Check if stream still has subscribers and is still running
+            let should_continue = {
+                let streams_lock = streams.read().await;
+                if let Some(stream_state) = streams_lock.get(&display_id) {
+                    let state = stream_state.read().await;
+                    !state.subscribers.is_empty() && state.is_running
+                } else {
+                    false
+                }
+            };
+
+            if !should_continue {
+                break;
+            }
+
+            // Wait for new screenshot
+            if let Ok(_) = screenshot_rx.changed().await {
+                let screenshot = screenshot_rx.borrow().clone();
+                
+                // Rate limiting based on max_fps
+                let config = {
+                    let streams_lock = streams.read().await;
+                    if let Some(stream_state) = streams_lock.get(&display_id) {
+                        let state = stream_state.read().await;
+                        state.config.clone()
+                    } else {
+                        break;
+                    }
+                };
+
+                let min_interval = Duration::from_millis(1000 / config.max_fps as u64);
+                let elapsed = last_process_time.elapsed();
+                if elapsed < min_interval {
+                    sleep(min_interval - elapsed).await;
+                }
+
+                // Process screenshot into JPEG frame
+                if let Ok(frame) = Self::process_screenshot(&screenshot, &config).await {
+                    last_process_time = Instant::now();
+                    
+                    // Check if frame content changed (simple hash comparison) or force send
+                    let frame_hash = Self::calculate_frame_hash(&frame.jpeg_data);
+                    let should_send = {
+                        let streams_lock = streams.read().await;
+                        if let Some(stream_state) = streams_lock.get(&display_id) {
+                            let mut state = stream_state.write().await;
+                            let changed = state.last_screenshot_hash.map_or(true, |hash| hash != frame_hash);
+                            let elapsed_ms = state.last_force_send.elapsed().as_millis();
+                            let force_send = elapsed_ms > 500; // Force send every 500ms for better CPU performance
+
+                            if changed || force_send {
+                                state.last_screenshot_hash = Some(frame_hash);
+                                state.last_frame = Some(frame.clone());
+                                if force_send {
+                                    state.last_force_send = Instant::now();
+                                }
+                            }
+                            changed || force_send
+                        } else {
+                            false
+                        }
+                    };
+
+                    if should_send {
+                        // Send to all subscribers
+                        let streams_lock = streams.read().await;
+                        if let Some(stream_state) = streams_lock.get(&display_id) {
+                            let state = stream_state.read().await;
+                            for tx in state.subscribers.iter() {
+                                if let Err(_) = tx.send(frame.clone()) {
+                                    log::warn!("Failed to send frame to subscriber for display_id: {}", display_id);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // Mark stream as stopped
+        {
+            let streams_lock = streams.read().await;
+            if let Some(stream_state) = streams_lock.get(&display_id) {
+                let mut state = stream_state.write().await;
+                state.is_running = false;
+            }
+        }
+
+        Ok(())
+    }
+
+    async fn process_screenshot(screenshot: &Screenshot, config: &StreamConfig) -> Result<StreamFrame> {
+        let total_start = Instant::now();
+        let bytes = screenshot.bytes.read().await;
+
+        // Convert BGRA to RGBA using unsafe with optimized batch processing for maximum performance
+        let mut rgba_bytes = bytes.as_ref().clone();
+        unsafe {
+            let ptr = rgba_bytes.as_mut_ptr() as *mut u32;
+            let len = rgba_bytes.len() / 4;
+
+            // Process in larger chunks of 64 for better cache efficiency and loop unrolling
+            let chunk_size = 64;
+            let full_chunks = len / chunk_size;
+            let remainder = len % chunk_size;
+
+            // Process full chunks with manual loop unrolling
+            for chunk_idx in 0..full_chunks {
+                let base_ptr = ptr.add(chunk_idx * chunk_size);
+
+                // Unroll the inner loop for better performance
+                for i in (0..chunk_size).step_by(4) {
+                    // Process 4 pixels at once
+                    let p0 = base_ptr.add(i).read();
+                    let p1 = base_ptr.add(i + 1).read();
+                    let p2 = base_ptr.add(i + 2).read();
+                    let p3 = base_ptr.add(i + 3).read();
+
+                    // BGRA (0xAABBGGRR) -> RGBA (0xAAGGBBRR)
+                    let s0 = (p0 & 0xFF00FF00) | ((p0 & 0x00FF0000) >> 16) | ((p0 & 0x000000FF) << 16);
+                    let s1 = (p1 & 0xFF00FF00) | ((p1 & 0x00FF0000) >> 16) | ((p1 & 0x000000FF) << 16);
+                    let s2 = (p2 & 0xFF00FF00) | ((p2 & 0x00FF0000) >> 16) | ((p2 & 0x000000FF) << 16);
+                    let s3 = (p3 & 0xFF00FF00) | ((p3 & 0x00FF0000) >> 16) | ((p3 & 0x000000FF) << 16);
+
+                    base_ptr.add(i).write(s0);
+                    base_ptr.add(i + 1).write(s1);
+                    base_ptr.add(i + 2).write(s2);
+                    base_ptr.add(i + 3).write(s3);
+                }
+            }
+
+            // Process remaining pixels
+            let remainder_start = full_chunks * chunk_size;
+            for i in 0..remainder {
+                let idx = remainder_start + i;
+                let pixel = ptr.add(idx).read();
+                let swapped = (pixel & 0xFF00FF00) | ((pixel & 0x00FF0000) >> 16) | ((pixel & 0x000000FF) << 16);
+                ptr.add(idx).write(swapped);
+            }
+        }
+
+        // Create image from raw bytes
+        let img = RgbaImage::from_raw(
+            screenshot.width,
+            screenshot.height,
+            rgba_bytes,
+        ).ok_or_else(|| anyhow::anyhow!("Failed to create image from raw bytes"))?;
+
+        // Resize if needed
+        let final_img = if screenshot.width != config.target_width || screenshot.height != config.target_height {
+            image::imageops::resize(
+                &img,
+                config.target_width,
+                config.target_height,
+                image::imageops::FilterType::Nearest, // Fastest filter for real-time streaming
+            )
+        } else {
+            img
+        };
+
+        // Convert to JPEG
+        let mut jpeg_buffer = Vec::new();
+        let mut cursor = Cursor::new(&mut jpeg_buffer);
+
+        let rgb_img = image::DynamicImage::ImageRgba8(final_img).to_rgb8();
+        rgb_img.write_to(&mut cursor, ImageFormat::Jpeg)?;
+
+        let total_duration = total_start.elapsed();
+        log::debug!("Screenshot processed for display {} in {}ms, JPEG size: {} bytes",
+                   config.display_id, total_duration.as_millis(), jpeg_buffer.len());
+
+        Ok(StreamFrame {
+            display_id: config.display_id,
+            timestamp: Instant::now(),
+            jpeg_data: jpeg_buffer,
+            width: config.target_width,
+            height: config.target_height,
+        })
+    }
+
+    fn calculate_frame_hash(data: &[u8]) -> u64 {
+        use std::collections::hash_map::DefaultHasher;
+        use std::hash::{Hash, Hasher};
+
+        let mut hasher = DefaultHasher::new();
+        // Sample every 100th byte for better sensitivity (was 1000)
+        for (i, &byte) in data.iter().enumerate() {
+            if i % 100 == 0 {
+                byte.hash(&mut hasher);
+            }
+        }
+        hasher.finish()
+    }
+
+    pub async fn stop_stream(&self, display_id: u32) {
+        log::info!("Stopping stream for display_id: {}", display_id);
+        let mut streams = self.streams.write().await;
+
+        if let Some(stream_state) = streams.get(&display_id) {
+            // Mark stream as not running to stop the processing task
+            let mut state = stream_state.write().await;
+            state.is_running = false;
+            log::info!("Marked stream as not running for display_id: {}", display_id);
+        }
+
+        // Remove the stream from the map
+        streams.remove(&display_id);
+        log::info!("Removed stream from manager for display_id: {}", display_id);
+    }
+}
+
+// Global instance
+static SCREEN_STREAM_MANAGER: tokio::sync::OnceCell<ScreenStreamManager> = tokio::sync::OnceCell::const_new();
+
+impl ScreenStreamManager {
+    pub async fn global() -> &'static Self {
+        SCREEN_STREAM_MANAGER.get_or_init(|| async {
+            ScreenStreamManager::new()
+        }).await
+    }
+}
+
+// WebSocket handler for screen streaming
+pub async fn handle_websocket_connection(
+    stream: tokio::net::TcpStream,
+) -> Result<()> {
+    log::info!("Accepting WebSocket connection...");
+
+    let ws_stream = match accept_async(stream).await {
+        Ok(ws) => {
+            log::info!("WebSocket handshake completed successfully");
+            ws
+        }
+        Err(e) => {
+            log::error!("WebSocket handshake failed: {}", e);
+            return Err(e.into());
+        }
+    };
+    let (ws_sender, mut ws_receiver) = ws_stream.split();
+
+    log::info!("WebSocket connection established, waiting for configuration...");
+
+    // Wait for the first configuration message
+    let config = loop {
+        // Add timeout to prevent hanging
+        let timeout_duration = tokio::time::Duration::from_secs(10);
+        match tokio::time::timeout(timeout_duration, ws_receiver.next()).await {
+            Ok(Some(msg)) => {
+                match msg {
+                Ok(Message::Text(text)) => {
+                    log::info!("Received configuration message: {}", text);
+
+                    if let Ok(config_json) = serde_json::from_str::<serde_json::Value>(&text) {
+                        // Parse configuration from JSON
+                        let display_id = config_json.get("display_id")
+                            .and_then(|v| v.as_u64())
+                            .unwrap_or(0) as u32;
+                        let width = config_json.get("width")
+                            .and_then(|v| v.as_u64())
+                            .unwrap_or(320) as u32;  // Reduced from 400 for better performance
+                        let height = config_json.get("height")
+                            .and_then(|v| v.as_u64())
+                            .unwrap_or(180) as u32;  // Reduced from 225 for better performance
+                        let quality = config_json.get("quality")
+                            .and_then(|v| v.as_u64())
+                            .unwrap_or(50) as u8;  // Reduced from 75 for faster compression
+
+                        let config = StreamConfig {
+                            display_id,
+                            target_width: width,
+                            target_height: height,
+                            quality,
+                            max_fps: 15,
+                        };
+
+                        log::info!("Parsed stream config: display_id={}, width={}, height={}, quality={}",
+                                  display_id, width, height, quality);
+                        break config;
+                    } else {
+                        log::warn!("Failed to parse configuration JSON: {}", text);
+                    }
+                }
+                Ok(Message::Close(_)) => {
+                    log::info!("WebSocket connection closed before configuration");
+                    return Ok(());
+                }
+                Err(e) => {
+                    log::warn!("WebSocket error while waiting for config: {}", e);
+                    return Err(e.into());
+                }
+                _ => {}
+                }
+            }
+            Ok(None) => {
+                log::warn!("WebSocket connection closed while waiting for configuration");
+                return Ok(());
+            }
+            Err(_) => {
+                log::warn!("Timeout waiting for WebSocket configuration message");
+                return Err(anyhow::anyhow!("Timeout waiting for configuration"));
+            }
+        }
+    };
+
+    // Start the stream with the received configuration
+    log::info!("Starting stream with config: display_id={}, width={}, height={}",
+               config.display_id, config.target_width, config.target_height);
+    let stream_manager = ScreenStreamManager::global().await;
+    let display_id_for_cleanup = config.display_id;
+    let mut frame_rx = match stream_manager.start_stream(config).await {
+        Ok(rx) => {
+            log::info!("Screen stream started successfully");
+            rx
+        }
+        Err(e) => {
+            log::error!("Failed to start screen stream: {}", e);
+            return Err(e);
+        }
+    };
+
+    // Handle incoming WebSocket messages (for control)
+    let ws_sender = Arc::new(tokio::sync::Mutex::new(ws_sender));
+    let ws_sender_clone = ws_sender.clone();
+
+    // Task to handle outgoing frames
+    let frame_task = tokio::spawn(async move {
+        while let Ok(frame) = frame_rx.recv().await {
+            let mut sender = ws_sender_clone.lock().await;
+            match sender.send(Message::Binary(frame.jpeg_data)).await {
+                Ok(_) => {},
+                Err(e) => {
+                    log::warn!("Failed to send frame: {}", e);
+                    break;
+                }
+            }
+        }
+        log::info!("Frame sending task completed");
+    });
+
+    // Task to handle incoming messages
+    let control_task = tokio::spawn(async move {
+        while let Some(msg) = ws_receiver.next().await {
+            match msg {
+                Ok(Message::Text(text)) => {
+                    log::info!("Received control message: {}", text);
+                    // Additional configuration updates could be handled here
+                }
+                Ok(Message::Close(_)) => {
+                    log::info!("WebSocket connection closed");
+                    break;
+                }
+                Err(e) => {
+                    log::warn!("WebSocket error: {}", e);
+                    break;
+                }
+                _ => {}
+            }
+        }
+        log::info!("Control message task completed");
+    });
+
+    // Wait for either task to complete
+    tokio::select! {
+        _ = frame_task => {},
+        _ = control_task => {},
+    }
+
+    // Clean up resources when connection ends
+    log::info!("WebSocket connection ending, cleaning up resources for display_id: {}", display_id_for_cleanup);
+    let stream_manager = ScreenStreamManager::global().await;
+    stream_manager.stop_stream(display_id_for_cleanup).await;
+
+    log::info!("WebSocket connection handler completed");
+    Ok(())
+}

src-tauri/src/screenshot.rs

@@ -1,5 +1,6 @@
 
-use std::iter;
+use std::fmt::Formatter;
+use std::{iter, fmt::Debug};
 use std::sync::Arc;
 
 use serde::{Deserialize, Serialize};
@@ -7,17 +8,30 @@ use tauri::async_runtime::RwLock;
 
 use crate::{ambient_light::LedStripConfig, led_color::LedColor};
 
-#[derive(Debug, Clone)]
+#[derive(Clone)]
 pub struct Screenshot {
     pub display_id: u32,
     pub height: u32,
     pub width: u32,
     pub bytes_per_row: usize,
-    pub bytes: Arc<RwLock<Vec<u8>>>,
+    pub bytes: Arc<RwLock<Arc<Vec<u8>>>>,
     pub scale_factor: f32,
     pub bound_scale_factor: f32,
 }
 
+impl Debug for Screenshot {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Screenshot")
+            .field("display_id", &self.display_id)
+            .field("height", &self.height)
+            .field("width", &self.width)
+            .field("bytes_per_row", &self.bytes_per_row)
+            .field("scale_factor", &self.scale_factor)
+            .field("bound_scale_factor", &self.bound_scale_factor)
+            .finish()
+    }
+}
+
 static SINGLE_AXIS_POINTS: usize = 5;
 
 impl Screenshot {
@@ -26,7 +40,7 @@ impl Screenshot {
         height: u32,
         width: u32,
         bytes_per_row: usize,
-        bytes: Vec<u8>,
+        bytes: Arc<Vec<u8>>,
         scale_factor: f32,
         bound_scale_factor: f32,
     ) -> Self {
@@ -131,9 +145,16 @@ impl Screenshot {
             for (x, y) in led_points {
                 // log::info!("x: {}, y: {}, bytes_per_row: {}", x, y, bytes_per_row);
                 let position = x * 4 + y * bytes_per_row;
-                b += bitmap[position] as f64;
+
-                g += bitmap[position + 1] as f64;
+                // Add bounds checking to prevent index out of bounds
-                r += bitmap[position + 2] as f64;
+                if position + 2 < bitmap.len() {
+                    b += bitmap[position] as f64;
+                    g += bitmap[position + 1] as f64;
+                    r += bitmap[position + 2] as f64;
+                } else {
+                    // Skip invalid positions or use default values
+                    log::warn!("Invalid pixel position: x={}, y={}, position={}, bitmap_len={}", x, y, position, bitmap.len());
+                }
             }
             let color = LedColor::new((r / len) as u8, (g / len) as u8, (b / len) as u8);
             colors.push(color);
@@ -155,9 +176,16 @@ impl Screenshot {
             for (x, y) in led_points {
                 // log::info!("x: {}, y: {}, bytes_per_row: {}", x, y, bytes_per_row);
                 let position = x * 4 + y * bytes_per_row;
-                b += bitmap[position] as f64;
+
-                g += bitmap[position + 1] as f64;
+                // Add bounds checking to prevent index out of bounds
-                r += bitmap[position + 2] as f64;
+                if position + 2 < bitmap.len() as usize {
+                    b += bitmap[position] as f64;
+                    g += bitmap[position + 1] as f64;
+                    r += bitmap[position + 2] as f64;
+                } else {
+                    // Skip invalid positions or use default values
+                    log::warn!("Invalid pixel position in CG image: x={}, y={}, position={}, bitmap_len={}", x, y, position, bitmap.len());
+                }
                 // log::info!("position: {}, total: {}", position, bitmap.len());
             }
             let color = LedColor::new((r / len) as u8, (g / len) as u8, (b / len) as u8);

src-tauri/src/screenshot_manager.rs

@@ -1,57 +1,28 @@
+use std::time::Duration;
 use std::{collections::HashMap, sync::Arc};
 
 use core_graphics::display::{
     kCGNullWindowID, kCGWindowImageDefault, kCGWindowListOptionOnScreenOnly, CGDisplay,
 };
 use core_graphics::geometry::{CGPoint, CGRect, CGSize};
-use paris::warn;
+use paris::{info, warn};
+use screen_capture_kit::shareable_content::{SCDisplay, SCShareableContent};
+use screen_capture_kit::stream::{SCStream, SCStreamConfiguration, SCContentFilter, SCStreamOutput};
+use screen_capture_kit::stream::SCStreamDelegate;
 use tauri::async_runtime::RwLock;
 use tokio::sync::{broadcast, watch, OnceCell};
-use tokio::time::{self, Duration};
+use tokio::task::yield_now;
+use tokio::time::sleep;
 
 use crate::screenshot::LedSamplePoints;
 use crate::{ambient_light::SamplePointMapper, led_color::LedColor, screenshot::Screenshot};
 
-pub fn take_screenshot(display_id: u32, scale_factor: f32) -> anyhow::Result<Screenshot> {
-    log::debug!("take_screenshot");
-
-    let cg_display = CGDisplay::new(display_id);
-    let cg_image = CGDisplay::screenshot(
-        cg_display.bounds(),
-        kCGWindowListOptionOnScreenOnly,
-        kCGNullWindowID,
-        kCGWindowImageDefault,
-    )
-    .ok_or_else(|| anyhow::anyhow!("Display#{}: take screenshot failed", display_id))?;
-
-    let buffer = cg_image.data();
-    let bytes_per_row = cg_image.bytes_per_row();
-
-    let height = cg_image.height();
-    let width = cg_image.width();
-
-    let bytes = buffer.bytes().to_owned();
-
-    let cg_display = CGDisplay::new(display_id);
-    let bound_scale_factor = (cg_display.bounds().size.width / width as f64) as f32;
-
-    Ok(Screenshot::new(
-        display_id,
-        height as u32,
-        width as u32,
-        bytes_per_row,
-        bytes,
-        scale_factor,
-        bound_scale_factor,
-    ))
-}
-
 pub fn get_display_colors(
     display_id: u32,
     sample_points: &Vec<Vec<LedSamplePoints>>,
     bound_scale_factor: f32,
 ) -> anyhow::Result<Vec<LedColor>> {
-    log::debug!("take_screenshot");
+
     let cg_display = CGDisplay::new(display_id);
 
     let mut colors = vec![];
@@ -114,7 +85,7 @@ pub fn get_display_colors(
 }
 
 pub struct ScreenshotManager {
-    pub channels: Arc<RwLock<HashMap<u32, watch::Receiver<Screenshot>>>>,
+    pub channels: Arc<RwLock<HashMap<u32, Arc<RwLock<watch::Sender<Screenshot>>>>>>,
     merged_screenshot_tx: Arc<RwLock<broadcast::Sender<Screenshot>>>,
 }
 
@@ -134,77 +105,141 @@ impl ScreenshotManager {
             .await
     }
 
-    pub fn start(&self) -> anyhow::Result<()> {
+    pub async fn start(&self) -> anyhow::Result<()> {
         let displays = display_info::DisplayInfo::all()?;
-        for display in displays {
+
-            self.start_one(display.id, display.scale_factor)?;
+        log::info!("ScreenshotManager starting with {} displays:", displays.len());
+        for display in &displays {
+            log::info!("  Display ID: {}, Scale: {}", display.id, display.scale_factor);
         }
-        Ok(())
-    }
 
-    fn start_one(&self, display_id: u32, scale_factor: f32) -> anyhow::Result<()> {
+        let futures = displays.iter().map(|display| async {
-        let channels = self.channels.to_owned();
+            self.start_one(display.id, display.scale_factor)
-        let merged_screenshot_tx = self.merged_screenshot_tx.clone();
+                .await
-        tokio::spawn(async move {
+                .unwrap_or_else(|err| {
-            let screenshot = take_screenshot(display_id, scale_factor);
+                    warn!("start_one failed: display_id: {}, err: {}", display.id, err);
+                });
 
-            if screenshot.is_err() {
-                warn!("take_screenshot_loop: {}", screenshot.err().unwrap());
-                return;
-            }
-            let mut interval = time::interval(Duration::from_millis(1000));
-
-            let screenshot = screenshot.unwrap();
-            let (screenshot_tx, screenshot_rx) = watch::channel(screenshot);
-            {
-                let channels = channels.clone();
-                let mut channels = channels.write().await;
-                channels.insert(display_id, screenshot_rx.clone());
-            }
-
-            let merged_screenshot_tx = merged_screenshot_tx.read().await.clone();
-
-            loop {
-                Self::take_screenshot_loop(
-                    display_id,
-                    scale_factor,
-                    &screenshot_tx,
-                    &merged_screenshot_tx,
-                )
-                .await;
-                interval.tick().await;
-                tokio::time::sleep(Duration::from_millis(1)).await;
-            }
         });
 
+        futures::future::join_all(futures).await;
+        log::info!("ScreenshotManager started successfully");
         Ok(())
     }
 
-    async fn take_screenshot_loop(
+    async fn start_one(&self, display_id: u32, scale_factor: f32) -> anyhow::Result<()> {
-        display_id: u32,
+        log::info!("Starting screenshot capture for display_id: {}", display_id);
-        scale_factor: f32,
+
-        screenshot_tx: &watch::Sender<Screenshot>,
+        let merged_screenshot_tx = self.merged_screenshot_tx.clone();
-        merged_screenshot_tx: &broadcast::Sender<Screenshot>,
+
-    ) {
+        let (tx, _) = watch::channel(Screenshot::new(
-        let screenshot = take_screenshot(display_id, scale_factor);
+            display_id,
-        if let Ok(screenshot) = screenshot {
+            0,
-            match merged_screenshot_tx.send(screenshot.clone()) {
+            0,
-                Ok(_) => {
+            0,
-                    log::info!(
+            Arc::new(vec![]),
-                        "take_screenshot_loop: merged_screenshot_tx.send success. display#{}",
+            scale_factor,
-                        display_id
+            scale_factor,
-                    );
+        ));
+        let tx = Arc::new(RwLock::new(tx));
+
+        let mut channels = self.channels.write().await;
+        channels.insert(display_id, tx.clone());
+
+        drop(channels);
+
+
+
+        // Implement screen capture using screen-capture-kit
+        loop {
+            match Self::capture_display_screenshot(display_id, scale_factor).await {
+                Ok(screenshot) => {
+                    let tx_for_send = tx.read().await;
+                    let merged_screenshot_tx = merged_screenshot_tx.write().await;
+
+                    if let Err(err) = merged_screenshot_tx.send(screenshot.clone()) {
+                        // log::warn!("merged_screenshot_tx.send failed: {}", err);
+                    }
+                    if let Err(err) = tx_for_send.send(screenshot.clone()) {
+                        log::warn!("display {} screenshot_tx.send failed: {}", display_id, err);
+                    }
                 }
-                Err(_) => {
+                Err(err) => {
+                    warn!("Failed to capture screenshot for display {}: {}", display_id, err);
+                    // Create a fallback empty screenshot to maintain the interface
+                    let screenshot = Screenshot::new(
+                        display_id,
+                        1080,
+                        1920,
+                        1920 * 4, // Assuming RGBA format
+                        Arc::new(vec![0u8; 1920 * 1080 * 4]),
+                        scale_factor,
+                        scale_factor,
+                    );
+
+                    let tx_for_send = tx.read().await;
+                    let merged_screenshot_tx = merged_screenshot_tx.write().await;
+
+                    if let Err(err) = merged_screenshot_tx.send(screenshot.clone()) {
+                        // log::warn!("merged_screenshot_tx.send failed: {}", err);
+                    }
+                    if let Err(err) = tx_for_send.send(screenshot.clone()) {
+                        log::warn!("display {} screenshot_tx.send failed: {}", display_id, err);
+                    }
                 }
             }
-            screenshot_tx.send(screenshot).unwrap();
+
-            // log::info!("take_screenshot_loop: send success. display#{}", display_id)
+            // Sleep for a frame duration (5 FPS for much better CPU performance)
-        } else {
+            sleep(Duration::from_millis(200)).await;
-            warn!("take_screenshot_loop: {}", screenshot.err().unwrap());
+            yield_now().await;
         }
     }
 
+    async fn capture_display_screenshot(display_id: u32, scale_factor: f32) -> anyhow::Result<Screenshot> {
+        // For now, use the existing CGDisplay approach as a fallback
+        // TODO: Implement proper screen-capture-kit integration
+
+
+        let cg_display = CGDisplay::new(display_id);
+        let bounds = cg_display.bounds();
+
+
+
+        let cg_image = CGDisplay::screenshot(
+            bounds,
+            kCGWindowListOptionOnScreenOnly,
+            kCGNullWindowID,
+            kCGWindowImageDefault,
+        )
+        .ok_or_else(|| anyhow::anyhow!("Display#{}: take screenshot failed - possibly no screen recording permission", display_id))?;
+
+        let bitmap = cg_image.data();
+        let width = cg_image.width() as u32;
+        let height = cg_image.height() as u32;
+        let bytes_per_row = cg_image.bytes_per_row();
+
+
+
+        // Convert CFData to Vec<u8>
+        let data_ptr = bitmap.bytes().as_ptr();
+        let data_len = bitmap.len() as usize;
+        let screenshot_data = unsafe {
+            std::slice::from_raw_parts(data_ptr, data_len).to_vec()
+        };
+
+
+
+        Ok(Screenshot::new(
+            display_id,
+            height,
+            width,
+            bytes_per_row,
+            Arc::new(screenshot_data),
+            scale_factor,
+            scale_factor,
+        ))
+    }
+
     pub fn get_sorted_colors(colors: &Vec<u8>, mappers: &Vec<SamplePointMapper>) -> Vec<u8> {
         let total_leds = mappers
             .iter()
@@ -257,4 +292,16 @@ impl ScreenshotManager {
     pub async fn clone_merged_screenshot_rx(&self) -> broadcast::Receiver<Screenshot> {
         self.merged_screenshot_tx.read().await.subscribe()
     }
+
+    pub async fn subscribe_by_display_id(
+        &self,
+        display_id: u32,
+    ) -> anyhow::Result<watch::Receiver<Screenshot>> {
+        let channels = self.channels.read().await;
+        if let Some(tx) = channels.get(&display_id) {
+            Ok(tx.read().await.subscribe())
+        } else {
+            Err(anyhow::anyhow!("display_id: {} not found", display_id))
+        }
+    }
 }

src-tauri/src/volume/manager.rs

@@ -1,23 +1,22 @@
-use std::{
+use std::{mem, sync::Arc};
-    mem,
-    sync::{Arc, RwLock},
-};
 
 use coreaudio::{
     audio_unit::macos_helpers::get_default_device_id,
     sys::{
         kAudioHardwareServiceDeviceProperty_VirtualMasterVolume, kAudioObjectPropertyScopeOutput,
-        AudioObjectHasProperty, AudioObjectPropertyAddress, AudioObjectSetPropertyData,
+        AudioObjectGetPropertyData, AudioObjectHasProperty, AudioObjectPropertyAddress,
+        AudioObjectSetPropertyData,
     },
 };
 use paris::error;
-use tokio::sync::OnceCell;
+use tokio::sync::{OnceCell, RwLock};
 
 use crate::rpc::BoardMessageChannels;
 
 pub struct VolumeManager {
     current_volume: Arc<RwLock<f32>>,
     handler: Option<tokio::task::JoinHandle<()>>,
+    read_handler: Option<tokio::task::JoinHandle<()>>,
 }
 
 impl VolumeManager {
@@ -33,9 +32,11 @@ impl VolumeManager {
         let mut instance = Self {
             current_volume: Arc::new(RwLock::new(0.0)),
             handler: None,
+            read_handler: None,
         };
 
         instance.subscribe_volume_setting_request();
+        instance.auto_read_volume();
 
         instance
     }
@@ -55,6 +56,36 @@ impl VolumeManager {
         self.handler = Some(handler);
     }
 
+    fn auto_read_volume(&mut self) {
+        let current_volume = self.current_volume.clone();
+
+        let handler = tokio::spawn(async move {
+            let channel = BoardMessageChannels::global().await;
+            let volume_changed_tx = channel.volume_changed_sender.clone();
+            loop {
+                match Self::read_volume() {
+                    Ok(value) => {
+                        let mut volume = current_volume.write().await;
+                        if *volume != value {
+                            if let Err(err) = volume_changed_tx.send(value) {
+                                error!("failed to send volume changed event: {}", err);
+                            }
+                        }
+
+                        *volume = value;
+                    }
+                    Err(err) => {
+                        error!("failed to read volume: {}", err);
+                    }
+                }
+
+                tokio::time::sleep(std::time::Duration::from_secs(10)).await;
+            }
+        });
+
+        self.read_handler = Some(handler);
+    }
+
     fn set_volume(volume: f32) -> anyhow::Result<()> {
         log::debug!("set volume: {}", volume);
 
@@ -98,4 +129,75 @@ impl VolumeManager {
 
         Ok(())
     }
+
+    fn read_volume() -> anyhow::Result<f32> {
+        let device_id = get_default_device_id(false);
+
+        if device_id.is_none() {
+            anyhow::bail!("default audio output device is not found.");
+        }
+
+        let device_id = device_id.unwrap();
+
+        let address = AudioObjectPropertyAddress {
+            mSelector: kAudioHardwareServiceDeviceProperty_VirtualMasterVolume,
+            mScope: kAudioObjectPropertyScopeOutput,
+            mElement: 0,
+        };
+
+        log::debug!("device id: {}", device_id);
+        log::debug!("address: {:?}", address);
+
+        if 0 == unsafe { AudioObjectHasProperty(device_id, &address) } {
+            anyhow::bail!("Can not get audio property");
+        }
+
+        let mut size = mem::size_of::<f32>() as u32;
+
+        let mut volume = 0.0f32;
+
+        let result = unsafe {
+            AudioObjectGetPropertyData(
+                device_id,
+                &address,
+                0,
+                std::ptr::null(),
+                &mut size,
+                &mut volume as *mut f32 as *mut std::ffi::c_void,
+            )
+        };
+
+        if result != 0 {
+            anyhow::bail!("Can not get audio property. result: {}", result);
+        }
+
+        if size != mem::size_of::<f32>() as u32 {
+            anyhow::bail!("Can not get audio property. data size is not matched.");
+        }
+
+        log::debug!("current system volume of primary device: {}", volume);
+
+        Ok(volume)
+    }
+
+    pub async fn get_volume(&self) -> f32 {
+        self.current_volume.read().await.clone()
+    }
+}
+
+impl Drop for VolumeManager {
+    fn drop(&mut self) {
+        log::info!("drop volume manager");
+        if let Some(handler) = self.handler.take() {
+            tokio::task::block_in_place(move || {
+                handler.abort();
+            });
+        }
+
+        if let Some(handler) = self.read_handler.take() {
+            tokio::task::block_in_place(move || {
+                handler.abort();
+            });
+        }
+    }
 }

src-tauri/tauri.conf.json

@@ -1,40 +1,23 @@
 {
+  "$schema": "https://schema.tauri.app/config/2.0.0",
+  "productName": "test-demo",
+  "version": "0.0.1",
+  "identifier": "cc.ivanli.ambient-light.desktop",
   "build": {
     "beforeDevCommand": "pnpm dev",
     "beforeBuildCommand": "pnpm build",
-    "devPath": "http://localhost:1420",
+    "devUrl": "http://localhost:1420",
-    "distDir": "../dist",
+    "frontendDist": "../dist"
-    "withGlobalTauri": false
   },
-  "package": {
+  "app": {
-    "productName": "test-demo",
+    "withGlobalTauri": true,
-    "version": "0.0.1"
-  },
-  "tauri": {
-    "allowlist": {
-      "all": false,
-      "shell": {
-        "all": false,
-        "open": true
-      }
-    },
-    "bundle": {
-      "active": true,
-      "icon": [
-        "icons/32x32.png",
-        "icons/128x128.png",
-        "icons/128x128@2x.png",
-        "icons/icon.icns",
-        "icons/icon.ico"
-      ],
-      "identifier": "cc.ivanli.ambient-light.desktop",
-      "targets": "all"
-    },
     "security": {
-      "csp": null
+      "csp": null,
-    },
+      "assetProtocol": {
-    "updater": {
+        "scope": [
-      "active": false
+          "**"
+        ]
+      }
     },
     "windows": [
       {
@@ -45,5 +28,19 @@
         "height": 600
       }
     ]
+  },
+  "bundle": {
+    "active": true,
+    "icon": [
+      "icons/32x32.png",
+      "icons/128x128.png",
+      "icons/128x128@2x.png",
+      "icons/icon.icns",
+      "icons/icon.ico"
+    ],
+    "targets": "all",
+    "macOS": {
+      "minimumSystemVersion": "13"
+    }
   }
 }

src/App.tsx

@@ -2,7 +2,7 @@ import { Routes, Route } from '@solidjs/router';
 import { LedStripConfiguration } from './components/led-strip-configuration/led-strip-configuration';
 import { WhiteBalance } from './components/white-balance/white-balance';
 import { createEffect } from 'solid-js';
-import { invoke } from '@tauri-apps/api';
+import { invoke } from '@tauri-apps/api/core';
 import { setLedStripStore } from './stores/led-strip.store';
 import { LedStripConfigContainer } from './models/led-strip-config';
 import { InfoIndex } from './components/info/info-index';
@@ -11,29 +11,59 @@ import { DisplayStateIndex } from './components/displays/display-state-index';
 function App() {
   createEffect(() => {
     invoke<LedStripConfigContainer>('read_config').then((config) => {
-      console.log('read config', config);
+      console.log('App: read config', config);
       setLedStripStore({
         strips: config.strips,
         mappers: config.mappers,
         colorCalibration: config.color_calibration,
       });
+    }).catch((error) => {
+      console.error('App: Failed to read config:', error);
     });
   });
 
   return (
-    <div>
+    <div class="min-h-screen bg-base-100" data-theme="dark">
-      <div>
+      {/* Navigation */}
-        <a href="/info">基本信息</a>
+      <div class="navbar bg-base-200 shadow-lg">
-        <a href="/displays">显示器信息</a>
+        <div class="navbar-start">
-        <a href="/led-strips-configuration">灯条配置</a>
+          <div class="dropdown">
-        <a href="/white-balance">白平衡</a>
+            <div tabindex="0" role="button" class="btn btn-ghost lg:hidden">
+              <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 6h16M4 12h8m-8 6h16"></path>
+              </svg>
+            </div>
+            <ul tabindex="0" class="menu menu-sm dropdown-content mt-3 z-[1] p-2 shadow bg-base-100 rounded-box w-52">
+              <li><a href="/info" class="text-base-content">基本信息</a></li>
+              <li><a href="/displays" class="text-base-content">显示器信息</a></li>
+              <li><a href="/led-strips-configuration" class="text-base-content">灯条配置</a></li>
+              <li><a href="/white-balance" class="text-base-content">白平衡</a></li>
+            </ul>
+          </div>
+          <a class="btn btn-ghost text-xl text-primary font-bold">环境光控制</a>
+        </div>
+        <div class="navbar-center hidden lg:flex">
+          <ul class="menu menu-horizontal px-1">
+            <li><a href="/info" class="btn btn-ghost text-base-content hover:text-primary">基本信息</a></li>
+            <li><a href="/displays" class="btn btn-ghost text-base-content hover:text-primary">显示器信息</a></li>
+            <li><a href="/led-strips-configuration" class="btn btn-ghost text-base-content hover:text-primary">灯条配置</a></li>
+            <li><a href="/white-balance" class="btn btn-ghost text-base-content hover:text-primary">白平衡</a></li>
+          </ul>
+        </div>
+        <div class="navbar-end">
+          <div class="badge badge-primary badge-outline">v1.0</div>
+        </div>
       </div>
-      <Routes>
+
-        <Route path="/info" component={InfoIndex} />
+      {/* Main Content */}
-        <Route path="/displays" component={DisplayStateIndex} />
+      <main class="container mx-auto p-4">
-        <Route path="/led-strips-configuration" component={LedStripConfiguration} />
+        <Routes>
-        <Route path="/white-balance" component={WhiteBalance} />
+          <Route path="/info" component={InfoIndex} />
-      </Routes>
+          <Route path="/displays" component={DisplayStateIndex} />
+          <Route path="/led-strips-configuration" component={LedStripConfiguration} />
+          <Route path="/white-balance" component={WhiteBalance} />
+        </Routes>
+      </main>
     </div>
   );
 }

src/components/displays/display-state-card.tsx

@@ -11,26 +11,59 @@ type ItemProps = {
 
 const Item: ParentComponent<ItemProps> = (props) => {
   return (
-    <dl class="flex">
+    <div class="flex justify-between items-center py-1">
-      <dt class="w-20">{props.label}</dt>
+      <dt class="text-sm font-medium text-base-content/70">{props.label}</dt>
-      <dd class="flex-auto">{props.children}</dd>
+      <dd class="text-sm font-mono text-base-content">{props.children}</dd>
-    </dl>
+    </div>
   );
 };
 
 export const DisplayStateCard: Component<DisplayStateCardProps> = (props) => {
   return (
-    <section class="p-2 rounded shadow">
+    <div class="card bg-base-200 shadow-lg hover:shadow-xl transition-shadow duration-200">
-      <Item label="Brightness">{props.state.brightness}</Item>
+      <div class="card-body p-4">
-      <Item label="Max Brightness">{props.state.max_brightness}</Item>
+        <div class="card-title text-base mb-3 flex items-center justify-between">
-      <Item label="Min Brightness">{props.state.min_brightness}</Item>
+          <span>显示器状态</span>
-      <Item label="Contrast">{props.state.contrast}</Item>
+          <div class="badge badge-primary badge-outline">实时</div>
-      <Item label="Max Contrast">{props.state.max_contrast}</Item>
+        </div>
-      <Item label="Min Contrast">{props.state.min_contrast}</Item>
+
-      <Item label="Max Mode">{props.state.max_mode}</Item>
+        <div class="grid grid-cols-1 gap-3">
-      <Item label="Min Mode">{props.state.min_mode}</Item>
+          {/* 亮度信息 */}
-      <Item label="Mode">{props.state.mode}</Item>
+          <div class="bg-base-100 rounded-lg p-3">
-      <Item label="Last Modified At">{props.state.last_modified_at.toISOString()}</Item>
+            <h4 class="text-sm font-semibold text-base-content mb-2">亮度设置</h4>
-    </section>
+            <div class="space-y-1">
+              <Item label="当前亮度">{props.state.brightness}</Item>
+              <Item label="最大亮度">{props.state.max_brightness}</Item>
+              <Item label="最小亮度">{props.state.min_brightness}</Item>
+            </div>
+          </div>
+
+          {/* 对比度信息 */}
+          <div class="bg-base-100 rounded-lg p-3">
+            <h4 class="text-sm font-semibold text-base-content mb-2">对比度设置</h4>
+            <div class="space-y-1">
+              <Item label="当前对比度">{props.state.contrast}</Item>
+              <Item label="最大对比度">{props.state.max_contrast}</Item>
+              <Item label="最小对比度">{props.state.min_contrast}</Item>
+            </div>
+          </div>
+
+          {/* 模式信息 */}
+          <div class="bg-base-100 rounded-lg p-3">
+            <h4 class="text-sm font-semibold text-base-content mb-2">模式设置</h4>
+            <div class="space-y-1">
+              <Item label="当前模式">{props.state.mode}</Item>
+              <Item label="最大模式">{props.state.max_mode}</Item>
+              <Item label="最小模式">{props.state.min_mode}</Item>
+            </div>
+          </div>
+
+          {/* 更新时间 */}
+          <div class="text-xs text-base-content/50 text-center pt-2 border-t border-base-300">
+            最后更新: {props.state.last_modified_at.toLocaleString()}
+          </div>
+        </div>
+      </div>
+    </div>
   );
 };

src/components/displays/display-state-index.tsx

@@ -1,7 +1,7 @@
 import { Component, For, createEffect, createSignal } from 'solid-js';
 import { listen } from '@tauri-apps/api/event';
 import debug from 'debug';
-import { invoke } from '@tauri-apps/api';
+import { invoke } from '@tauri-apps/api/core';
 import { DisplayState, RawDisplayState } from '../../models/display-state.model';
 import { DisplayStateCard } from './display-state-card';
 
@@ -36,17 +36,37 @@ export const DisplayStateIndex: Component = () => {
     };
   });
   return (
-    <ol class="grid sm:grid-cols-1 md:grid-cols-2 lg:grid-cols-3 p-2 gap-2">
+    <div class="space-y-6">
-      <For each={states()}>
+      <div class="flex items-center justify-between">
-        {(state, index) => (
+        <h1 class="text-2xl font-bold text-base-content">显示器状态</h1>
-          <li class="bg-slate-50 text-gray-800 relative border-2 border-slate-50 hover:border-sky-300 focus:border-sky-300 transition">
+        <div class="stats shadow">
-            <DisplayStateCard state={state} />
+          <div class="stat">
-            <span class="absolute left-2 -top-3 bg-sky-300 text-white px-1 py-0.5 text-xs rounded-sm font-mono">
+            <div class="stat-title">显示器数量</div>
-              #{index() + 1}
+            <div class="stat-value text-primary">{states().length}</div>
-            </span>
+          </div>
-          </li>
+        </div>
-        )}
+      </div>
-      </For>
+
-    </ol>
+      <div class="grid grid-cols-1 lg:grid-cols-2 xl:grid-cols-3 gap-6">
+        <For each={states()}>
+          {(state, index) => (
+            <div class="relative">
+              <DisplayStateCard state={state} />
+              <div class="absolute -top-2 -left-2 w-6 h-6 bg-primary text-primary-content rounded-full flex items-center justify-center text-xs font-bold">
+                {index() + 1}
+              </div>
+            </div>
+          )}
+        </For>
+      </div>
+
+      {states().length === 0 && (
+        <div class="text-center py-12">
+          <div class="text-6xl mb-4">🖥️</div>
+          <h3 class="text-lg font-semibold text-base-content mb-2">未检测到显示器</h3>
+          <p class="text-base-content/70">请检查显示器连接状态</p>
+        </div>
+      )}
+    </div>
   );
 };

src/components/info/board-index.tsx

@@ -2,7 +2,7 @@ import { Component, For, createEffect, createSignal } from 'solid-js';
 import { BoardInfo } from '../../models/board-info.model';
 import { listen } from '@tauri-apps/api/event';
 import debug from 'debug';
-import { invoke } from '@tauri-apps/api';
+import { invoke } from '@tauri-apps/api/core';
 import { BoardInfoPanel } from './board-info-panel';
 
 const logger = debug('app:components:info:board-index');
@@ -26,17 +26,37 @@ export const BoardIndex: Component = () => {
     };
   });
   return (
-    <ol class="grid sm:grid-cols-1 md:grid-cols-2 lg:grid-cols-3 p-2 gap-2">
+    <div class="space-y-6">
-      <For each={boards()}>
+      <div class="flex items-center justify-between">
-        {(board, index) => (
+        <h1 class="text-2xl font-bold text-base-content">设备信息</h1>
-          <li class="bg-slate-50 text-gray-800 relative border-2 border-slate-50 hover:border-sky-300 focus:border-sky-300 transition">
+        <div class="stats shadow">
-            <BoardInfoPanel board={board} />
+          <div class="stat">
-            <span class="absolute left-2 -top-3 bg-sky-300 text-white px-1 py-0.5 text-xs rounded-sm font-mono">
+            <div class="stat-title">设备总数</div>
-              #{index() + 1}
+            <div class="stat-value text-primary">{boards().length}</div>
-            </span>
+          </div>
-          </li>
+        </div>
-        )}
+      </div>
-      </For>
+
-    </ol>
+      <div class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
+        <For each={boards()}>
+          {(board, index) => (
+            <div class="relative">
+              <BoardInfoPanel board={board} />
+              <div class="absolute -top-2 -left-2 w-6 h-6 bg-primary text-primary-content rounded-full flex items-center justify-center text-xs font-bold">
+                {index() + 1}
+              </div>
+            </div>
+          )}
+        </For>
+      </div>
+
+      {boards().length === 0 && (
+        <div class="text-center py-12">
+          <div class="text-6xl mb-4">🔍</div>
+          <h3 class="text-lg font-semibold text-base-content mb-2">未发现设备</h3>
+          <p class="text-base-content/70">请检查设备连接状态</p>
+        </div>
+      )}
+    </div>
   );
 };

src/components/info/board-info-panel.tsx

@@ -7,10 +7,10 @@ type ItemProps = {
 
 const Item: ParentComponent<ItemProps> = (props) => {
   return (
-    <dl class="flex">
+    <div class="flex justify-between items-center py-1">
-      <dt class="w-20">{props.label}</dt>
+      <dt class="text-sm font-medium text-base-content/70">{props.label}</dt>
-      <dd class="flex-auto">{props.children}</dd>
+      <dd class="text-sm font-mono text-base-content">{props.children}</dd>
-    </dl>
+    </div>
   );
 };
 
@@ -41,20 +41,31 @@ export const BoardInfoPanel: Component<{ board: BoardInfo }> = (props) => {
     }
   });
 
+  const statusBadgeClass = createMemo(() => {
+    const status = connectStatus();
+    if (status === 'Connected') {
+      return 'badge badge-success badge-sm';
+    } else if (status?.startsWith('Connecting')) {
+      return 'badge badge-warning badge-sm';
+    } else {
+      return 'badge badge-error badge-sm';
+    }
+  });
+
   return (
-    <section class="p-2 rounded shadow">
+    <div class="card bg-base-200 shadow-lg hover:shadow-xl transition-shadow duration-200">
-      <Item label="Host">{props.board.fullname}</Item>
+      <div class="card-body p-4">
-      <Item label="Host">{props.board.host}</Item>
+        <div class="card-title text-base mb-3 flex items-center justify-between">
-      <Item label="Ip Addr">
+          <span class="truncate">{props.board.fullname}</span>
-        <span class="font-mono">{props.board.address}</span>
+          <div class={statusBadgeClass()}>{connectStatus()}</div>
-      </Item>
+        </div>
-      <Item label="Port">
+        <div class="space-y-2">
-        <span class="font-mono">{props.board.port}</span>
+          <Item label="主机名">{props.board.host}</Item>
-      </Item>
+          <Item label="IP地址">{props.board.address}</Item>
-      <Item label="Status">
+          <Item label="端口">{props.board.port}</Item>
-        <span class="font-mono">{connectStatus()}</span>
+          <Item label="延迟">{ttl()}</Item>
-      </Item>
+        </div>
-      <Item label="TTL">{ttl()}</Item>
+      </div>
-    </section>
+    </div>
   );
 };

src/components/led-strip-configuration/display-info-panel.tsx

@@ -7,10 +7,10 @@ type DisplayInfoItemProps = {
 
 export const DisplayInfoItem: ParentComponent<DisplayInfoItemProps> = (props) => {
   return (
-    <dl class="px-3 py-1 flex hover:bg-slate-900/50 gap-2 text-white drop-shadow-[0_2px_2px_rgba(0,0,0,0.8)] rounded">
+    <div class="flex justify-between items-center py-1 px-2 hover:bg-base-300/50 rounded transition-colors">
-      <dt class="uppercase w-1/2 select-all whitespace-nowrap">{props.label}</dt>
+      <dt class="text-sm font-medium text-base-content/80 uppercase">{props.label}</dt>
-      <dd class="select-all w-1/2 whitespace-nowrap">{props.children}</dd>
+      <dd class="text-sm font-mono text-base-content select-all">{props.children}</dd>
-    </dl>
+    </div>
   );
 };
 
@@ -21,22 +21,29 @@ type DisplayInfoPanelProps = {
 export const DisplayInfoPanel: Component<DisplayInfoPanelProps> = (props) => {
   const [localProps, rootProps] = splitProps(props, ['display']);
   return (
-    <section {...rootProps} class={'m-2 flex flex-col gap-1 py-2 ' + rootProps.class}>
+    <div {...rootProps} class={'card bg-base-100/95 backdrop-blur shadow-lg border border-base-300 ' + rootProps.class}>
-      <DisplayInfoItem label="ID">
+      <div class="card-body p-4">
-        <code>{localProps.display.id}</code>
+        <div class="card-title text-sm mb-3 flex items-center justify-between">
-      </DisplayInfoItem>
+          <span class="text-base-content">显示器信息</span>
-      <DisplayInfoItem label="Position">
+          {localProps.display.is_primary && (
-        ({localProps.display.x}, {localProps.display.y})
+            <div class="badge badge-primary badge-sm">主显示器</div>
-      </DisplayInfoItem>
+          )}
-      <DisplayInfoItem label="Size">
+        </div>
-        {localProps.display.width} x {localProps.display.height}
+        <div class="space-y-1">
-      </DisplayInfoItem>
+          <DisplayInfoItem label="ID">
-      <DisplayInfoItem label="Scale Factor">
+            <code class="bg-base-200 px-1 rounded text-xs">{localProps.display.id}</code>
-        {localProps.display.scale_factor}
+          </DisplayInfoItem>
-      </DisplayInfoItem>
+          <DisplayInfoItem label="位置">
-      <DisplayInfoItem label="is Primary">
+            ({localProps.display.x}, {localProps.display.y})
-        {localProps.display.is_primary ? 'True' : 'False'}
+          </DisplayInfoItem>
-      </DisplayInfoItem>
+          <DisplayInfoItem label="尺寸">
-    </section>
+            {localProps.display.width} × {localProps.display.height}
+          </DisplayInfoItem>
+          <DisplayInfoItem label="缩放">
+            {localProps.display.scale_factor}×
+          </DisplayInfoItem>
+        </div>
+      </div>
+    </div>
   );
 };

src/components/led-strip-configuration/display-view.tsx

@@ -6,6 +6,7 @@ import { DisplayInfoPanel } from './display-info-panel';
 import { LedStripPart } from './led-strip-part';
 import { ScreenView } from './screen-view';
 
+
 type DisplayViewProps = {
   display: DisplayInfo;
 };
@@ -23,7 +24,6 @@ export const DisplayView: Component<DisplayViewProps> = (props) => {
   }));
 
   const ledStripConfigs = createMemo(() => {
-    console.log('ledStripConfigs', ledStripStore.strips);
     return ledStripStore.strips.filter((c) => c.display_id === props.display.id);
   });
 

src/components/led-strip-configuration/led-count-control-panel.tsx

@@ -0,0 +1,155 @@
+import { invoke } from '@tauri-apps/api/core';
+import { Component, createMemo, For, JSX, splitProps } from 'solid-js';
+import { DisplayInfo } from '../../models/display-info.model';
+import { ledStripStore } from '../../stores/led-strip.store';
+import { Borders } from '../../constants/border';
+
+type LedCountControlItemProps = {
+  displayId: number;
+  border: Borders;
+  label: string;
+};
+
+const LedCountControlItem: Component<LedCountControlItemProps> = (props) => {
+  const config = createMemo(() => {
+    return ledStripStore.strips.find(
+      (s) => s.display_id === props.displayId && s.border === props.border
+    );
+  });
+
+  const handleDecrease = () => {
+    if (config()) {
+      invoke('patch_led_strip_len', {
+        displayId: props.displayId,
+        border: props.border,
+        deltaLen: -1,
+      }).catch((e) => {
+        console.error(e);
+      });
+    }
+  };
+
+  const handleIncrease = () => {
+    if (config()) {
+      invoke('patch_led_strip_len', {
+        displayId: props.displayId,
+        border: props.border,
+        deltaLen: 1,
+      }).catch((e) => {
+        console.error(e);
+      });
+    }
+  };
+
+  const handleInputChange = (e: Event) => {
+    const target = e.target as HTMLInputElement;
+    const newValue = parseInt(target.value);
+    const currentLen = config()?.len || 0;
+    
+    if (!isNaN(newValue) && newValue >= 0 && newValue <= 1000) {
+      const deltaLen = newValue - currentLen;
+      if (deltaLen !== 0) {
+        invoke('patch_led_strip_len', {
+          displayId: props.displayId,
+          border: props.border,
+          deltaLen: deltaLen,
+        }).catch((e) => {
+          console.error(e);
+          // Reset input value on error
+          target.value = currentLen.toString();
+        });
+      }
+    } else {
+      // Reset invalid input
+      target.value = (config()?.len || 0).toString();
+    }
+  };
+
+  return (
+    <div class="card bg-base-100 border border-base-300/50 p-2">
+      <div class="flex flex-col gap-1">
+        <div class="text-center">
+          <span class="text-xs font-medium text-base-content">
+            {props.label}
+          </span>
+        </div>
+
+        <div class="flex items-center gap-1">
+          <button
+            class="btn btn-xs btn-circle btn-outline flex-shrink-0"
+            onClick={handleDecrease}
+            disabled={!config() || (config()?.len || 0) <= 0}
+            title="减少LED数量"
+          >
+            -
+          </button>
+
+          <input
+            type="number"
+            class="input input-xs flex-1 text-center min-w-0 text-sm font-medium [appearance:textfield] [&::-webkit-outer-spin-button]:appearance-none [&::-webkit-inner-spin-button]:appearance-none"
+            value={config()?.len || 0}
+            min="0"
+            max="1000"
+            onBlur={handleInputChange}
+            onKeyDown={(e) => {
+              if (e.key === 'Enter') {
+                handleInputChange(e);
+              }
+            }}
+          />
+
+          <button
+            class="btn btn-xs btn-circle btn-outline flex-shrink-0"
+            onClick={handleIncrease}
+            disabled={!config() || (config()?.len || 0) >= 1000}
+            title="增加LED数量"
+          >
+            +
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+};
+
+type LedCountControlPanelProps = {
+  display: DisplayInfo;
+} & JSX.HTMLAttributes<HTMLElement>;
+
+export const LedCountControlPanel: Component<LedCountControlPanelProps> = (props) => {
+  const [localProps, rootProps] = splitProps(props, ['display']);
+
+  const borders: { border: Borders; label: string }[] = [
+    { border: 'Top', label: '上' },
+    { border: 'Bottom', label: '下' },
+    { border: 'Left', label: '左' },
+    { border: 'Right', label: '右' },
+  ];
+
+  return (
+    <div {...rootProps} class={'card bg-base-200 shadow-lg border border-base-300 ' + (rootProps.class || '')}>
+      <div class="card-body p-4">
+        <div class="card-title text-base mb-3 flex items-center justify-between">
+          <span>LED数量控制</span>
+          <div class="badge badge-info badge-outline">显示器 {localProps.display.id}</div>
+        </div>
+
+        <div class="grid grid-cols-4 gap-2">
+          <For each={borders}>
+            {(item) => (
+              <LedCountControlItem
+                displayId={localProps.display.id}
+                border={item.border}
+                label={item.label}
+              />
+            )}
+          </For>
+        </div>
+
+        <div class="text-xs text-base-content/50 mt-3 p-2 bg-base-300/50 rounded">
+          💡 提示：点击 +/- 按钮或直接输入数值来调整LED数量（范围：0-1000）
+        </div>
+      </div>
+    </div>
+  );
+};

src/components/led-strip-configuration/led-strip-configuration.tsx

@@ -1,5 +1,5 @@
 import { createEffect, onCleanup } from 'solid-js';
-import { invoke } from '@tauri-apps/api/tauri';
+import { invoke } from '@tauri-apps/api/core';
 import { DisplayView } from './display-view';
 import { DisplayListContainer } from './display-list-container';
 import { displayStore, setDisplayStore } from '../../stores/display.store';
@@ -7,22 +7,31 @@ import { LedStripConfigContainer } from '../../models/led-strip-config';
 import { setLedStripStore } from '../../stores/led-strip.store';
 import { listen } from '@tauri-apps/api/event';
 import { LedStripPartsSorter } from './led-strip-parts-sorter';
+import { LedCountControlPanel } from './led-count-control-panel';
 import { createStore } from 'solid-js/store';
 import {
   LedStripConfigurationContext,
   LedStripConfigurationContextType,
 } from '../../contexts/led-strip-configuration.context';
 
+
 export const LedStripConfiguration = () => {
   createEffect(() => {
     invoke<string>('list_display_info').then((displays) => {
+      const parsedDisplays = JSON.parse(displays);
+      console.log('LedStripConfiguration: Loaded displays:', parsedDisplays);
       setDisplayStore({
-        displays: JSON.parse(displays),
+        displays: parsedDisplays,
       });
+    }).catch((error) => {
+      console.error('LedStripConfiguration: Failed to load displays:', error);
     });
+
     invoke<LedStripConfigContainer>('read_led_strip_configs').then((configs) => {
-      console.log(configs);
+      console.log('LedStripConfiguration: Loaded LED strip configs:', configs);
       setLedStripStore(configs);
+    }).catch((error) => {
+      console.error('LedStripConfiguration: Failed to load LED strip configs:', error);
     });
   });
 
@@ -30,7 +39,6 @@ export const LedStripConfiguration = () => {
   createEffect(() => {
     const unlisten = listen('config_changed', (event) => {
       const { strips, mappers } = event.payload as LedStripConfigContainer;
-      console.log(event.payload);
       setLedStripStore({
         strips,
         mappers,
@@ -92,14 +100,65 @@ export const LedStripConfiguration = () => {
   ];
 
   return (
-    <div>
+    <div class="space-y-6">
+      <div class="flex items-center justify-between">
+        <h1 class="text-2xl font-bold text-base-content">灯条配置</h1>
+        <div class="stats shadow">
+          <div class="stat">
+            <div class="stat-title">显示器数量</div>
+            <div class="stat-value text-primary">{displayStore.displays.length}</div>
+          </div>
+        </div>
+      </div>
+
       <LedStripConfigurationContext.Provider value={ledStripConfigurationContextValue}>
-        <LedStripPartsSorter />
+        {/* LED Strip Sorter Panel */}
-        <DisplayListContainer>
+        <div class="card bg-base-200 shadow-lg">
-          {displayStore.displays.map((display) => {
+          <div class="card-body p-4">
-            return <DisplayView display={display} />;
+            <div class="card-title text-base mb-3">
-          })}
+              <span>灯条排序</span>
-        </DisplayListContainer>
+              <div class="badge badge-info badge-outline">实时预览</div>
+            </div>
+            <LedStripPartsSorter />
+            <div class="text-xs text-base-content/50 mt-2">
+              💡 提示：拖拽灯条段落来调整顺序，双击可反转方向
+            </div>
+          </div>
+        </div>
+
+        {/* Display Configuration Panel */}
+        <div class="card bg-base-200 shadow-lg">
+          <div class="card-body p-4">
+            <div class="card-title text-base mb-3">
+              <span>显示器配置</span>
+              <div class="badge badge-secondary badge-outline">可视化编辑</div>
+            </div>
+            <div class="h-96 mb-4">
+              <DisplayListContainer>
+                {displayStore.displays.map((display) => {
+                  console.log('LedStripConfiguration: Rendering DisplayView for display:', display);
+                  return <DisplayView display={display} />;
+                })}
+              </DisplayListContainer>
+            </div>
+            <div class="text-xs text-base-content/50">
+              💡 提示：悬停显示器查看详细信息，使用下方控制面板调整LED数量
+            </div>
+          </div>
+        </div>
+
+        {/* LED Count Control Panels */}
+        <div class="space-y-4">
+          <div class="flex items-center gap-2 mb-3">
+            <h2 class="text-lg font-semibold text-base-content">LED数量控制</h2>
+            <div class="badge badge-info badge-outline">实时调整</div>
+          </div>
+          <div class="grid grid-cols-1 md:grid-cols-2 gap-4">
+            {displayStore.displays.map((display) => (
+              <LedCountControlPanel display={display} />
+            ))}
+          </div>
+        </div>
       </LedStripConfigurationContext.Provider>
     </div>
   );

src/components/led-strip-configuration/led-strip-part.tsx

@@ -1,4 +1,4 @@
-import { invoke } from '@tauri-apps/api';
+import { invoke } from '@tauri-apps/api/core';
 import {
   Component,
   createEffect,
@@ -34,7 +34,7 @@ export const Pixel: Component<PixelProps> = (props) => {
       title={props.color}
     >
       <div
-        class="absolute top-1/2 -translate-y-1/2 h-2.5 w-2.5 rounded-full ring-1 ring-stone-300"
+        class="absolute top-1/2 -translate-y-1/2 h-2.5 w-2.5 rounded-full ring-1 ring-stone-300/50"
         style={style()}
       />
     </div>
@@ -60,21 +60,44 @@ export const LedStripPart: Component<LedStripPartProps> = (props) => {
     );
 
     if (index === -1) {
+      console.log('🔍 LED: Strip config not found', {
+        displayId: localProps.config.display_id,
+        border: localProps.config.border,
+        availableStrips: ledStripStore.strips.length
+      });
       return;
     }
 
     const mapper = ledStripStore.mappers[index];
     if (!mapper) {
+      console.log('🔍 LED: Mapper not found', { index, mappersCount: ledStripStore.mappers.length });
       return;
     }
 
-    const offset = mapper.pos * 3;
+    const offset = mapper.start * 3;
+
+    console.log('🎨 LED: Updating colors', {
+      displayId: localProps.config.display_id,
+      border: localProps.config.border,
+      stripLength: localProps.config.len,
+      mapperPos: mapper.pos,
+      offset,
+      colorsArrayLength: ledStripStore.colors.length,
+      firstFewColors: Array.from(ledStripStore.colors.slice(offset, offset + 9))
+    });
 
     const colors = new Array(localProps.config.len).fill(null).map((_, i) => {
       const index = offset + i * 3;
-      return `rgb(${ledStripStore.colors[index]}, ${ledStripStore.colors[index + 1]}, ${
+      const r = ledStripStore.colors[index] || 0;
-        ledStripStore.colors[index + 2]
+      const g = ledStripStore.colors[index + 1] || 0;
-      })`;
+      const b = ledStripStore.colors[index + 2] || 0;
+      return `rgb(${r}, ${g}, ${b})`;
+    });
+
+    console.log('🎨 LED: Generated colors', {
+      border: localProps.config.border,
+      colorsCount: colors.length,
+      sampleColors: colors.slice(0, 3)
     });
 
     setColors(colors);
@@ -101,26 +124,14 @@ export const LedStripPart: Component<LedStripPartProps> = (props) => {
     },
   });
 
-  const onWheel = (e: WheelEvent) => {
+
-    if (localProps.config) {
-      invoke('patch_led_strip_len', {
-        displayId: localProps.config.display_id,
-        border: localProps.config.border,
-        deltaLen: e.deltaY > 0 ? 1 : -1,
-      })
-        .then(() => {})
-        .catch((e) => {
-          console.error(e);
-        });
-    }
-  };
 
   return (
     <section
       {...rootProps}
       ref={setAnchor}
       class={
-        'flex rounded-full flex-nowrap justify-around items-center overflow-hidden ' +
+        'flex rounded-full flex-nowrap justify-around items-center overflow-hidden bg-gray-800/20 border border-gray-600/30 min-h-[32px] min-w-[32px] ' +
         rootProps.class
       }
       classList={{
@@ -129,7 +140,7 @@ export const LedStripPart: Component<LedStripPartProps> = (props) => {
           stripConfiguration.selectedStripPart?.displayId ===
             localProps.config?.display_id,
       }}
-      onWheel={onWheel}
+
     >
       <For each={colors()}>{(item) => <Pixel color={item} />}</For>
     </section>

src/components/led-strip-configuration/led-strip-parts-sorter.tsx

@@ -16,7 +16,7 @@ import {
 } from 'solid-js';
 import { LedStripConfig, LedStripPixelMapper } from '../../models/led-strip-config';
 import { ledStripStore } from '../../stores/led-strip.store';
-import { invoke } from '@tauri-apps/api';
+import { invoke } from '@tauri-apps/api/core';
 import { LedStripConfigurationContext } from '../../contexts/led-strip-configuration.context';
 import background from '../../assets/transparent-grid-background.svg?url';
 

src/components/led-strip-configuration/screen-view-websocket.tsx

@@ -0,0 +1,290 @@
+import {
+  Component,
+  createEffect,
+  createSignal,
+  JSX,
+  onCleanup,
+  onMount,
+  splitProps,
+} from 'solid-js';
+import { invoke } from '@tauri-apps/api/core';
+
+type ScreenViewWebSocketProps = {
+  displayId: number;
+  width?: number;
+  height?: number;
+  quality?: number;
+} & JSX.HTMLAttributes<HTMLDivElement>;
+
+export const ScreenViewWebSocket: Component<ScreenViewWebSocketProps> = (props) => {
+  const [localProps, rootProps] = splitProps(props, ['displayId', 'width', 'height', 'quality']);
+  let canvas: HTMLCanvasElement;
+  let root: HTMLDivElement;
+  const [ctx, setCtx] = createSignal<CanvasRenderingContext2D | null>(null);
+
+  const [drawInfo, setDrawInfo] = createSignal({
+    drawX: 0,
+    drawY: 0,
+    drawWidth: 0,
+    drawHeight: 0,
+  });
+
+  const [connectionStatus, setConnectionStatus] = createSignal<'connecting' | 'connected' | 'disconnected' | 'error'>('disconnected');
+  const [frameCount, setFrameCount] = createSignal(0);
+  const [lastFrameTime, setLastFrameTime] = createSignal(0);
+  const [fps, setFps] = createSignal(0);
+
+  let websocket: WebSocket | null = null;
+  let reconnectTimeout: number | null = null;
+  let isMounted = true;
+
+  // Performance monitoring
+  let frameTimestamps: number[] = [];
+
+  const connectWebSocket = () => {
+    if (!isMounted) {
+      console.log('Component not mounted, skipping WebSocket connection');
+      return;
+    }
+
+    const wsUrl = `ws://127.0.0.1:8765`;
+    console.log('Connecting to WebSocket:', wsUrl, 'with displayId:', localProps.displayId);
+
+    setConnectionStatus('connecting');
+    websocket = new WebSocket(wsUrl);
+    websocket.binaryType = 'arraybuffer';
+    console.log('WebSocket object created:', websocket);
+
+    websocket.onopen = () => {
+      console.log('WebSocket connected successfully!');
+      setConnectionStatus('connected');
+
+      // Send initial configuration
+      const config = {
+        display_id: localProps.displayId,
+        width: localProps.width || 320,  // Reduced from 400 for better performance
+        height: localProps.height || 180, // Reduced from 225 for better performance
+        quality: localProps.quality || 50  // Reduced from 75 for faster compression
+      };
+      console.log('Sending WebSocket configuration:', config);
+      websocket?.send(JSON.stringify(config));
+    };
+
+    websocket.onmessage = (event) => {
+      console.log('🔍 WebSocket message received:', {
+        type: typeof event.data,
+        isArrayBuffer: event.data instanceof ArrayBuffer,
+        size: event.data instanceof ArrayBuffer ? event.data.byteLength : 'N/A'
+      });
+
+      if (event.data instanceof ArrayBuffer) {
+        console.log('📦 Processing ArrayBuffer frame, size:', event.data.byteLength);
+        handleJpegFrame(new Uint8Array(event.data));
+      } else {
+        console.log('⚠️ Received non-ArrayBuffer data:', event.data);
+      }
+    };
+
+    websocket.onclose = (event) => {
+      console.log('WebSocket closed:', event.code, event.reason);
+      setConnectionStatus('disconnected');
+      websocket = null;
+      
+      // Auto-reconnect after 2 seconds if component is still mounted
+      if (isMounted && !reconnectTimeout) {
+        reconnectTimeout = window.setTimeout(() => {
+          reconnectTimeout = null;
+          connectWebSocket();
+        }, 2000);
+      }
+    };
+
+    websocket.onerror = (error) => {
+      console.error('WebSocket error:', error);
+      setConnectionStatus('error');
+    };
+  };
+
+  const handleJpegFrame = async (jpegData: Uint8Array) => {
+    const _ctx = ctx();
+    if (!_ctx) return;
+
+    try {
+      // Update performance metrics
+      const now = performance.now();
+      frameTimestamps.push(now);
+      
+      // Keep only last 30 frames for FPS calculation
+      if (frameTimestamps.length > 30) {
+        frameTimestamps = frameTimestamps.slice(-30);
+      }
+      
+      // Calculate FPS
+      if (frameTimestamps.length >= 2) {
+        const timeSpan = frameTimestamps[frameTimestamps.length - 1] - frameTimestamps[0];
+        if (timeSpan > 0) {
+          const currentFps = Math.round((frameTimestamps.length - 1) * 1000 / timeSpan);
+          setFps(Math.max(0, currentFps)); // Ensure FPS is never negative
+        }
+      }
+
+      setFrameCount(prev => prev + 1);
+      setLastFrameTime(now);
+
+      // Create blob from JPEG data
+      const blob = new Blob([jpegData], { type: 'image/jpeg' });
+      const imageUrl = URL.createObjectURL(blob);
+
+      // Create image element
+      const img = new Image();
+      img.onload = () => {
+        const { drawX, drawY, drawWidth, drawHeight } = drawInfo();
+        
+        // Clear canvas
+        _ctx.clearRect(0, 0, canvas.width, canvas.height);
+        
+        // Draw image
+        _ctx.drawImage(img, drawX, drawY, drawWidth, drawHeight);
+        
+        // Clean up
+        URL.revokeObjectURL(imageUrl);
+      };
+      
+      img.onerror = () => {
+        console.error('Failed to load JPEG image');
+        URL.revokeObjectURL(imageUrl);
+      };
+      
+      img.src = imageUrl;
+
+    } catch (error) {
+      console.error('Error handling JPEG frame:', error);
+    }
+  };
+
+  const resetSize = () => {
+    // Set canvas size first
+    canvas.width = root.clientWidth;
+    canvas.height = root.clientHeight;
+
+    // Use a default aspect ratio if canvas dimensions are invalid
+    const aspectRatio = (canvas.width > 0 && canvas.height > 0)
+      ? canvas.width / canvas.height
+      : 16 / 9; // Default 16:9 aspect ratio
+
+    const drawWidth = Math.round(
+      Math.min(root.clientWidth, root.clientHeight * aspectRatio),
+    );
+    const drawHeight = Math.round(
+      Math.min(root.clientHeight, root.clientWidth / aspectRatio),
+    );
+
+    const drawX = Math.round((root.clientWidth - drawWidth) / 2);
+    const drawY = Math.round((root.clientHeight - drawHeight) / 2);
+
+    setDrawInfo({
+      drawX,
+      drawY,
+      drawWidth,
+      drawHeight,
+    });
+  };
+
+  const disconnect = () => {
+    if (reconnectTimeout) {
+      clearTimeout(reconnectTimeout);
+      reconnectTimeout = null;
+    }
+    
+    if (websocket) {
+      websocket.close();
+      websocket = null;
+    }
+  };
+
+  // Initialize canvas and resize observer
+  onMount(() => {
+    console.log('ScreenViewWebSocket mounted with displayId:', localProps.displayId);
+    const context = canvas.getContext('2d');
+    setCtx(context);
+
+    // Initial size setup
+    resetSize();
+
+    const resizeObserver = new ResizeObserver(() => {
+      resetSize();
+    });
+    resizeObserver.observe(root);
+
+    // Connect WebSocket
+    console.log('About to connect WebSocket...');
+    connectWebSocket();
+
+    onCleanup(() => {
+      isMounted = false;
+      disconnect();
+      resizeObserver?.unobserve(root);
+    });
+  });
+
+  // Debug function to list displays
+  const debugDisplays = async () => {
+    try {
+      const result = await invoke('list_display_info');
+      console.log('Available displays:', result);
+      alert(`Available displays: ${result}`);
+    } catch (error) {
+      console.error('Failed to get display info:', error);
+      alert(`Error: ${error}`);
+    }
+  };
+
+  // Status indicator
+  const getStatusColor = () => {
+    switch (connectionStatus()) {
+      case 'connected': return '#10b981'; // green
+      case 'connecting': return '#f59e0b'; // yellow
+      case 'error': return '#ef4444'; // red
+      default: return '#6b7280'; // gray
+    }
+  };
+
+  return (
+    <div
+      ref={root!}
+      {...rootProps}
+      class={'overflow-hidden h-full w-full relative ' + (rootProps.class || '')}
+    >
+      <canvas
+        ref={canvas!}
+        style={{
+          display: 'block',
+          width: '100%',
+          height: '100%',
+          'background-color': '#f0f0f0'
+        }}
+      />
+      
+      {/* Status indicator */}
+      <div class="absolute top-2 right-2 flex items-center gap-2 bg-black bg-opacity-50 text-white px-2 py-1 rounded text-xs">
+        <div
+          class="w-2 h-2 rounded-full"
+          style={{ 'background-color': getStatusColor() }}
+        />
+        <span>{connectionStatus()}</span>
+        {connectionStatus() === 'connected' && (
+          <span>| {fps()} FPS | {frameCount()} frames</span>
+        )}
+        <button
+          onClick={debugDisplays}
+          class="ml-2 px-1 py-0.5 bg-blue-600 hover:bg-blue-700 rounded text-xs"
+          title="Debug: Show available displays"
+        >
+          Debug
+        </button>
+      </div>
+      
+      {rootProps.children}
+    </div>
+  );
+};

src/components/led-strip-configuration/screen-view.tsx

@@ -1,4 +1,3 @@
-import { convertFileSrc } from '@tauri-apps/api/tauri';
 import {
   Component,
   createEffect,
@@ -8,16 +7,29 @@ import {
   onMount,
   splitProps,
 } from 'solid-js';
+import { ScreenViewWebSocket } from './screen-view-websocket';
 
 type ScreenViewProps = {
   displayId: number;
+  useWebSocket?: boolean;
 } & JSX.HTMLAttributes<HTMLDivElement>;
 
 export const ScreenView: Component<ScreenViewProps> = (props) => {
-  const [localProps, rootProps] = splitProps(props, ['displayId']);
+  const [localProps, rootProps] = splitProps(props, ['displayId', 'useWebSocket']);
+
+  // Use WebSocket by default for better performance
+  if (localProps.useWebSocket !== false) {
+    return <ScreenViewWebSocket displayId={localProps.displayId} {...rootProps} />;
+  }
+
+  // Fallback to HTTP polling (legacy mode)
   let canvas: HTMLCanvasElement;
   let root: HTMLDivElement;
   const [ctx, setCtx] = createSignal<CanvasRenderingContext2D | null>(null);
+
+  // Cache temporary canvas for scaling
+  let tempCanvas: HTMLCanvasElement | null = null;
+  let tempCtx: CanvasRenderingContext2D | null = null;
   const [drawInfo, setDrawInfo] = createSignal({
     drawX: 0,
     drawY: 0,
@@ -30,9 +42,84 @@ export const ScreenView: Component<ScreenViewProps> = (props) => {
     height: number;
   } | null>(null);
   const [hidden, setHidden] = createSignal(false);
+  const [isLoading, setIsLoading] = createSignal(false);
+  let isMounted = true;
+
+  // Fetch screenshot data from backend with frame-based rendering
+  const fetchScreenshot = async () => {
+    if (isLoading()) {
+      return; // Skip if already loading - frame-based approach
+    }
+
+    try {
+      setIsLoading(true);
+
+      const timestamp = Date.now();
+      const response = await fetch(`ambient-light://displays/${localProps.displayId}?width=400&height=225&t=${timestamp}`);
+
+      if (!response.ok) {
+        console.error('Screenshot fetch failed:', response.status);
+        return;
+      }
+
+      const width = parseInt(response.headers.get('X-Image-Width') || '400');
+      const height = parseInt(response.headers.get('X-Image-Height') || '225');
+      const arrayBuffer = await response.arrayBuffer();
+      const buffer = new Uint8ClampedArray(arrayBuffer);
+      const expectedSize = width * height * 4;
+
+      // Validate buffer size
+      if (buffer.length !== expectedSize) {
+        console.error('Invalid buffer size:', buffer.length, 'expected:', expectedSize);
+        return;
+      }
+
+      setImageData({
+        buffer,
+        width,
+        height
+      });
+
+      // Draw immediately after data is set
+      setTimeout(() => {
+        draw(false);
+      }, 0);
+
+      // Frame-based rendering: wait for current frame to complete before scheduling next
+      const shouldContinue = !hidden() && isMounted;
+      if (shouldContinue) {
+        setTimeout(() => {
+          if (isMounted) {
+            fetchScreenshot(); // Start next frame only after current one completes
+          }
+        }, 500); // Reduced frequency to 500ms for better performance
+      }
+
+    } catch (error) {
+      console.error('Error fetching screenshot:', error);
+      // On error, wait longer before retry
+      const shouldContinueOnError = !hidden() && isMounted;
+      if (shouldContinueOnError) {
+        setTimeout(() => {
+          if (isMounted) {
+            fetchScreenshot();
+          }
+        }, 2000);
+      }
+    } finally {
+      setIsLoading(false);
+    }
+  };
 
   const resetSize = () => {
-    const aspectRatio = canvas.width / canvas.height;
+    // Set canvas size first
+    canvas.width = root.clientWidth;
+    canvas.height = root.clientHeight;
+
+    // Use a default aspect ratio if canvas dimensions are invalid
+    const aspectRatio = (canvas.width > 0 && canvas.height > 0)
+      ? canvas.width / canvas.height
+      : 16 / 9; // Default 16:9 aspect ratio
 
     const drawWidth = Math.round(
       Math.min(root.clientWidth, root.clientHeight * aspectRatio),
@@ -51,106 +138,83 @@ export const ScreenView: Component<ScreenViewProps> = (props) => {
       drawHeight,
     });
 
-    canvas.width = root.clientWidth;
-    canvas.height = root.clientHeight;
-
     draw(true);
   };
 
   const draw = (cached: boolean = false) => {
-    const { drawX, drawY } = drawInfo();
+    const { drawX, drawY, drawWidth, drawHeight } = drawInfo();
-
     let _ctx = ctx();
     let raw = imageData();
+
     if (_ctx && raw) {
       _ctx.clearRect(0, 0, canvas.width, canvas.height);
+
+      // Apply transparency effect for cached images if needed
+      let buffer = raw.buffer;
       if (cached) {
-        for (let i = 3; i < raw.buffer.length; i += 8) {
+        buffer = new Uint8ClampedArray(raw.buffer);
-          raw.buffer[i] = Math.floor(raw.buffer[i] * 0.7);
+        for (let i = 3; i < buffer.length; i += 4) {
+          buffer[i] = Math.floor(buffer[i] * 0.7);
         }
       }
-      const img = new ImageData(raw.buffer, raw.width, raw.height);
+
-      _ctx.putImageData(img, drawX, drawY);
+      try {
+        // Create ImageData and draw directly
+        const img = new ImageData(buffer, raw.width, raw.height);
+
+        // If the image size matches the draw size, use putImageData directly
+        if (raw.width === drawWidth && raw.height === drawHeight) {
+          _ctx.putImageData(img, drawX, drawY);
+        } else {
+          // Otherwise, use cached temporary canvas for scaling
+          if (!tempCanvas || tempCanvas.width !== raw.width || tempCanvas.height !== raw.height) {
+            tempCanvas = document.createElement('canvas');
+            tempCanvas.width = raw.width;
+            tempCanvas.height = raw.height;
+            tempCtx = tempCanvas.getContext('2d');
+          }
+
+          if (tempCtx) {
+            tempCtx.putImageData(img, 0, 0);
+            _ctx.drawImage(tempCanvas, drawX, drawY, drawWidth, drawHeight);
+          }
+        }
+      } catch (error) {
+        console.error('Error in draw():', error);
+      }
     }
   };
 
-  // get screenshot
-  createEffect(() => {
-    let stopped = false;
-    const frame = async () => {
-      const { drawWidth, drawHeight } = drawInfo();
-      const url = convertFileSrc(
-        `displays/${localProps.displayId}?width=${drawWidth}&height=${drawHeight}`,
-        'ambient-light',
-      );
-      await fetch(url, {
-        mode: 'cors',
-      })
-        .then((res) => res.body?.getReader().read())
-        .then((buffer) => {
-          if (buffer?.value) {
-            setImageData({
-              buffer: new Uint8ClampedArray(buffer?.value),
-              width: drawWidth,
-              height: drawHeight,
-            });
-          } else {
-            setImageData(null);
-          }
-          draw();
-        });
-    };
 
-    (async () => {
+
-      while (!stopped) {
+  // Initialize canvas and resize observer
-        if (hidden()) {
+  onMount(() => {
-          await new Promise((resolve) => setTimeout(resolve, 1000));
+    const context = canvas.getContext('2d');
-          continue;
+    setCtx(context);
-        }
+
-        await frame();
+    // Initial size setup
-      }
+    resetSize();
-    })();
+
-
+    const resizeObserver = new ResizeObserver(() => {
-    onCleanup(() => {
+      resetSize();
-      stopped = true;
+    });
-    });
+    resizeObserver.observe(root);
-  });
+
-
+    // Start screenshot fetching after context is ready
-  // resize
+    setTimeout(() => {
-  createEffect(() => {
+      fetchScreenshot(); // Initial fetch - will self-schedule subsequent frames
-    let resizeObserver: ResizeObserver;
+    }, 100); // Small delay to ensure context is ready
-
-    onMount(() => {
-      setCtx(canvas.getContext('2d'));
-      new ResizeObserver(() => {
-        resetSize();
-      }).observe(root);
-    });
 
     onCleanup(() => {
+      isMounted = false; // Stop scheduling new frames
       resizeObserver?.unobserve(root);
     });
   });
 
-  // update hidden
-  createEffect(() => {
-    const hide = () => {
-      setHidden(true);
-      console.log('hide');
-    };
-    const show = () => {
-      setHidden(false);
-      console.log('show');
-    };
 
-    window.addEventListener('focus', show);
-    window.addEventListener('blur', hide);
 
-    onCleanup(() => {
+  // Note: Removed window focus/blur logic as it was causing screenshot loop to stop
-      window.removeEventListener('focus', show);
+  // when user interacted with dev tools or other windows
-      window.removeEventListener('blur', hide);
-    });
-  });
 
   return (
     <div
@@ -158,7 +222,15 @@ export const ScreenView: Component<ScreenViewProps> = (props) => {
       {...rootProps}
       class={'overflow-hidden h-full w-full ' + rootProps.class}
     >
-      <canvas ref={canvas!} />
+      <canvas
+        ref={canvas!}
+        style={{
+          display: 'block',
+          width: '100%',
+          height: '100%',
+          'background-color': '#f0f0f0'
+        }}
+      />
       {rootProps.children}
     </div>
   );

src/components/white-balance/color-slider.tsx

@@ -14,7 +14,7 @@ export const ColorSlider: Component<Props> = (props) => {
       step={0.01}
       value={props.value}
       class={
-        'w-full h-2 bg-gradient-to-r rounded-lg appearance-none cursor-pointer dark:bg-gray-700 drop-shadow ' +
+        'range range-primary w-full bg-gradient-to-r ' +
         props.class
       }
     />

src/components/white-balance/white-balance.tsx

@@ -1,24 +1,101 @@
 import { listen } from '@tauri-apps/api/event';
-import { Component, createEffect, onCleanup } from 'solid-js';
+import { Component, createEffect, onCleanup, createSignal } from 'solid-js';
 import { ColorCalibration, LedStripConfigContainer } from '../../models/led-strip-config';
 import { ledStripStore, setLedStripStore } from '../../stores/led-strip.store';
 import { ColorSlider } from './color-slider';
 import { TestColorsBg } from './test-colors-bg';
-import { invoke } from '@tauri-apps/api';
+import { invoke } from '@tauri-apps/api/core';
 import { VsClose } from 'solid-icons/vs';
 import { BiRegularReset } from 'solid-icons/bi';
+import { BsFullscreen, BsFullscreenExit } from 'solid-icons/bs';
+import { getCurrentWindow } from '@tauri-apps/api/window';
 import transparentBg from '../../assets/transparent-grid-background.svg?url';
 
 const Value: Component<{ value: number }> = (props) => {
   return (
-    <span class="w-10 text-sm block font-mono text-right ">
+    <div class="badge badge-outline badge-sm font-mono">
-      {(props.value * 100).toFixed(0)}
+      {(props.value * 100).toFixed(0)}%
-      <span class="text-xs text-stone-600">%</span>
+    </div>
-    </span>
   );
 };
 
 export const WhiteBalance = () => {
+  const [isFullscreen, setIsFullscreen] = createSignal(false);
+  const [panelPosition, setPanelPosition] = createSignal({ x: 0, y: 0 });
+  const [isDragging, setIsDragging] = createSignal(false);
+  const [dragOffset, setDragOffset] = createSignal({ x: 0, y: 0 });
+
+  // 自动进入全屏模式
+  createEffect(() => {
+    const autoEnterFullscreen = async () => {
+      try {
+        const window = getCurrentWindow();
+        const currentFullscreen = await window.isFullscreen();
+        if (!currentFullscreen) {
+          await window.setFullscreen(true);
+          setIsFullscreen(true);
+        } else {
+          setIsFullscreen(true);
+        }
+      } catch (error) {
+        console.error('Failed to auto enter fullscreen:', error);
+      }
+    };
+
+    autoEnterFullscreen();
+  });
+
+  // 初始化面板位置到屏幕中央
+  createEffect(() => {
+    if (isFullscreen()) {
+      const centerX = window.innerWidth / 2 - 160; // 160是面板宽度的一半
+      const centerY = window.innerHeight / 2 - 200; // 200是面板高度的一半
+      setPanelPosition({ x: centerX, y: centerY });
+    }
+  });
+
+  // 拖拽处理函数
+  const handleMouseDown = (e: MouseEvent) => {
+    setIsDragging(true);
+    const rect = (e.currentTarget as HTMLElement).getBoundingClientRect();
+    setDragOffset({
+      x: e.clientX - rect.left,
+      y: e.clientY - rect.top
+    });
+    e.preventDefault();
+  };
+
+  const handleMouseMove = (e: MouseEvent) => {
+    if (isDragging()) {
+      const newX = e.clientX - dragOffset().x;
+      const newY = e.clientY - dragOffset().y;
+
+      // 限制面板在屏幕范围内
+      const maxX = window.innerWidth - 320; // 320是面板宽度
+      const maxY = window.innerHeight - 400; // 400是面板高度
+
+      setPanelPosition({
+        x: Math.max(0, Math.min(newX, maxX)),
+        y: Math.max(0, Math.min(newY, maxY))
+      });
+    }
+  };
+
+  const handleMouseUp = () => {
+    setIsDragging(false);
+  };
+
+  // 添加全局鼠标事件监听
+  createEffect(() => {
+    if (isDragging()) {
+      document.addEventListener('mousemove', handleMouseMove);
+      document.addEventListener('mouseup', handleMouseUp);
+    } else {
+      document.removeEventListener('mousemove', handleMouseMove);
+      document.removeEventListener('mouseup', handleMouseUp);
+    }
+  });
+
   // listen to config_changed event
   createEffect(() => {
     const unlisten = listen('config_changed', (event) => {
@@ -32,20 +109,48 @@ export const WhiteBalance = () => {
       });
     });
 
-    onCleanup(() => {
+    onCleanup(async () => {
-      unlisten.then((unlisten) => unlisten());
+      (await unlisten)();
     });
   });
 
-  const updateColorCalibration = (field: keyof ColorCalibration, value: number) => {
+  const updateColorCalibration = (
-    const calibration = { ...ledStripStore.colorCalibration, [field]: value };
+    key: keyof ColorCalibration,
-    invoke('set_color_calibration', {
+    value: number,
-      calibration,
+  ) => {
-    }).catch((error) => console.log(error));
+    const calibration = { ...ledStripStore.colorCalibration };
+    calibration[key] = value;
+    setLedStripStore('colorCalibration', calibration);
+    invoke('set_color_calibration', { calibration }).catch((error) =>
+      console.log(error),
+    );
+  };
+
+  const toggleFullscreen = async () => {
+    try {
+      const window = getCurrentWindow();
+      const currentFullscreen = await window.isFullscreen();
+      await window.setFullscreen(!currentFullscreen);
+      setIsFullscreen(!currentFullscreen);
+
+      // 退出全屏时重置面板位置
+      if (currentFullscreen) {
+        setPanelPosition({ x: 0, y: 0 });
+      }
+    } catch (error) {
+      console.error('Failed to toggle fullscreen:', error);
+    }
   };
 
   const exit = () => {
-    window.history.back();
+    // 退出时确保退出全屏模式
+    if (isFullscreen()) {
+      toggleFullscreen().then(() => {
+        window.history.back();
+      });
+    } else {
+      window.history.back();
+    }
   };
 
   const reset = () => {
@@ -55,77 +160,273 @@ export const WhiteBalance = () => {
   };
 
   return (
-    <section class="select-none text-stone-800">
+    <>
-      <div
+      {/* 普通模式 */}
-        class="absolute top-0 left-0 right-0 bottom-0"
+      {!isFullscreen() && (
-        style={{
+        <div class="space-y-6">
-          'background-image': `url(${transparentBg})`,
+          <div class="flex items-center justify-between">
-        }}
+            <h1 class="text-2xl font-bold text-base-content">白平衡调节</h1>
-      >
+            <div class="flex gap-2">
-        <TestColorsBg />
+              <button class="btn btn-outline btn-sm" onClick={toggleFullscreen} title="进入全屏">
-      </div>
+                <BsFullscreen size={16} />
-      <div class="absolute top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2 w-10/12 max-w-lg bg-stone-100/20 backdrop-blur p-5 rounded-xl shadow-lg">
+                全屏
-        <label class="flex items-center gap-2">
+              </button>
-          <span class="w-3 block">R:</span>
+              <button class="btn btn-outline btn-sm" onClick={reset} title="重置到100%">
-          <ColorSlider
+                <BiRegularReset size={16} />
-            class="from-cyan-500 to-red-500"
+                重置
-            value={ledStripStore.colorCalibration.r}
+              </button>
-            onInput={(ev) =>
+              <button class="btn btn-primary btn-sm" onClick={exit} title="返回">
-              updateColorCalibration(
+                <VsClose size={16} />
-                'r',
+                返回
-                (ev.target as HTMLInputElement).valueAsNumber ?? 1,
+              </button>
-              )
+            </div>
-            }
+          </div>
-          />
+
-          <Value value={ledStripStore.colorCalibration.r} />
+          <div class="grid grid-cols-1 lg:grid-cols-2 gap-6">
-        </label>
+            {/* 颜色测试区域 */}
-        <label class="flex items-center gap-2">
+            <div class="card bg-base-200 shadow-lg">
-          <span class="w-3 block">G:</span>
+              <div class="card-body p-4">
-          <ColorSlider
+                <div class="card-title text-base mb-3">
-            class="from-pink-500 to-green-500"
+                  <span>颜色测试</span>
-            value={ledStripStore.colorCalibration.g}
+                  <div class="badge badge-info badge-outline">点击测试</div>
-            onInput={(ev) =>
+                </div>
-              updateColorCalibration(
+                <div
-                'g',
+                  class="aspect-square rounded-lg overflow-hidden border border-base-300"
-                (ev.target as HTMLInputElement).valueAsNumber ?? 1,
+                  style={{
-              )
+                    'background-image': `url(${transparentBg})`,
-            }
+                  }}
-          />
+                >
-          <Value value={ledStripStore.colorCalibration.g} />
+                  <TestColorsBg />
-        </label>
+                </div>
-        <label class="flex items-center gap-2">
+                <div class="text-xs text-base-content/50 mt-2">
-          <span class="w-3 block">B:</span>
+                  💡 提示：点击颜色块进行单色测试，再次点击返回多色模式
-          <ColorSlider
+                </div>
-            class="from-yellow-500 to-blue-500"
+              </div>
-            value={ledStripStore.colorCalibration.b}
+            </div>
-            onInput={(ev) =>
+
-              updateColorCalibration(
+            {/* 白平衡控制面板 */}
-                'b',
+            <div class="card bg-base-200 shadow-lg">
-                (ev.target as HTMLInputElement).valueAsNumber ?? 1,
+              <div class="card-body p-4">
-              )
+                <div class="card-title text-base mb-3">
-            }
+                  <span>RGB调节</span>
-          />
+                  <div class="badge badge-secondary badge-outline">实时调节</div>
-          <Value value={ledStripStore.colorCalibration.b} />
+                </div>
-        </label>
+
-        <label class="flex items-center gap-2">
+                <div class="space-y-4">
-          <span class="w-3 block">W:</span>
+                  <div class="form-control">
-          <ColorSlider class="from-yellow-50 to-cyan-50" />
+                    <label class="label">
-        </label>
+                      <span class="label-text font-semibold text-red-500">红色 (R)</span>
-        <button
+                      <Value value={ledStripStore.colorCalibration.r} />
-          class="absolute -right-4 -top-4 rounded-full aspect-square bg-stone-100/20 backdrop-blur p-1 shadow hover:bg-stone-200/20 active:bg-stone-300"
+                    </label>
-          onClick={exit}
+                    <ColorSlider
-          title="Go Back"
+                      class="from-cyan-500 to-red-500"
-        >
+                      value={ledStripStore.colorCalibration.r}
-          <VsClose size={24} />
+                      onInput={(ev) =>
-        </button>
+                        updateColorCalibration(
-        <button
+                          'r',
-          class="absolute -right-4 -bottom-4 rounded-full aspect-square bg-stone-100/20 backdrop-blur p-1 shadow hover:bg-stone-200/20 active:bg-stone-300"
+                          (ev.target as HTMLInputElement).valueAsNumber ?? 1,
-          onClick={reset}
+                        )
-          title="Reset to 100%"
+                      }
-        >
+                    />
-          <BiRegularReset size={24} />
+                  </div>
-        </button>
+
-      </div>
+                  <div class="form-control">
-    </section>
+                    <label class="label">
+                      <span class="label-text font-semibold text-green-500">绿色 (G)</span>
+                      <Value value={ledStripStore.colorCalibration.g} />
+                    </label>
+                    <ColorSlider
+                      class="from-pink-500 to-green-500"
+                      value={ledStripStore.colorCalibration.g}
+                      onInput={(ev) =>
+                        updateColorCalibration(
+                          'g',
+                          (ev.target as HTMLInputElement).valueAsNumber ?? 1,
+                        )
+                      }
+                    />
+                  </div>
+
+                  <div class="form-control">
+                    <label class="label">
+                      <span class="label-text font-semibold text-blue-500">蓝色 (B)</span>
+                      <Value value={ledStripStore.colorCalibration.b} />
+                    </label>
+                    <ColorSlider
+                      class="from-yellow-500 to-blue-500"
+                      value={ledStripStore.colorCalibration.b}
+                      onInput={(ev) =>
+                        updateColorCalibration(
+                          'b',
+                          (ev.target as HTMLInputElement).valueAsNumber ?? 1,
+                        )
+                      }
+                    />
+                  </div>
+
+                  <div class="form-control">
+                    <label class="label">
+                      <span class="label-text font-semibold text-base-content/70">白色 (W)</span>
+                      <div class="badge badge-outline badge-sm">暂未启用</div>
+                    </label>
+                    <ColorSlider class="from-yellow-50 to-cyan-50" disabled />
+                  </div>
+                </div>
+
+                {/* 使用说明 - 可展开 */}
+                <div class="collapse collapse-arrow bg-base-100 mt-4">
+                  <input type="checkbox" />
+                  <div class="collapse-title text-sm font-medium text-base-content/80">
+                    💡 白平衡调节使用说明
+                  </div>
+                  <div class="collapse-content text-xs text-base-content/70 space-y-3">
+                    <div class="space-y-2">
+                      <p class="font-semibold text-primary">🎯 推荐使用方法：</p>
+                      <ol class="list-decimal list-inside space-y-1 ml-2">
+                        <li>点击上方"全屏"按钮进入全屏模式</li>
+                        <li>全屏模式下屏幕边缘会显示彩色条带</li>
+                        <li>将RGB控制面板拖拽到合适位置</li>
+                        <li>对比LED灯条颜色与屏幕边缘颜色</li>
+                      </ol>
+                    </div>
+
+                    <div class="space-y-2">
+                      <p class="font-semibold text-secondary">🔧 调节技巧：</p>
+                      <ul class="list-disc list-inside space-y-1 ml-2">
+                        <li><span class="text-red-500 font-medium">红色偏强</span>：降低R值，LED会减少红色成分</li>
+                        <li><span class="text-green-500 font-medium">绿色偏强</span>：降低G值，LED会减少绿色成分</li>
+                        <li><span class="text-blue-500 font-medium">蓝色偏强</span>：降低B值，LED会减少蓝色成分</li>
+                        <li><span class="text-base-content font-medium">白色发黄</span>：适当提高B值，降低R/G值</li>
+                        <li><span class="text-base-content font-medium">白色发蓝</span>：适当降低B值，提高R/G值</li>
+                      </ul>
+                    </div>
+
+                    <div class="space-y-2">
+                      <p class="font-semibold text-accent">📋 对比方法：</p>
+                      <ul class="list-disc list-inside space-y-1 ml-2">
+                        <li>重点观察白色区域，确保LED白光与屏幕白色一致</li>
+                        <li>检查彩色区域，确保LED颜色饱和度合适</li>
+                        <li>在不同环境光下测试，确保效果稳定</li>
+                        <li>调节完成后可点击"重置"按钮恢复默认值</li>
+                      </ul>
+                    </div>
+                  </div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      )}
+
+      {/* 全屏模式 */}
+      {isFullscreen() && (
+        <div class="fixed inset-0 w-screen h-screen bg-black z-50">
+          {/* 全屏颜色测试区域 - 紧贴边缘 */}
+          <div class="absolute inset-0 w-full h-full">
+            <TestColorsBg />
+          </div>
+
+          {/* 可拖拽的RGB控制面板 */}
+          <div
+            class="fixed w-80 bg-base-200/95 backdrop-blur-sm rounded-lg shadow-xl z-60 cursor-move select-none"
+            style={{
+              left: `${panelPosition().x}px`,
+              top: `${panelPosition().y}px`,
+              transform: 'none'
+            }}
+            onMouseDown={handleMouseDown}
+          >
+            <div class="card-body p-4">
+              <div class="card-title text-base mb-3 flex justify-between items-center">
+                <div class="flex items-center gap-2">
+                  <span class="text-xs opacity-60">⋮⋮</span>
+                  <span>RGB调节</span>
+                  <div class="badge badge-secondary badge-outline">可拖拽</div>
+                </div>
+                <button class="btn btn-ghost btn-xs" onClick={toggleFullscreen} title="退出全屏">
+                  <BsFullscreenExit size={14} />
+                </button>
+              </div>
+
+              <div class="space-y-4">
+                <div class="form-control">
+                  <label class="label">
+                    <span class="label-text font-semibold text-red-500">红色 (R)</span>
+                    <Value value={ledStripStore.colorCalibration.r} />
+                  </label>
+                  <ColorSlider
+                    class="from-cyan-500 to-red-500"
+                    value={ledStripStore.colorCalibration.r}
+                    onInput={(ev) =>
+                      updateColorCalibration(
+                        'r',
+                        (ev.target as HTMLInputElement).valueAsNumber ?? 1,
+                      )
+                    }
+                  />
+                </div>
+
+                <div class="form-control">
+                  <label class="label">
+                    <span class="label-text font-semibold text-green-500">绿色 (G)</span>
+                    <Value value={ledStripStore.colorCalibration.g} />
+                  </label>
+                  <ColorSlider
+                    class="from-pink-500 to-green-500"
+                    value={ledStripStore.colorCalibration.g}
+                    onInput={(ev) =>
+                      updateColorCalibration(
+                        'g',
+                        (ev.target as HTMLInputElement).valueAsNumber ?? 1,
+                      )
+                    }
+                  />
+                </div>
+
+                <div class="form-control">
+                  <label class="label">
+                    <span class="label-text font-semibold text-blue-500">蓝色 (B)</span>
+                    <Value value={ledStripStore.colorCalibration.b} />
+                  </label>
+                  <ColorSlider
+                    class="from-yellow-500 to-blue-500"
+                    value={ledStripStore.colorCalibration.b}
+                    onInput={(ev) =>
+                      updateColorCalibration(
+                        'b',
+                        (ev.target as HTMLInputElement).valueAsNumber ?? 1,
+                      )
+                    }
+                  />
+                </div>
+
+                <div class="form-control">
+                  <label class="label">
+                    <span class="label-text font-semibold text-base-content/70">白色 (W)</span>
+                    <div class="badge badge-outline badge-sm">暂未启用</div>
+                  </label>
+                  <ColorSlider class="from-yellow-50 to-cyan-50" disabled />
+                </div>
+              </div>
+
+              <div class="text-xs text-base-content/60 mt-3 p-2 bg-base-300/50 rounded">
+                💡 对比屏幕边缘颜色与LED灯条，调节RGB滑块使颜色一致
+              </div>
+
+              <div class="flex gap-2 mt-4">
+                <button class="btn btn-outline btn-sm flex-1" onClick={reset} title="重置到100%">
+                  <BiRegularReset size={14} />
+                  重置
+                </button>
+                <button class="btn btn-primary btn-sm flex-1" onClick={exit} title="返回">
+                  <VsClose size={14} />
+                  返回
+                </button>
+              </div>
+            </div>
+          </div>
+        </div>
+      )}
+    </>
   );
-};
+};

src/styles.css

@@ -1,3 +1,2 @@
-@tailwind base;
+@import "tailwindcss";
-@tailwind components;
+@config "../tailwind.config.js";
-@tailwind utilities;

tailwind.config.js

@@ -1,9 +1,20 @@
+import daisyui from 'daisyui';
+
 /** @type {import('tailwindcss').Config} */
-module.exports = {
+export default {
-  mode: 'jit',
   content: ['./src/**/*.{js,jsx,ts,tsx}'],
   theme: {
     extend: {},
   },
-  plugins: [],
+  plugins: [daisyui],
+  daisyui: {
+    themes: ["dark", "light"],
+    darkTheme: "dark",
+    base: true,
+    styled: true,
+    utils: true,
+    prefix: "",
+    logs: true,
+    themeRoot: ":root",
+  },
 };

vite.config.ts

@@ -6,8 +6,14 @@ const mobile =
   process.env.TAURI_PLATFORM === "ios";
 
 // https://vitejs.dev/config/
-export default defineConfig(async () => ({
+export default defineConfig(async () => {
-  plugins: [solidPlugin()],
+  const tailwindcss = (await import("@tailwindcss/vite")).default;
+
+  return {
+    plugins: [
+      solidPlugin(),
+      tailwindcss(),
+    ],
 
   // Vite options tailored for Tauri development and only applied in `tauri dev` or `tauri build`
   // prevent vite from obscuring rust errors
@@ -28,4 +34,5 @@ export default defineConfig(async () => ({
     // produce sourcemaps for debug builds
     sourcemap: !!process.env.TAURI_DEBUG,
   },
-}));
+  };
+});