Method wait_for_keyframe

packages/server/src/simulators/session.rs:200–233

(&self, timeout_duration: Duration)

    }

    pub async fn wait_for_keyframe(&self, timeout_duration: Duration) -> Option<SharedFrame> {
        self.inner.native.set_client_foreground(true);
        let deadline = Instant::now() + timeout_duration;
        let baseline_sequence = self
            .latest_keyframe()
            .map_or(0, |frame| frame.frame_sequence);
        let mut rx = self.inner.sender.subscribe();
        self.request_keyframe_immediate();

        loop {
            if let Some(frame) = self.latest_keyframe() {
                if frame.frame_sequence > baseline_sequence {
                    return Some(frame);
                }
            }

            let now = Instant::now();
            if now >= deadline {
                return None;
            }

            let remaining = deadline - now;
            match timeout(remaining, rx.recv()).await {
                Ok(Ok(frame)) if frame.is_keyframe && frame.frame_sequence > baseline_sequence => {
                    return Some(frame)
                }
                Ok(Ok(_)) => self.request_keyframe(),
                Ok(Err(broadcast::error::RecvError::Lagged(_))) => {
                    self.request_keyframe();
                }
                Ok(Err(_)) | Err(_) => return None,
            }
        }
    }

    pub fn request_refresh(&self) {
        self.inner.request_refresh();