Method new

src/executors/auto_executor.rs:20–90

(executor: Executor)

impl AutoExecutor {
    pub(crate) fn new(executor: Executor) -> (Self, Sender<()>, Sender<Duration>) {
        let (tx, mut rx) = channel::<()>(10);
        let (auto_delay_tx, mut auto_delay_rx) = channel::<Duration>(10);
        let (auto_tx, auto_rx) = std::sync::mpsc::channel::<()>();
        let is_auto = Arc::new(AtomicBool::new(false));

        let (reset_tx, mut reset_rx) = channel::<()>(10);

        // 创建定时器
        let timer = slint::Timer::default();

        let executor = Self {
            timer,
            executor,
            is_auto: is_auto.clone(),
            auto_rx: Some(auto_rx),
        };

        // 监听控制信号的任务
        let is_auto_clone = is_auto.clone();
        tokio::spawn(async move {
            let mut start = true;
            while rx.recv().await.is_some() {
                if start {
                    is_auto_clone.store(true, Ordering::Relaxed);
                    start = false;
                } else {
                    is_auto_clone.store(false, Ordering::Relaxed);
                    start = true;
                    if let Err(e) = reset_tx.send(()).await {
                        eprintln!("auto reset channel closed: {e}");
                        return;
                    }
                }
            }
        });

        tokio::spawn(async move {
            let mut current_delay: Option<Sleep> = None;

            loop {
                tokio::select! {
                    Some(delay) = auto_delay_rx.recv() => {
                        current_delay = Some(tokio::time::sleep(delay));
                    }

                    // 延迟完成
                    _ = async {
                        if let Some(sleep) = current_delay {
                            sleep.await
                        } else {
                            std::future::pending::<()>().await
                        }
                    } => {
                        if let Err(e) = auto_tx.send(()) {
                            eprintln!("auto trigger channel closed: {e}");
                            return;
                        }