Use LiveKit's Rust SDK on Linux while continue using Swift SDK on Mac (#21550)

Similar to #20826 but keeps the Swift implementation. There were quite a few changes in the `call` crate, and so that code now has two variants. Closes #13714 Release Notes: - Added preliminary Linux support for voice chat and viewing screenshares. --------- Co-authored-by: Kirill Bulatov <mail4score@gmail.com> Co-authored-by: Kirill Bulatov <kirill@zed.dev> Co-authored-by: Mikayla <mikayla@zed.dev>
2024-12-05 15:06:17 -08:00
parent 0511768b22
commit 6a4cd53fd8
91 changed files with 7187 additions and 1028 deletions
@@ -0,0 +1,111 @@
+use super::*;
+
+#[derive(Clone, Debug)]
+pub enum Participant {
+    Local(LocalParticipant),
+    Remote(RemoteParticipant),
+}
+
+#[derive(Clone, Debug)]
+pub struct LocalParticipant {
+    #[cfg(not(target_os = "windows"))]
+    pub(super) identity: ParticipantIdentity,
+    pub(super) room: Room,
+}
+
+#[derive(Clone, Debug)]
+pub struct RemoteParticipant {
+    #[cfg(not(target_os = "windows"))]
+    pub(super) identity: ParticipantIdentity,
+    pub(super) room: WeakRoom,
+}
+
+#[cfg(not(target_os = "windows"))]
+impl Participant {
+    pub fn identity(&self) -> ParticipantIdentity {
+        match self {
+            Participant::Local(participant) => participant.identity.clone(),
+            Participant::Remote(participant) => participant.identity.clone(),
+        }
+    }
+}
+
+#[cfg(not(target_os = "windows"))]
+impl LocalParticipant {
+    pub async fn unpublish_track(&self, track: &TrackSid) -> Result<()> {
+        self.room
+            .test_server()
+            .unpublish_track(self.room.token(), track)
+            .await
+    }
+
+    pub async fn publish_track(
+        &self,
+        track: LocalTrack,
+        _options: TrackPublishOptions,
+    ) -> Result<LocalTrackPublication> {
+        let this = self.clone();
+        let track = track.clone();
+        let server = this.room.test_server();
+        let sid = match track {
+            LocalTrack::Video(track) => {
+                server.publish_video_track(this.room.token(), track).await?
+            }
+            LocalTrack::Audio(track) => {
+                server
+                    .publish_audio_track(this.room.token(), &track)
+                    .await?
+            }
+        };
+        Ok(LocalTrackPublication {
+            room: self.room.downgrade(),
+            sid,
+        })
+    }
+}
+
+#[cfg(not(target_os = "windows"))]
+impl RemoteParticipant {
+    pub fn track_publications(&self) -> HashMap<TrackSid, RemoteTrackPublication> {
+        if let Some(room) = self.room.upgrade() {
+            let server = room.test_server();
+            let audio = server
+                .audio_tracks(room.token())
+                .unwrap()
+                .into_iter()
+                .filter(|track| track.publisher_id() == self.identity)
+                .map(|track| {
+                    (
+                        track.sid(),
+                        RemoteTrackPublication {
+                            sid: track.sid(),
+                            room: self.room.clone(),
+                            track: RemoteTrack::Audio(track),
+                        },
+                    )
+                });
+            let video = server
+                .video_tracks(room.token())
+                .unwrap()
+                .into_iter()
+                .filter(|track| track.publisher_id() == self.identity)
+                .map(|track| {
+                    (
+                        track.sid(),
+                        RemoteTrackPublication {
+                            sid: track.sid(),
+                            room: self.room.clone(),
+                            track: RemoteTrack::Video(track),
+                        },
+                    )
+                });
+            audio.chain(video).collect()
+        } else {
+            HashMap::default()
+        }
+    }
+
+    pub fn identity(&self) -> ParticipantIdentity {
+        self.identity.clone()
+    }
+}
@@ -0,0 +1,116 @@
+use super::*;
+
+#[derive(Clone, Debug)]
+pub enum TrackPublication {
+    Local(LocalTrackPublication),
+    Remote(RemoteTrackPublication),
+}
+
+#[derive(Clone, Debug)]
+pub struct LocalTrackPublication {
+    #[cfg(not(target_os = "windows"))]
+    pub(crate) sid: TrackSid,
+    pub(crate) room: WeakRoom,
+}
+
+#[derive(Clone, Debug)]
+pub struct RemoteTrackPublication {
+    #[cfg(not(target_os = "windows"))]
+    pub(crate) sid: TrackSid,
+    pub(crate) room: WeakRoom,
+    pub(crate) track: RemoteTrack,
+}
+
+#[cfg(not(target_os = "windows"))]
+impl TrackPublication {
+    pub fn sid(&self) -> TrackSid {
+        match self {
+            TrackPublication::Local(track) => track.sid(),
+            TrackPublication::Remote(track) => track.sid(),
+        }
+    }
+
+    pub fn is_muted(&self) -> bool {
+        match self {
+            TrackPublication::Local(track) => track.is_muted(),
+            TrackPublication::Remote(track) => track.is_muted(),
+        }
+    }
+}
+
+#[cfg(not(target_os = "windows"))]
+impl LocalTrackPublication {
+    pub fn sid(&self) -> TrackSid {
+        self.sid.clone()
+    }
+
+    pub fn mute(&self) {
+        self.set_mute(true)
+    }
+
+    pub fn unmute(&self) {
+        self.set_mute(false)
+    }
+
+    fn set_mute(&self, mute: bool) {
+        if let Some(room) = self.room.upgrade() {
+            room.test_server()
+                .set_track_muted(&room.token(), &self.sid, mute)
+                .ok();
+        }
+    }
+
+    pub fn is_muted(&self) -> bool {
+        if let Some(room) = self.room.upgrade() {
+            room.test_server()
+                .is_track_muted(&room.token(), &self.sid)
+                .unwrap_or(false)
+        } else {
+            false
+        }
+    }
+}
+
+#[cfg(not(target_os = "windows"))]
+impl RemoteTrackPublication {
+    pub fn sid(&self) -> TrackSid {
+        self.sid.clone()
+    }
+
+    pub fn track(&self) -> Option<RemoteTrack> {
+        Some(self.track.clone())
+    }
+
+    pub fn kind(&self) -> TrackKind {
+        self.track.kind()
+    }
+
+    pub fn is_muted(&self) -> bool {
+        if let Some(room) = self.room.upgrade() {
+            room.test_server()
+                .is_track_muted(&room.token(), &self.sid)
+                .unwrap_or(false)
+        } else {
+            false
+        }
+    }
+
+    pub fn is_enabled(&self) -> bool {
+        if let Some(room) = self.room.upgrade() {
+            !room.0.lock().paused_audio_tracks.contains(&self.sid)
+        } else {
+            false
+        }
+    }
+
+    pub fn set_enabled(&self, enabled: bool) {
+        if let Some(room) = self.room.upgrade() {
+            let paused_audio_tracks = &mut room.0.lock().paused_audio_tracks;
+            if enabled {
+                paused_audio_tracks.remove(&self.sid);
+            } else {
+                paused_audio_tracks.insert(self.sid.clone());
+            }
+        }
+    }
+}
@@ -0,0 +1,201 @@
+use super::*;
+#[cfg(not(windows))]
+use webrtc::{audio_source::RtcAudioSource, video_source::RtcVideoSource};
+
+#[cfg(not(windows))]
+pub use livekit::track::{TrackKind, TrackSource};
+
+#[derive(Clone, Debug)]
+pub enum LocalTrack {
+    Audio(LocalAudioTrack),
+    Video(LocalVideoTrack),
+}
+
+#[derive(Clone, Debug)]
+pub enum RemoteTrack {
+    Audio(RemoteAudioTrack),
+    Video(RemoteVideoTrack),
+}
+
+#[derive(Clone, Debug)]
+pub struct LocalVideoTrack {}
+
+#[derive(Clone, Debug)]
+pub struct LocalAudioTrack {}
+
+#[derive(Clone, Debug)]
+pub struct RemoteVideoTrack {
+    #[cfg(not(target_os = "windows"))]
+    pub(super) server_track: Arc<TestServerVideoTrack>,
+    pub(super) _room: WeakRoom,
+}
+
+#[derive(Clone, Debug)]
+pub struct RemoteAudioTrack {
+    #[cfg(not(target_os = "windows"))]
+    pub(super) server_track: Arc<TestServerAudioTrack>,
+    pub(super) room: WeakRoom,
+}
+
+pub enum RtcTrack {
+    Audio(RtcAudioTrack),
+    Video(RtcVideoTrack),
+}
+
+pub struct RtcAudioTrack {
+    #[cfg(not(target_os = "windows"))]
+    pub(super) server_track: Arc<TestServerAudioTrack>,
+    pub(super) room: WeakRoom,
+}
+
+pub struct RtcVideoTrack {
+    #[cfg(not(target_os = "windows"))]
+    pub(super) _server_track: Arc<TestServerVideoTrack>,
+}
+
+#[cfg(not(target_os = "windows"))]
+impl RemoteTrack {
+    pub fn sid(&self) -> TrackSid {
+        match self {
+            RemoteTrack::Audio(track) => track.sid(),
+            RemoteTrack::Video(track) => track.sid(),
+        }
+    }
+
+    pub fn kind(&self) -> TrackKind {
+        match self {
+            RemoteTrack::Audio(_) => TrackKind::Audio,
+            RemoteTrack::Video(_) => TrackKind::Video,
+        }
+    }
+
+    pub fn publisher_id(&self) -> ParticipantIdentity {
+        match self {
+            RemoteTrack::Audio(track) => track.publisher_id(),
+            RemoteTrack::Video(track) => track.publisher_id(),
+        }
+    }
+
+    pub fn rtc_track(&self) -> RtcTrack {
+        match self {
+            RemoteTrack::Audio(track) => RtcTrack::Audio(track.rtc_track()),
+            RemoteTrack::Video(track) => RtcTrack::Video(track.rtc_track()),
+        }
+    }
+}
+
+#[cfg(not(windows))]
+impl LocalVideoTrack {
+    pub fn create_video_track(_name: &str, _source: RtcVideoSource) -> Self {
+        Self {}
+    }
+}
+
+#[cfg(not(windows))]
+impl LocalAudioTrack {
+    pub fn create_audio_track(_name: &str, _source: RtcAudioSource) -> Self {
+        Self {}
+    }
+}
+
+#[cfg(not(target_os = "windows"))]
+impl RemoteAudioTrack {
+    pub fn sid(&self) -> TrackSid {
+        self.server_track.sid.clone()
+    }
+
+    pub fn publisher_id(&self) -> ParticipantIdentity {
+        self.server_track.publisher_id.clone()
+    }
+
+    pub fn start(&self) {
+        if let Some(room) = self.room.upgrade() {
+            room.0
+                .lock()
+                .paused_audio_tracks
+                .remove(&self.server_track.sid);
+        }
+    }
+
+    pub fn stop(&self) {
+        if let Some(room) = self.room.upgrade() {
+            room.0
+                .lock()
+                .paused_audio_tracks
+                .insert(self.server_track.sid.clone());
+        }
+    }
+
+    pub fn rtc_track(&self) -> RtcAudioTrack {
+        RtcAudioTrack {
+            server_track: self.server_track.clone(),
+            room: self.room.clone(),
+        }
+    }
+}
+
+#[cfg(not(target_os = "windows"))]
+impl RemoteVideoTrack {
+    pub fn sid(&self) -> TrackSid {
+        self.server_track.sid.clone()
+    }
+
+    pub fn publisher_id(&self) -> ParticipantIdentity {
+        self.server_track.publisher_id.clone()
+    }
+
+    pub fn rtc_track(&self) -> RtcVideoTrack {
+        RtcVideoTrack {
+            _server_track: self.server_track.clone(),
+        }
+    }
+}
+
+#[cfg(not(target_os = "windows"))]
+impl RtcTrack {
+    pub fn enabled(&self) -> bool {
+        match self {
+            RtcTrack::Audio(track) => track.enabled(),
+            RtcTrack::Video(track) => track.enabled(),
+        }
+    }
+
+    pub fn set_enabled(&self, enabled: bool) {
+        match self {
+            RtcTrack::Audio(track) => track.set_enabled(enabled),
+            RtcTrack::Video(_) => {}
+        }
+    }
+}
+
+#[cfg(not(target_os = "windows"))]
+impl RtcAudioTrack {
+    pub fn set_enabled(&self, enabled: bool) {
+        if let Some(room) = self.room.upgrade() {
+            let paused_audio_tracks = &mut room.0.lock().paused_audio_tracks;
+            if enabled {
+                paused_audio_tracks.remove(&self.server_track.sid);
+            } else {
+                paused_audio_tracks.insert(self.server_track.sid.clone());
+            }
+        }
+    }
+
+    pub fn enabled(&self) -> bool {
+        if let Some(room) = self.room.upgrade() {
+            !room
+                .0
+                .lock()
+                .paused_audio_tracks
+                .contains(&self.server_track.sid)
+        } else {
+            false
+        }
+    }
+}
+
+impl RtcVideoTrack {
+    pub fn enabled(&self) -> bool {
+        true
+    }
+}
@@ -0,0 +1,136 @@
+use super::track::{RtcAudioTrack, RtcVideoTrack};
+use futures::Stream;
+use livekit::webrtc as real;
+use std::{
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+pub mod video_stream {
+    use super::*;
+
+    pub mod native {
+        use super::*;
+        use real::video_frame::BoxVideoFrame;
+
+        pub struct NativeVideoStream {
+            pub track: RtcVideoTrack,
+        }
+
+        impl NativeVideoStream {
+            pub fn new(track: RtcVideoTrack) -> Self {
+                Self { track }
+            }
+        }
+
+        impl Stream for NativeVideoStream {
+            type Item = BoxVideoFrame;
+
+            fn poll_next(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Option<Self::Item>> {
+                Poll::Pending
+            }
+        }
+    }
+}
+
+pub mod audio_stream {
+    use super::*;
+
+    pub mod native {
+        use super::*;
+        use real::audio_frame::AudioFrame;
+
+        pub struct NativeAudioStream {
+            pub track: RtcAudioTrack,
+        }
+
+        impl NativeAudioStream {
+            pub fn new(track: RtcAudioTrack, _sample_rate: i32, _num_channels: i32) -> Self {
+                Self { track }
+            }
+        }
+
+        impl Stream for NativeAudioStream {
+            type Item = AudioFrame<'static>;
+
+            fn poll_next(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<Option<Self::Item>> {
+                Poll::Pending
+            }
+        }
+    }
+}
+
+pub mod audio_source {
+    use super::*;
+
+    pub use real::audio_source::AudioSourceOptions;
+
+    pub mod native {
+        use std::sync::Arc;
+
+        use super::*;
+        use real::{audio_frame::AudioFrame, RtcError};
+
+        #[derive(Clone)]
+        pub struct NativeAudioSource {
+            pub options: Arc<AudioSourceOptions>,
+            pub sample_rate: u32,
+            pub num_channels: u32,
+        }
+
+        impl NativeAudioSource {
+            pub fn new(
+                options: AudioSourceOptions,
+                sample_rate: u32,
+                num_channels: u32,
+                _queue_size_ms: u32,
+            ) -> Self {
+                Self {
+                    options: Arc::new(options),
+                    sample_rate,
+                    num_channels,
+                }
+            }
+
+            pub async fn capture_frame(&self, _frame: &AudioFrame<'_>) -> Result<(), RtcError> {
+                Ok(())
+            }
+        }
+    }
+
+    pub enum RtcAudioSource {
+        Native(native::NativeAudioSource),
+    }
+}
+
+pub use livekit::webrtc::audio_frame;
+pub use livekit::webrtc::video_frame;
+
+pub mod video_source {
+    use super::*;
+    pub use real::video_source::VideoResolution;
+
+    pub struct RTCVideoSource;
+
+    pub mod native {
+        use super::*;
+        use real::video_frame::{VideoBuffer, VideoFrame};
+
+        #[derive(Clone)]
+        pub struct NativeVideoSource {
+            pub resolution: VideoResolution,
+        }
+
+        impl NativeVideoSource {
+            pub fn new(resolution: super::VideoResolution) -> Self {
+                Self { resolution }
+            }
+
+            pub fn capture_frame<T: AsRef<dyn VideoBuffer>>(&self, _frame: &VideoFrame<T>) {}
+        }
+    }
+
+    pub enum RtcVideoSource {
+        Native(native::NativeVideoSource),
+    }
+}