1use futures::StreamExt;
  2use gpui::{
  3    actions,
  4    elements::{Canvas, *},
  5    keymap::Binding,
  6    platform::current::Surface,
  7    Menu, MenuItem, ViewContext,
  8};
  9use live_kit_client::{LocalVideoTrack, RemoteVideoTrackUpdate, Room};
 10use live_kit_server::token::{self, VideoGrant};
 11use log::LevelFilter;
 12use media::core_video::CVImageBuffer;
 13use postage::watch;
 14use simplelog::SimpleLogger;
 15use std::sync::Arc;
 16
 17actions!(capture, [Quit]);
 18
 19fn main() {
 20    SimpleLogger::init(LevelFilter::Info, Default::default()).expect("could not initialize logger");
 21
 22    gpui::App::new(()).unwrap().run(|cx| {
 23        cx.platform().activate(true);
 24        cx.add_global_action(quit);
 25
 26        cx.add_bindings([Binding::new("cmd-q", Quit, None)]);
 27        cx.set_menus(vec![Menu {
 28            name: "Zed",
 29            items: vec![MenuItem::Action {
 30                name: "Quit",
 31                action: Box::new(Quit),
 32            }],
 33        }]);
 34
 35        let live_kit_url = std::env::var("LIVE_KIT_URL").unwrap_or("http://localhost:7880".into());
 36        let live_kit_key = std::env::var("LIVE_KIT_KEY").unwrap_or("devkey".into());
 37        let live_kit_secret = std::env::var("LIVE_KIT_SECRET").unwrap_or("secret".into());
 38
 39        cx.spawn(|cx| async move {
 40            let user_a_token = token::create(
 41                &live_kit_key,
 42                &live_kit_secret,
 43                Some("test-participant-1"),
 44                VideoGrant::to_join("test-room"),
 45            )
 46            .unwrap();
 47            let room_a = Room::new();
 48            room_a.connect(&live_kit_url, &user_a_token).await.unwrap();
 49
 50            let user2_token = token::create(
 51                &live_kit_key,
 52                &live_kit_secret,
 53                Some("test-participant-2"),
 54                VideoGrant::to_join("test-room"),
 55            )
 56            .unwrap();
 57            let room_b = Room::new();
 58            room_b.connect(&live_kit_url, &user2_token).await.unwrap();
 59
 60            let mut track_changes = room_b.remote_video_track_updates();
 61
 62            let displays = live_kit_client::display_sources().await.unwrap();
 63            let display = displays.into_iter().next().unwrap();
 64
 65            let track_a = LocalVideoTrack::screen_share_for_display(&display);
 66            room_a.publish_video_track(&track_a).await.unwrap();
 67
 68            let next_update = track_changes.next().await.unwrap();
 69
 70            if let RemoteVideoTrackUpdate::Subscribed(track) = next_update {
 71                let remote_tracks = room_b.remote_video_tracks("test-participant-1");
 72                assert_eq!(remote_tracks.len(), 1);
 73                assert_eq!(remote_tracks[0].publisher_id(), "test-participant-1");
 74                assert_eq!(track.publisher_id(), "test-participant-1");
 75            } else {
 76                panic!("unexpected message")
 77            }
 78
 79            cx.platform().quit();
 80        })
 81        .detach();
 82    });
 83}
 84
 85struct ScreenCaptureView {
 86    image_buffer: Option<CVImageBuffer>,
 87    _room: Arc<Room>,
 88}
 89
 90impl gpui::Entity for ScreenCaptureView {
 91    type Event = ();
 92}
 93
 94impl ScreenCaptureView {
 95    pub fn new(room: Arc<Room>, cx: &mut ViewContext<Self>) -> Self {
 96        let mut remote_video_tracks = room.remote_video_track_updates();
 97        cx.spawn_weak(|this, mut cx| async move {
 98            if let Some(video_track) = remote_video_tracks.next().await {
 99                let (mut frames_tx, mut frames_rx) = watch::channel_with(None);
100                // video_track.add_renderer(move |frame| *frames_tx.borrow_mut() = Some(frame));
101
102                while let Some(frame) = frames_rx.next().await {
103                    if let Some(this) = this.upgrade(&cx) {
104                        this.update(&mut cx, |this, cx| {
105                            this.image_buffer = frame;
106                            cx.notify();
107                        });
108                    } else {
109                        break;
110                    }
111                }
112            }
113        })
114        .detach();
115
116        Self {
117            image_buffer: None,
118            _room: room,
119        }
120    }
121}
122
123impl gpui::View for ScreenCaptureView {
124    fn ui_name() -> &'static str {
125        "View"
126    }
127
128    fn render(&mut self, _: &mut gpui::RenderContext<Self>) -> gpui::ElementBox {
129        let image_buffer = self.image_buffer.clone();
130        let canvas = Canvas::new(move |bounds, _, cx| {
131            if let Some(image_buffer) = image_buffer.clone() {
132                cx.scene.push_surface(Surface {
133                    bounds,
134                    image_buffer,
135                });
136            }
137        });
138
139        if let Some(image_buffer) = self.image_buffer.as_ref() {
140            canvas
141                .constrained()
142                .with_width(image_buffer.width() as f32)
143                .with_height(image_buffer.height() as f32)
144                .aligned()
145                .boxed()
146        } else {
147            canvas.boxed()
148        }
149    }
150}
151
152fn quit(_: &Quit, cx: &mut gpui::MutableAppContext) {
153    cx.platform().quit();
154}