collab: Make unsupported for MinGW toolchain (#23518)

Closes #23451

reverts #23117 for MinGW. collab can't be compiled for MinGW because
webrtc itself doesn't support MinGW compilers

Release Notes:

- N/A

crates/livekit_client/Cargo.toml

@@ -28,7 +28,6 @@ cpal = "0.15"
 futures.workspace = true
 gpui.workspace = true
 http_2 = { package = "http", version = "0.2.1" }
-livekit.workspace = true
 livekit_server.workspace = true
 log.workspace = true
 media.workspace = true
@@ -40,6 +39,9 @@ http_client.workspace = true
 smallvec.workspace = true
 image.workspace = true
 
+[target.'cfg(not(all(target_os = "windows", target_env = "gnu")))'.dependencies]
+livekit.workspace = true
+
 [target.'cfg(target_os = "macos")'.dependencies]
 core-foundation.workspace = true
 coreaudio-rs = "0.12.1"

crates/livekit_client/src/livekit_client.rs

@@ -1,5 +1,11 @@
+#![cfg_attr(all(target_os = "windows", target_env = "gnu"), allow(unused))]
+
 mod remote_video_track_view;
-#[cfg(any(test, feature = "test-support"))]
+#[cfg(any(
+    test,
+    feature = "test-support",
+    all(target_os = "windows", target_env = "gnu")
+))]
 pub mod test;
 
 use anyhow::{anyhow, Context as _, Result};
@@ -11,6 +17,7 @@ use gpui::{
 use parking_lot::Mutex;
 use std::{borrow::Cow, collections::VecDeque, future::Future, pin::Pin, sync::Arc, thread};
 use util::{debug_panic, ResultExt as _};
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 use webrtc::{
     audio_frame::AudioFrame,
     audio_source::{native::NativeAudioSource, AudioSourceOptions, RtcAudioSource},
@@ -20,13 +27,27 @@ use webrtc::{
     video_stream::native::NativeVideoStream,
 };
 
-#[cfg(not(any(test, feature = "test-support")))]
+#[cfg(all(
+    not(any(test, feature = "test-support")),
+    not(all(target_os = "windows", target_env = "gnu"))
+))]
 use livekit::track::RemoteAudioTrack;
-#[cfg(not(any(test, feature = "test-support")))]
+#[cfg(all(
+    not(any(test, feature = "test-support")),
+    not(all(target_os = "windows", target_env = "gnu"))
+))]
 pub use livekit::*;
-#[cfg(any(test, feature = "test-support"))]
+#[cfg(any(
+    test,
+    feature = "test-support",
+    all(target_os = "windows", target_env = "gnu")
+))]
 use test::track::RemoteAudioTrack;
-#[cfg(any(test, feature = "test-support"))]
+#[cfg(any(
+    test,
+    feature = "test-support",
+    all(target_os = "windows", target_env = "gnu")
+))]
 pub use test::*;
 
 pub use remote_video_track_view::{RemoteVideoTrackView, RemoteVideoTrackViewEvent};
@@ -43,6 +64,7 @@ pub enum AudioStream {
 
 struct Dispatcher(Arc<dyn gpui::PlatformDispatcher>);
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 impl livekit::dispatcher::Dispatcher for Dispatcher {
     fn dispatch(&self, runnable: livekit::dispatcher::Runnable) {
         self.0.dispatch(runnable, None);
@@ -64,6 +86,7 @@ fn http_2_status(status: http_client::http::StatusCode) -> http_2::StatusCode {
         .expect("valid status code to status code conversion")
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 impl livekit::dispatcher::HttpClient for HttpClientAdapter {
     fn get(
         &self,
@@ -118,6 +141,14 @@ impl livekit::dispatcher::HttpClient for HttpClientAdapter {
     }
 }
 
+#[cfg(all(target_os = "windows", target_env = "gnu"))]
+pub fn init(
+    dispatcher: Arc<dyn gpui::PlatformDispatcher>,
+    http_client: Arc<dyn http_client::HttpClient>,
+) {
+}
+
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 pub fn init(
     dispatcher: Arc<dyn gpui::PlatformDispatcher>,
     http_client: Arc<dyn http_client::HttpClient>,
@@ -126,6 +157,7 @@ pub fn init(
     livekit::dispatcher::set_http_client(HttpClientAdapter(http_client));
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 pub async fn capture_local_video_track(
     capture_source: &dyn ScreenCaptureSource,
 ) -> Result<(track::LocalVideoTrack, Box<dyn ScreenCaptureStream>)> {
@@ -159,6 +191,7 @@ pub async fn capture_local_video_track(
     ))
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 pub fn capture_local_audio_track(
     background_executor: &BackgroundExecutor,
 ) -> Result<Task<(track::LocalAudioTrack, AudioStream)>> {
@@ -250,6 +283,7 @@ pub fn capture_local_audio_track(
     }))
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 pub fn play_remote_audio_track(
     track: &RemoteAudioTrack,
     background_executor: &BackgroundExecutor,
@@ -320,6 +354,7 @@ fn default_device(input: bool) -> anyhow::Result<(cpal::Device, cpal::SupportedS
     Ok((device, config))
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 fn get_default_output() -> anyhow::Result<(cpal::Device, cpal::SupportedStreamConfig)> {
     let host = cpal::default_host();
     let output_device = host
@@ -329,6 +364,7 @@ fn get_default_output() -> anyhow::Result<(cpal::Device, cpal::SupportedStreamCo
     Ok((output_device, output_config))
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 fn start_output_stream(
     output_config: cpal::SupportedStreamConfig,
     output_device: cpal::Device,
@@ -413,6 +449,14 @@ fn start_output_stream(
     (receive_task, thread)
 }
 
+#[cfg(all(target_os = "windows", target_env = "gnu"))]
+pub fn play_remote_video_track(
+    track: &track::RemoteVideoTrack,
+) -> impl Stream<Item = RemoteVideoFrame> {
+    futures::stream::empty()
+}
+
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 pub fn play_remote_video_track(
     track: &track::RemoteVideoTrack,
 ) -> impl Stream<Item = RemoteVideoFrame> {
@@ -440,7 +484,7 @@ fn video_frame_buffer_from_webrtc(buffer: Box<dyn VideoBuffer>) -> Option<Remote
 #[cfg(not(target_os = "macos"))]
 pub type RemoteVideoFrame = Arc<gpui::RenderImage>;
 
-#[cfg(not(target_os = "macos"))]
+#[cfg(not(any(target_os = "macos", all(target_os = "windows", target_env = "gnu"))))]
 fn video_frame_buffer_from_webrtc(buffer: Box<dyn VideoBuffer>) -> Option<RemoteVideoFrame> {
     use gpui::RenderImage;
     use image::{Frame, RgbaImage};
@@ -491,7 +535,7 @@ fn video_frame_buffer_to_webrtc(frame: ScreenCaptureFrame) -> Option<impl AsRef<
     }
 }
 
-#[cfg(not(target_os = "macos"))]
+#[cfg(not(any(target_os = "macos", all(target_os = "windows", target_env = "gnu"))))]
 fn video_frame_buffer_to_webrtc(_frame: ScreenCaptureFrame) -> Option<impl AsRef<dyn VideoBuffer>> {
     None as Option<Box<dyn VideoBuffer>>
 }

crates/livekit_client/src/test.rs

@@ -1,14 +1,18 @@
 pub mod participant;
 pub mod publication;
 pub mod track;
+
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 pub mod webrtc;
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 use self::id::*;
 use self::{participant::*, publication::*, track::*};
 use anyhow::{anyhow, Context as _, Result};
 use async_trait::async_trait;
 use collections::{btree_map::Entry as BTreeEntry, hash_map::Entry, BTreeMap, HashMap, HashSet};
 use gpui::BackgroundExecutor;
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 use livekit::options::TrackPublishOptions;
 use livekit_server::{proto, token};
 use parking_lot::Mutex;
@@ -18,6 +22,7 @@ use std::sync::{
     Arc, Weak,
 };
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 pub use livekit::{id, options, ConnectionState, DisconnectReason, RoomOptions};
 
 static SERVERS: Mutex<BTreeMap<String, Arc<TestServer>>> = Mutex::new(BTreeMap::new());
@@ -26,10 +31,12 @@ pub struct TestServer {
     pub url: String,
     pub api_key: String,
     pub secret_key: String,
+    #[cfg(not(all(target_os = "windows", target_env = "gnu")))]
     rooms: Mutex<HashMap<String, TestServerRoom>>,
     executor: BackgroundExecutor,
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 impl TestServer {
     pub fn create(
         url: String,
@@ -527,6 +534,7 @@ impl TestServer {
     }
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 #[derive(Default, Debug)]
 struct TestServerRoom {
     client_rooms: HashMap<ParticipantIdentity, Room>,
@@ -535,6 +543,7 @@ struct TestServerRoom {
     participant_permissions: HashMap<ParticipantIdentity, proto::ParticipantPermission>,
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 #[derive(Debug)]
 struct TestServerVideoTrack {
     sid: TrackSid,
@@ -542,6 +551,7 @@ struct TestServerVideoTrack {
     // frames_rx: async_broadcast::Receiver<Frame>,
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 #[derive(Debug)]
 struct TestServerAudioTrack {
     sid: TrackSid,
@@ -580,6 +590,7 @@ pub enum RoomEvent {
     TrackSubscriptionFailed {
         participant: RemoteParticipant,
         error: String,
+        #[cfg(not(all(target_os = "windows", target_env = "gnu")))]
         track_sid: TrackSid,
     },
     TrackPublished {
@@ -615,10 +626,12 @@ pub enum RoomEvent {
     ActiveSpeakersChanged {
         speakers: Vec<Participant>,
     },
+    #[cfg(not(all(target_os = "windows", target_env = "gnu")))]
     ConnectionStateChanged(ConnectionState),
     Connected {
         participants_with_tracks: Vec<(RemoteParticipant, Vec<RemoteTrackPublication>)>,
     },
+    #[cfg(not(all(target_os = "windows", target_env = "gnu")))]
     Disconnected {
         reason: DisconnectReason,
     },
@@ -626,6 +639,7 @@ pub enum RoomEvent {
     Reconnected,
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 #[async_trait]
 impl livekit_server::api::Client for TestApiClient {
     fn url(&self) -> &str {
@@ -689,8 +703,11 @@ impl livekit_server::api::Client for TestApiClient {
 struct RoomState {
     url: String,
     token: String,
+    #[cfg(not(all(target_os = "windows", target_env = "gnu")))]
     local_identity: ParticipantIdentity,
+    #[cfg(not(all(target_os = "windows", target_env = "gnu")))]
     connection_state: ConnectionState,
+    #[cfg(not(all(target_os = "windows", target_env = "gnu")))]
     paused_audio_tracks: HashSet<TrackSid>,
     updates_tx: mpsc::Sender<RoomEvent>,
 }
@@ -701,6 +718,7 @@ pub struct Room(Arc<Mutex<RoomState>>);
 #[derive(Clone, Debug)]
 pub(crate) struct WeakRoom(Weak<Mutex<RoomState>>);
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 impl std::fmt::Debug for RoomState {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("Room")
@@ -713,6 +731,17 @@ impl std::fmt::Debug for RoomState {
     }
 }
 
+#[cfg(all(target_os = "windows", target_env = "gnu"))]
+impl std::fmt::Debug for RoomState {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Room")
+            .field("url", &self.url)
+            .field("token", &self.token)
+            .finish()
+    }
+}
+
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 impl Room {
     fn downgrade(&self) -> WeakRoom {
         WeakRoom(Arc::downgrade(&self.0))
@@ -774,6 +803,7 @@ impl Room {
     }
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 impl Drop for RoomState {
     fn drop(&mut self) {
         if self.connection_state == ConnectionState::Connected {

crates/livekit_client/src/test/participant.rs

@@ -8,16 +8,19 @@ pub enum Participant {
 
 #[derive(Clone, Debug)]
 pub struct LocalParticipant {
+    #[cfg(not(all(target_os = "windows", target_env = "gnu")))]
     pub(super) identity: ParticipantIdentity,
     pub(super) room: Room,
 }
 
 #[derive(Clone, Debug)]
 pub struct RemoteParticipant {
+    #[cfg(not(all(target_os = "windows", target_env = "gnu")))]
     pub(super) identity: ParticipantIdentity,
     pub(super) room: WeakRoom,
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 impl Participant {
     pub fn identity(&self) -> ParticipantIdentity {
         match self {
@@ -27,6 +30,7 @@ impl Participant {
     }
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 impl LocalParticipant {
     pub async fn unpublish_track(&self, track: &TrackSid) -> Result<()> {
         self.room
@@ -60,6 +64,7 @@ impl LocalParticipant {
     }
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 impl RemoteParticipant {
     pub fn track_publications(&self) -> HashMap<TrackSid, RemoteTrackPublication> {
         if let Some(room) = self.room.upgrade() {

crates/livekit_client/src/test/publication.rs

@@ -8,17 +8,20 @@ pub enum TrackPublication {
 
 #[derive(Clone, Debug)]
 pub struct LocalTrackPublication {
+    #[cfg(not(all(target_os = "windows", target_env = "gnu")))]
     pub(crate) sid: TrackSid,
     pub(crate) room: WeakRoom,
 }
 
 #[derive(Clone, Debug)]
 pub struct RemoteTrackPublication {
+    #[cfg(not(all(target_os = "windows", target_env = "gnu")))]
     pub(crate) sid: TrackSid,
     pub(crate) room: WeakRoom,
     pub(crate) track: RemoteTrack,
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 impl TrackPublication {
     pub fn sid(&self) -> TrackSid {
         match self {
@@ -35,6 +38,7 @@ impl TrackPublication {
     }
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 impl LocalTrackPublication {
     pub fn sid(&self) -> TrackSid {
         self.sid.clone()
@@ -67,6 +71,7 @@ impl LocalTrackPublication {
     }
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 impl RemoteTrackPublication {
     pub fn sid(&self) -> TrackSid {
         self.sid.clone()

crates/livekit_client/src/test/track.rs

@@ -1,6 +1,8 @@
 use super::*;
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 use webrtc::{audio_source::RtcAudioSource, video_source::RtcVideoSource};
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 pub use livekit::track::{TrackKind, TrackSource};
 
 #[derive(Clone, Debug)]
@@ -23,12 +25,14 @@ pub struct LocalAudioTrack {}
 
 #[derive(Clone, Debug)]
 pub struct RemoteVideoTrack {
+    #[cfg(not(all(target_os = "windows", target_env = "gnu")))]
     pub(super) server_track: Arc<TestServerVideoTrack>,
     pub(super) _room: WeakRoom,
 }
 
 #[derive(Clone, Debug)]
 pub struct RemoteAudioTrack {
+    #[cfg(not(all(target_os = "windows", target_env = "gnu")))]
     pub(super) server_track: Arc<TestServerAudioTrack>,
     pub(super) room: WeakRoom,
 }
@@ -39,14 +43,17 @@ pub enum RtcTrack {
 }
 
 pub struct RtcAudioTrack {
+    #[cfg(not(all(target_os = "windows", target_env = "gnu")))]
     pub(super) server_track: Arc<TestServerAudioTrack>,
     pub(super) room: WeakRoom,
 }
 
 pub struct RtcVideoTrack {
+    #[cfg(not(all(target_os = "windows", target_env = "gnu")))]
     pub(super) _server_track: Arc<TestServerVideoTrack>,
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 impl RemoteTrack {
     pub fn sid(&self) -> TrackSid {
         match self {
@@ -77,18 +84,21 @@ impl RemoteTrack {
     }
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 impl LocalVideoTrack {
     pub fn create_video_track(_name: &str, _source: RtcVideoSource) -> Self {
         Self {}
     }
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 impl LocalAudioTrack {
     pub fn create_audio_track(_name: &str, _source: RtcAudioSource) -> Self {
         Self {}
     }
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 impl RemoteAudioTrack {
     pub fn sid(&self) -> TrackSid {
         self.server_track.sid.clone()
@@ -124,6 +134,7 @@ impl RemoteAudioTrack {
     }
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 impl RemoteVideoTrack {
     pub fn sid(&self) -> TrackSid {
         self.server_track.sid.clone()
@@ -140,6 +151,7 @@ impl RemoteVideoTrack {
     }
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 impl RtcTrack {
     pub fn enabled(&self) -> bool {
         match self {
@@ -156,6 +168,7 @@ impl RtcTrack {
     }
 }
 
+#[cfg(not(all(target_os = "windows", target_env = "gnu")))]
 impl RtcAudioTrack {
     pub fn set_enabled(&self, enabled: bool) {
         if let Some(room) = self.room.upgrade() {