feat: video publishing (#42)

- Prepare webrtc abstraction ( for future wasm support )
- Added track publish support for videos
  - Added LogoTrack example to simple_room demo
- Lot of cleanup
- There are compiler warnings I'll solve on our v1 release

livekit-utils/Cargo.toml

@@ -6,8 +6,7 @@ license = "Apache-2.0"
 description = "Shared utilities for livekit"
 repository = "https://github.com/livekit/client-sdk-rust" 
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
-parking_lot = "0.12.1"
-tokio = { version = "1", features = ["full"] }
+tokio = { version = "1.26.0", features = ["full"] }
+futures-util = "0.3"
+parking_lot = "0.12"

livekit-utils/src/enum_dispatch.rs

@@ -1,11 +1,9 @@
-
-// TODO(theomonnom): Match the complete function signature like:
-//  - pub(crate) fn update_info(&self, info: ParticipantInfo) -> ();
+// TODO(theomonnom): Async methods
 #[macro_export]
 macro_rules! enum_dispatch {
     // This arm is used to avoid nested loops with the arguments
-    // The arguments are transformed to $combined_args TokenTree
-    (@match $self:ident $fnc:ident $combined_args:tt [$($variant:ident),+]) => {
+    // The arguments are transformed to $combined_args tt
+    (@match [$($variant:ident),+]: $fnc:ident, $self:ident, $combined_args:tt) => {
         match $self {
             $(
                 Self::$variant(inner) => inner.$fnc$combined_args,
@@ -13,15 +11,17 @@ macro_rules! enum_dispatch {
         }
     };
 
-    ($vis:vis$(,)? $fnc:ident, $self:ty, [$($arg:ident: $t:ty),*], $ret:ty, [$($variant:ident),+]) => {
-        $vis fn $fnc(self: $self, $($arg: $t),*) -> $ret {
-            enum_dispatch!(@match self $fnc ($($arg,)*) [$($variant),+])
+    // Create the function and extract self fron the $args tt (little hack)
+    (@fnc [$($variant:ident),+]: $vis:vis fn $fnc:ident($self:ident: $sty:ty $(, $arg:ident: $t:ty)*) -> $ret:ty) => {
+        #[inline]
+        $vis fn $fnc($self: $sty, $($arg: $t),*) -> $ret {
+            enum_dispatch!(@match [$($variant),+]: $fnc, $self, ($($arg,)*))
         }
     };
 
-    ($variants:tt $(fnc!($vis:vis$(,)? $fnc:ident, $self:ty, $args:tt, $ret:ty);)+) => {
+    ($variants:tt; $($vis:vis fn $fnc:ident$args:tt -> $ret:ty;)+) => {
         $(
-            enum_dispatch!($vis, $fnc, $self, $args, $ret, $variants);
-        )*
+            enum_dispatch!(@fnc $variants: $vis fn $fnc$args -> $ret);
+        )+
     };
 }

livekit-utils/src/observer.rs

@@ -1,14 +1,16 @@
-// Really basic implementation of the observer pattern using mpsc channels.
-// Currently unbounded channels
-
+use futures_util::sink::Sink;
+use futures_util::task::{Context, Poll};
+use parking_lot::Mutex;
+use std::pin::Pin;
+use std::sync::Arc;
 use tokio::sync::mpsc;
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Dispatcher<T>
 where
     T: Clone,
 {
-    senders: Vec<mpsc::UnboundedSender<T>>,
+    senders: Arc<Mutex<Vec<mpsc::UnboundedSender<T>>>>,
 }
 
 impl<T> Default for Dispatcher<T>
@@ -26,14 +28,43 @@ impl<T> Dispatcher<T>
 where
     T: Clone,
 {
-    pub fn register(&mut self) -> mpsc::UnboundedReceiver<T> {
+    pub fn register(&self) -> mpsc::UnboundedReceiver<T> {
         let (tx, rx) = mpsc::unbounded_channel();
-        self.senders.push(tx);
+        self.senders.lock().push(tx);
         rx
     }
 
-    pub fn dispatch(&mut self, msg: &T) {
+    pub fn dispatch(&self, msg: &T) {
         self.senders
+            .lock()
             .retain(|sender| sender.send(msg.clone()).is_ok());
     }
+
+    pub fn clear(&self) {
+        self.senders.lock().clear();
+    }
+}
+
+impl<T> Sink<T> for Dispatcher<T>
+where
+    T: Clone,
+{
+    type Error = ();
+
+    fn poll_ready(self: Pin<&mut Self>, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn start_send(self: Pin<&mut Self>, item: T) -> Result<(), Self::Error> {
+        self.dispatch(&item);
+        Ok(())
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn poll_close(self: Pin<&mut Self>, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
 }