move out dummy webrtc mod

src/lib.rs

@@ -61,10 +61,6 @@ pub mod stream;
 pub mod websocket;
 #[cfg(feature = "webrtc")]
 pub mod webrtc;
-#[cfg(not(feature = "webrtc"))]
-pub mod webrtc_dummy;
-#[cfg(not(feature = "webrtc"))]
-pub use webrtc_dummy as webrtc;
 #[cfg(any(target_os = "android", target_os = "ios"))]
 pub use rustls_platform_verifier;
 pub use stream::Stream;

src/stream.rs

@@ -1,10 +1,13 @@
-use crate::{config, tcp, websocket, webrtc, ResultType};
+use crate::{config, tcp, websocket, ResultType};
+#[cfg(feature = "webrtc")]
+use crate::webrtc;
 use sodiumoxide::crypto::secretbox::Key;
 use std::net::SocketAddr;
 use tokio::net::TcpStream;
 
 // support Websocket and tcp.
 pub enum Stream {
+    #[cfg(feature = "webrtc")]
     WebRTC(webrtc::WebRTCStream),
     WebSocket(websocket::WsFramedStream),
     Tcp(tcp::FramedStream),
@@ -14,6 +17,7 @@ impl Stream {
     #[inline]
     pub fn set_send_timeout(&mut self, ms: u64) {
         match self {
+            #[cfg(feature = "webrtc")]
             Stream::WebRTC(s) => s.set_send_timeout(ms),
             Stream::WebSocket(s) => s.set_send_timeout(ms),
             Stream::Tcp(s) => s.set_send_timeout(ms),
@@ -23,6 +27,7 @@ impl Stream {
     #[inline]
     pub fn set_raw(&mut self) {
         match self {
+            #[cfg(feature = "webrtc")]
             Stream::WebRTC(s) => s.set_raw(),
             Stream::WebSocket(s) => s.set_raw(),
             Stream::Tcp(s) => s.set_raw(),
@@ -32,6 +37,7 @@ impl Stream {
     #[inline]
     pub async fn send_bytes(&mut self, bytes: bytes::Bytes) -> ResultType<()> {
         match self {
+            #[cfg(feature = "webrtc")]
             Stream::WebRTC(s) => s.send_bytes(bytes).await,
             Stream::WebSocket(s) => s.send_bytes(bytes).await,
             Stream::Tcp(s) => s.send_bytes(bytes).await,
@@ -41,6 +47,7 @@ impl Stream {
     #[inline]
     pub async fn send_raw(&mut self, bytes: Vec<u8>) -> ResultType<()> {
         match self {
+            #[cfg(feature = "webrtc")]
             Stream::WebRTC(s) => s.send_raw(bytes).await,
             Stream::WebSocket(s) => s.send_raw(bytes).await,
             Stream::Tcp(s) => s.send_raw(bytes).await,
@@ -50,6 +57,7 @@ impl Stream {
     #[inline]
     pub fn set_key(&mut self, key: Key) {
         match self {
+            #[cfg(feature = "webrtc")]
             Stream::WebRTC(s) => s.set_key(key),
             Stream::WebSocket(s) => s.set_key(key),
             Stream::Tcp(s) => s.set_key(key),
@@ -59,6 +67,7 @@ impl Stream {
     #[inline]
     pub fn is_secured(&self) -> bool {
         match self {
+            #[cfg(feature = "webrtc")]
             Stream::WebRTC(s) => s.is_secured(),
             Stream::WebSocket(s) => s.is_secured(),
             Stream::Tcp(s) => s.is_secured(),
@@ -71,6 +80,7 @@ impl Stream {
         timeout: u64,
     ) -> Option<Result<bytes::BytesMut, std::io::Error>> {
         match self {
+            #[cfg(feature = "webrtc")]
             Stream::WebRTC(s) => s.next_timeout(timeout).await,
             Stream::WebSocket(s) => s.next_timeout(timeout).await,
             Stream::Tcp(s) => s.next_timeout(timeout).await,
@@ -95,6 +105,7 @@ impl Stream {
     #[inline]
     pub async fn send(&mut self, msg: &impl protobuf::Message) -> ResultType<()> {
         match self {
+            #[cfg(feature = "webrtc")]
             Self::WebRTC(s) => s.send(msg).await,
             Self::WebSocket(ws) => ws.send(msg).await,
             Self::Tcp(tcp) => tcp.send(msg).await,
@@ -105,6 +116,7 @@ impl Stream {
     #[inline]
     pub async fn next(&mut self) -> Option<Result<bytes::BytesMut, std::io::Error>> {
         match self {
+            #[cfg(feature = "webrtc")]
             Self::WebRTC(s) => s.next().await,
             Self::WebSocket(ws) => ws.next().await,
             Self::Tcp(tcp) => tcp.next().await,
@@ -114,6 +126,7 @@ impl Stream {
     #[inline]
     pub fn local_addr(&self) -> SocketAddr {
         match self {
+            #[cfg(feature = "webrtc")]
             Self::WebRTC(s) => s.local_addr(),
             Self::WebSocket(ws) => ws.local_addr(),
             Self::Tcp(tcp) => tcp.local_addr(),

src/webrtc_dummy.rs

@@ -1,91 +0,0 @@
-use std::net::{IpAddr, Ipv4Addr, SocketAddr};
-use std::io::Error;
-
-use bytes::{Bytes, BytesMut};
-
-use crate::{
-    protobuf::Message,
-    sodiumoxide::crypto::secretbox::Key,
-    ResultType,
-};
-
-pub struct WebRTCStream {
-    // mock struct
-}
-
-impl Clone for WebRTCStream {
-    fn clone(&self) -> Self {
-        WebRTCStream {
-        }
-    }
-}
-
-impl WebRTCStream {
-
-    pub async fn new(
-        _: &str,
-        _: u64,
-    ) -> ResultType<Self> {
-        Ok(Self {})
-    }
-
-    #[inline]
-    pub async fn get_local_endpoint(&self) -> ResultType<String> {
-        Ok(String::new())
-    }
-
-    #[inline]
-    pub async fn set_remote_endpoint(&self, _: &str) -> ResultType<()> {
-        Ok(())
-    }
-
-    #[inline]
-    pub fn set_raw(&mut self) {
-    }
-
-    #[inline]
-    pub fn local_addr(&self) -> SocketAddr {
-        SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0)
-    }
-
-    #[inline]
-    pub fn set_send_timeout(&mut self, _ms: u64) {
-    }
-
-    #[inline]
-    pub fn set_key(&mut self, _key: Key) {
-    }
-
-    #[inline]
-    pub fn is_secured(&self) -> bool {
-        false
-    }
-
-    #[inline]
-    pub async fn send(&mut self, _msg: &impl Message) -> ResultType<()> {
-        Ok(())
-    }
-
-    #[inline]
-    pub async fn send_raw(&mut self, _msg: Vec<u8>) -> ResultType<()> {
-        Ok(())
-    }
-
-    pub async fn send_bytes(&mut self, _bytes: Bytes) -> ResultType<()> {
-        Ok(())
-    }
-
-    #[inline]
-    pub async fn next(&mut self) -> Option<Result<BytesMut, Error>> {
-        None
-    }
-
-    #[inline]
-    pub async fn next_timeout(&mut self, _ms: u64) -> Option<Result<BytesMut, Error>> {
-        None
-    }
-}
-
-pub fn is_webrtc_endpoint(_endpoint: &str) -> bool {
-    false
-}