WIP cursor capture

Author: ids1024

src/wayland/cursor_stream.rs

@@ -1,19 +1,56 @@
-use cosmic_client_toolkit::screencopy::CaptureSession;
+use cosmic_client_toolkit::screencopy::{CaptureSession, FailureReason, Frame};
+use futures::channel::oneshot;
 use std::{
     pin::Pin,
+    sync::Mutex,
     task::{Context, Poll},
 };
+use wayland_client::{QueueHandle, WEnum};
+
+use super::{AppData, CursorCaptureSessionData, FrameData};
+
+enum State {
+    WaitingForFormats,
+    Capturing(oneshot::Receiver<Result<Frame, WEnum<FailureReason>>>),
+}
 
 // TODO wake stream when we get formats?
 pub struct CursorStream {
     // TODO formats
-    pub(super) capture_session: CaptureSession,
+    capture_session: CaptureSession,
+    qh: QueueHandle<AppData>,
+}
+
+impl CursorStream {
+    pub(super) fn new(capture_session: &CaptureSession, qh: &QueueHandle<AppData>) -> Self {
+        Self {
+            capture_session: capture_session.clone(),
+            qh: qh.clone(),
+        }
+    }
 }
 
 impl futures::stream::Stream for CursorStream {
     type Item = image::RgbaImage;
 
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<image::RgbaImage>> {
+        let (sender, receiver) = oneshot::channel();
+        let data = self
+            .capture_session
+            .data::<CursorCaptureSessionData>()
+            .unwrap();
+        *data.waker.lock().unwrap() = Some(cx.waker().clone());
+        let formats = data.formats.lock().unwrap().clone();
+        // WIP damage
+        self.capture_session.capture(
+            todo!(),
+            &[],
+            &self.qh,
+            FrameData {
+                frame_data: Default::default(),
+                sender: Mutex::new(Some(sender)),
+            },
+        );
         todo!()
     }
 }

src/wayland/mod.rs

@@ -180,7 +180,6 @@ struct SessionInner {
     wayland_helper: WaylandHelper,
     capture_session: CaptureSession,
     capture_cursor_session: Option<(CaptureCursorSession, CaptureSession)>,
-    capture_cursor_formats: Mutex<Option<Formats>>,
     condvar: Condvar,
     state: Mutex<SessionState>,
 }
@@ -244,14 +243,15 @@ impl Session {
         receiver.await.unwrap()
     }
 
-    // Should only be called once
+    // XXX Should only be called once
     fn cursor_stream(&self) -> Option<cursor_stream::CursorStream> {
         let Some((_, capture_session)) = &self.0.capture_cursor_session else {
             return None;
         };
-        Some(cursor_stream::CursorStream {
-            capture_session: capture_session.clone(),
-        })
+        Some(cursor_stream::CursorStream::new(
+            capture_session,
+            &self.0.wayland_helper.inner.qh,
+        ))
     }
 }
 
@@ -414,6 +414,8 @@ impl WaylandHelper {
                             CursorCaptureSessionData {
                                 session: weak_session.clone(),
                                 session_data: ScreencopySessionData::default(),
+                                waker: Mutex::new(None),
+                                formats: Mutex::new(None),
                             },
                         )
                         .unwrap();
@@ -427,7 +429,6 @@ impl WaylandHelper {
                 wayland_helper: self.clone(),
                 capture_session,
                 capture_cursor_session,
-                capture_cursor_formats: Mutex::new(None),
                 condvar: Condvar::new(),
                 state: Default::default(),
             }
@@ -658,9 +659,7 @@ impl ScreencopyHandler for AppData {
                 data.formats = Some(formats.clone());
             });
         } else if let Some(data) = session.data::<CursorCaptureSessionData>() {
-            if let Some(session_inner) = data.session.upgrade() {
-                *session_inner.capture_cursor_formats.lock().unwrap() = Some(formats.clone());
-            }
+            *data.formats.lock().unwrap() = Some(formats.clone());
             println!("Cursor session formats: {:?}", formats);
         }
     }
@@ -860,6 +859,8 @@ impl ScreencopySessionDataExt for SessionData {
 struct CursorCaptureSessionData {
     session: Weak<SessionInner>,
     session_data: ScreencopySessionData,
+    waker: Mutex<Option<std::task::Waker>>,
+    formats: Mutex<Option<Formats>>,
 }
 
 impl ScreencopySessionDataExt for CursorCaptureSessionData {