Switch fully to Rust Livekit (redux) (#27126)

Swift bindings BEGONE

Release Notes:

- Switched from using the Swift LiveKit bindings, to the Rust bindings,
fixing https://github.com/zed-industries/zed/issues/9396, a crash when
leaving a collaboration session, and making Zed easier to build.

---------

Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com>
Co-authored-by: Michael Sloan <michael@zed.dev>

crates/workspace/src/shared_screen.rs

@@ -1,11 +1,133 @@
-#[cfg(target_os = "macos")]
-mod macos;
+use crate::{
+    item::{Item, ItemEvent},
+    ItemNavHistory, WorkspaceId,
+};
+use call::{RemoteVideoTrack, RemoteVideoTrackView, Room};
+use client::{proto::PeerId, User};
+use gpui::{
+    div, AppContext as _, Entity, EventEmitter, FocusHandle, Focusable, InteractiveElement,
+    ParentElement, Render, SharedString, Styled,
+};
+use std::sync::Arc;
+use ui::{prelude::*, Icon, IconName};
 
-#[cfg(target_os = "macos")]
-pub use macos::*;
+pub enum Event {
+    Close,
+}
 
-#[cfg(not(target_os = "macos"))]
-mod cross_platform;
+pub struct SharedScreen {
+    pub peer_id: PeerId,
+    user: Arc<User>,
+    nav_history: Option<ItemNavHistory>,
+    view: Entity<RemoteVideoTrackView>,
+    focus: FocusHandle,
+}
 
-#[cfg(not(target_os = "macos"))]
-pub use cross_platform::*;
+impl SharedScreen {
+    pub fn new(
+        track: RemoteVideoTrack,
+        peer_id: PeerId,
+        user: Arc<User>,
+        room: Entity<Room>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let my_sid = track.sid();
+        cx.subscribe(&room, move |_, _, ev, cx| match ev {
+            call::room::Event::RemoteVideoTrackUnsubscribed { sid } => {
+                if sid == &my_sid {
+                    cx.emit(Event::Close)
+                }
+            }
+            _ => {}
+        })
+        .detach();
+
+        let view = cx.new(|cx| RemoteVideoTrackView::new(track.clone(), window, cx));
+        cx.subscribe(&view, |_, _, ev, cx| match ev {
+            call::RemoteVideoTrackViewEvent::Close => cx.emit(Event::Close),
+        })
+        .detach();
+        Self {
+            view,
+            peer_id,
+            user,
+            nav_history: Default::default(),
+            focus: cx.focus_handle(),
+        }
+    }
+}
+
+impl EventEmitter<Event> for SharedScreen {}
+
+impl Focusable for SharedScreen {
+    fn focus_handle(&self, _: &App) -> FocusHandle {
+        self.focus.clone()
+    }
+}
+impl Render for SharedScreen {
+    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        div()
+            .bg(cx.theme().colors().editor_background)
+            .track_focus(&self.focus)
+            .key_context("SharedScreen")
+            .size_full()
+            .child(self.view.clone())
+    }
+}
+
+impl Item for SharedScreen {
+    type Event = Event;
+
+    fn tab_tooltip_text(&self, _: &App) -> Option<SharedString> {
+        Some(format!("{}'s screen", self.user.github_login).into())
+    }
+
+    fn deactivated(&mut self, _window: &mut Window, cx: &mut Context<Self>) {
+        if let Some(nav_history) = self.nav_history.as_mut() {
+            nav_history.push::<()>(None, cx);
+        }
+    }
+
+    fn tab_icon(&self, _window: &Window, _cx: &App) -> Option<Icon> {
+        Some(Icon::new(IconName::Screen))
+    }
+
+    fn tab_content_text(&self, _window: &Window, _cx: &App) -> Option<SharedString> {
+        Some(format!("{}'s screen", self.user.github_login).into())
+    }
+
+    fn telemetry_event_text(&self) -> Option<&'static str> {
+        None
+    }
+
+    fn set_nav_history(
+        &mut self,
+        history: ItemNavHistory,
+        _window: &mut Window,
+        _cx: &mut Context<Self>,
+    ) {
+        self.nav_history = Some(history);
+    }
+
+    fn clone_on_split(
+        &self,
+        _workspace_id: Option<WorkspaceId>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Option<Entity<Self>> {
+        Some(cx.new(|cx| Self {
+            view: self.view.update(cx, |view, cx| view.clone(window, cx)),
+            peer_id: self.peer_id,
+            user: self.user.clone(),
+            nav_history: Default::default(),
+            focus: cx.focus_handle(),
+        }))
+    }
+
+    fn to_item_events(event: &Self::Event, mut f: impl FnMut(ItemEvent)) {
+        match event {
+            Event::Close => f(ItemEvent::CloseItem),
+        }
+    }
+}

crates/workspace/src/shared_screen/cross_platform.rs

@@ -1,121 +0,0 @@
-use crate::{
-    item::{Item, ItemEvent},
-    ItemNavHistory, WorkspaceId,
-};
-use call::{RemoteVideoTrack, RemoteVideoTrackView};
-use client::{proto::PeerId, User};
-use gpui::{
-    div, AppContext as _, Entity, EventEmitter, FocusHandle, Focusable, InteractiveElement,
-    ParentElement, Render, SharedString, Styled,
-};
-use std::sync::Arc;
-use ui::{prelude::*, Icon, IconName};
-
-pub enum Event {
-    Close,
-}
-
-pub struct SharedScreen {
-    pub peer_id: PeerId,
-    user: Arc<User>,
-    nav_history: Option<ItemNavHistory>,
-    view: Entity<RemoteVideoTrackView>,
-    focus: FocusHandle,
-}
-
-impl SharedScreen {
-    pub fn new(
-        track: RemoteVideoTrack,
-        peer_id: PeerId,
-        user: Arc<User>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Self {
-        let view = cx.new(|cx| RemoteVideoTrackView::new(track.clone(), window, cx));
-        cx.subscribe(&view, |_, _, ev, cx| match ev {
-            call::RemoteVideoTrackViewEvent::Close => cx.emit(Event::Close),
-        })
-        .detach();
-        Self {
-            view,
-            peer_id,
-            user,
-            nav_history: Default::default(),
-            focus: cx.focus_handle(),
-        }
-    }
-}
-
-impl EventEmitter<Event> for SharedScreen {}
-
-impl Focusable for SharedScreen {
-    fn focus_handle(&self, _: &App) -> FocusHandle {
-        self.focus.clone()
-    }
-}
-impl Render for SharedScreen {
-    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        div()
-            .bg(cx.theme().colors().editor_background)
-            .track_focus(&self.focus)
-            .key_context("SharedScreen")
-            .size_full()
-            .child(self.view.clone())
-    }
-}
-
-impl Item for SharedScreen {
-    type Event = Event;
-
-    fn tab_tooltip_text(&self, _: &App) -> Option<SharedString> {
-        Some(format!("{}'s screen", self.user.github_login).into())
-    }
-
-    fn deactivated(&mut self, _window: &mut Window, cx: &mut Context<Self>) {
-        if let Some(nav_history) = self.nav_history.as_mut() {
-            nav_history.push::<()>(None, cx);
-        }
-    }
-
-    fn tab_icon(&self, _window: &Window, _cx: &App) -> Option<Icon> {
-        Some(Icon::new(IconName::Screen))
-    }
-
-    fn tab_content_text(&self, _window: &Window, _cx: &App) -> Option<SharedString> {
-        Some(format!("{}'s screen", self.user.github_login).into())
-    }
-
-    fn telemetry_event_text(&self) -> Option<&'static str> {
-        None
-    }
-
-    fn set_nav_history(
-        &mut self,
-        history: ItemNavHistory,
-        _window: &mut Window,
-        _cx: &mut Context<Self>,
-    ) {
-        self.nav_history = Some(history);
-    }
-
-    fn clone_on_split(
-        &self,
-        _workspace_id: Option<WorkspaceId>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Option<Entity<Self>> {
-        Some(cx.new(|cx| Self {
-            view: self.view.update(cx, |view, cx| view.clone(window, cx)),
-            peer_id: self.peer_id,
-            user: self.user.clone(),
-            nav_history: Default::default(),
-            focus: cx.focus_handle(),
-        }))
-    }
-
-    fn to_item_events(event: &Self::Event, mut f: impl FnMut(ItemEvent)) {
-        match event {
-            Event::Close => f(ItemEvent::CloseItem),
-        }
-    }
-}

crates/workspace/src/shared_screen/macos.rs

@@ -1,132 +0,0 @@
-use crate::{
-    item::{Item, ItemEvent},
-    ItemNavHistory, WorkspaceId,
-};
-use anyhow::Result;
-use call::participant::{Frame, RemoteVideoTrack};
-use client::{proto::PeerId, User};
-use futures::StreamExt;
-use gpui::{
-    div, surface, App, Context, Entity, EventEmitter, FocusHandle, Focusable, InteractiveElement,
-    ParentElement, Render, SharedString, Styled, Task, Window,
-};
-use std::sync::{Arc, Weak};
-use ui::{prelude::*, Icon, IconName};
-
-pub enum Event {
-    Close,
-}
-
-pub struct SharedScreen {
-    track: Weak<RemoteVideoTrack>,
-    frame: Option<Frame>,
-    pub peer_id: PeerId,
-    user: Arc<User>,
-    nav_history: Option<ItemNavHistory>,
-    _maintain_frame: Task<Result<()>>,
-    focus: FocusHandle,
-}
-
-impl SharedScreen {
-    pub fn new(
-        track: Arc<RemoteVideoTrack>,
-        peer_id: PeerId,
-        user: Arc<User>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Self {
-        cx.focus_handle();
-        let mut frames = track.frames();
-        Self {
-            track: Arc::downgrade(&track),
-            frame: None,
-            peer_id,
-            user,
-            nav_history: Default::default(),
-            _maintain_frame: cx.spawn_in(window, async move |this, cx| {
-                while let Some(frame) = frames.next().await {
-                    this.update(cx, |this, cx| {
-                        this.frame = Some(frame);
-                        cx.notify();
-                    })?;
-                }
-                this.update(cx, |_, cx| cx.emit(Event::Close))?;
-                Ok(())
-            }),
-            focus: cx.focus_handle(),
-        }
-    }
-}
-
-impl EventEmitter<Event> for SharedScreen {}
-
-impl Focusable for SharedScreen {
-    fn focus_handle(&self, _: &App) -> FocusHandle {
-        self.focus.clone()
-    }
-}
-impl Render for SharedScreen {
-    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
-        div()
-            .bg(cx.theme().colors().editor_background)
-            .track_focus(&self.focus)
-            .key_context("SharedScreen")
-            .size_full()
-            .children(
-                self.frame
-                    .as_ref()
-                    .map(|frame| surface(frame.image()).size_full()),
-            )
-    }
-}
-
-impl Item for SharedScreen {
-    type Event = Event;
-
-    fn tab_tooltip_text(&self, _: &App) -> Option<SharedString> {
-        Some(format!("{}'s screen", self.user.github_login).into())
-    }
-
-    fn deactivated(&mut self, _: &mut Window, cx: &mut Context<Self>) {
-        if let Some(nav_history) = self.nav_history.as_mut() {
-            nav_history.push::<()>(None, cx);
-        }
-    }
-
-    fn tab_icon(&self, _window: &Window, _cx: &App) -> Option<Icon> {
-        Some(Icon::new(IconName::Screen))
-    }
-
-    fn tab_content_text(&self, _window: &Window, _cx: &App) -> Option<SharedString> {
-        Some(format!("{}'s screen", self.user.github_login).into())
-    }
-
-    fn telemetry_event_text(&self) -> Option<&'static str> {
-        None
-    }
-
-    fn set_nav_history(
-        &mut self,
-        history: ItemNavHistory,
-        _window: &mut Window,
-        _: &mut Context<Self>,
-    ) {
-        self.nav_history = Some(history);
-    }
-
-    fn clone_on_split(
-        &self,
-        _workspace_id: Option<WorkspaceId>,
-        window: &mut Window,
-        cx: &mut Context<Self>,
-    ) -> Option<Entity<Self>> {
-        let track = self.track.upgrade()?;
-        Some(cx.new(|cx| Self::new(track, self.peer_id, self.user.clone(), window, cx)))
-    }
-
-    fn to_item_events(event: &Self::Event, mut f: impl FnMut(ItemEvent)) {
-        match event {
-            Event::Close => f(ItemEvent::CloseItem),
-        }
-    }
-}

crates/workspace/src/workspace.rs

@@ -4435,8 +4435,8 @@ impl Workspace {
         cx: &mut App,
     ) -> Option<Entity<SharedScreen>> {
         let call = self.active_call()?;
-        let room = call.read(cx).room()?.read(cx);
-        let participant = room.remote_participant_for_peer_id(peer_id)?;
+        let room = call.read(cx).room()?.clone();
+        let participant = room.read(cx).remote_participant_for_peer_id(peer_id)?;
         let track = participant.video_tracks.values().next()?.clone();
         let user = participant.user.clone();
 
@@ -4446,7 +4446,7 @@ impl Workspace {
             }
         }
 
-        Some(cx.new(|cx| SharedScreen::new(track, peer_id, user.clone(), window, cx)))
+        Some(cx.new(|cx| SharedScreen::new(track, peer_id, user.clone(), room.clone(), window, cx)))
     }
 
     pub fn on_window_activation_changed(&mut self, window: &mut Window, cx: &mut Context<Self>) {