update native client to new version

2 files changed, 67 insertions, 23 deletions

diff --git a/client-native-lib/src/instance.rs b/client-native-lib/src/instance.rs
index 56c9efa..be8ffb8 100644
--- a/client-native-lib/src/instance.rs
+++ b/client-native-lib/src/instance.rs
@@ -5,7 +5,7 @@
 */
 use crate::{
     build_api,
-    crypto::{self, Key},
+    crypto::{self, hash, Key},
     peer::Peer,
     protocol::{self, ClientboundPacket, RelayMessage, RelayMessageWrapper, ServerboundPacket},
     signaling::{self, SignalingConnection},
@@ -22,7 +22,7 @@ pub struct Instance {
     pub conn: SignalingConnection,
     pub config: Config,
     pub api: API,
-    key: Key,
+    key: RwLock<Option<Key>>,
     pub local_resources: RwLock<HashMap<String, Box<dyn LocalResource>>>,
     my_id: RwLock<Option<usize>>,
     pub peers: RwLock<HashMap<usize, Arc<Peer>>>,
@@ -31,7 +31,6 @@ pub struct Instance {
 impl Instance {
     pub async fn new(config: Config, event_handler: Arc<dyn EventHandler>) -> Arc<Self> {
         let conn = signaling::SignalingConnection::new(&config.signaling_uri).await;
-        let key = crypto::Key::derive(&config.secret);
 
         Arc::new(Self {
             event_handler,
@@ -41,10 +40,19 @@ impl Instance {
             local_resources: Default::default(),
             config,
             conn,
-            key,
+            key: None.into(),
         })
     }
 
+    pub async fn join(&self, secret: Option<&str>) {
+        info!("join room {secret:?}");
+        *self.key.write().await = secret.map(|secret| crypto::Key::derive(&secret));
+        self.send_packet(ServerboundPacket::Join {
+            hash: secret.map(|secret| hash(secret)),
+        })
+        .await;
+    }
+
     pub async fn spawn_ping(self: &Arc<Self>) {
         let blub = self.clone();
         tokio::spawn(async move {
@@ -94,12 +102,22 @@ impl Instance {
                 }
             }
             protocol::ClientboundPacket::ClientLeave { id } => {
-                let peer = self.peers.write().await.remove(&id).unwrap();
-                peer.on_leave().await;
-                self.event_handler.peer_leave(peer).await;
+                if id == self.my_id().await {
+                    // we left
+                } else {
+                    let peer = self.peers.write().await.remove(&id).unwrap();
+                    peer.on_leave().await;
+                    self.event_handler.peer_leave(peer).await;
+                }
             }
             protocol::ClientboundPacket::Message { sender, message } => {
-                let message = self.key.decrypt(&message);
+                let message = self
+                    .key
+                    .read()
+                    .await
+                    .as_ref()
+                    .expect("not in a room")
+                    .decrypt(&message);
                 let p = serde_json::from_str::<RelayMessageWrapper>(&message).unwrap();
                 if p.sender == sender {
                     self.on_relay(sender, p.inner).await;
@@ -107,7 +125,9 @@ impl Instance {
                     warn!("dropping packet with inconsistent sender")
                 }
             }
-            protocol::ClientboundPacket::RoomInfo { .. } => {}
+            protocol::ClientboundPacket::RoomInfo { hash, user_count } => {
+                self.event_handler.room_info(hash, user_count).await;
+            }
         }
     }
 
@@ -121,24 +141,36 @@ impl Instance {
         }
     }
 
-    pub async fn send_relay(&self, recipient: Option<usize>, inner: RelayMessage) {
-        debug!("(relay) -> ({recipient:?}) {inner:?}");
+    pub async fn send_packet(&self, packet: ServerboundPacket) {
         self.conn
             .send
             .write()
             .await
-            .send(ServerboundPacket::Relay {
-                recipient,
-                message: self.key.encrypt(
+            .send(packet)
+            .await
+            .expect("why?");
+    }
+
+    pub async fn send_relay(&self, recipient: Option<usize>, inner: RelayMessage) {
+        debug!("(relay) -> ({recipient:?}) {inner:?}");
+        self.send_packet(ServerboundPacket::Relay {
+            recipient,
+            // TODO handle this error
+            message: self
+                .key
+                .read()
+                .await
+                .as_ref()
+                .expect("not in a room")
+                .encrypt(
                     &serde_json::to_string(&RelayMessageWrapper {
                         sender: self.my_id.read().await.expect("not ready to relay yet.."),
                         inner,
                     })
                     .unwrap(),
                 ),
-            })
-            .await
-            .unwrap()
+        })
+        .await
     }
 
     pub async fn add_local_resource(&self, res: Box<dyn LocalResource>) {
diff --git a/client-native-lib/src/lib.rs b/client-native-lib/src/lib.rs
index dce21af..4fdf80f 100644
--- a/client-native-lib/src/lib.rs
+++ b/client-native-lib/src/lib.rs
@@ -27,7 +27,6 @@ pub use webrtc;
 
 pub struct Config {
     pub signaling_uri: String,
-    pub secret: String,
     pub username: String,
 }
 
@@ -47,18 +46,31 @@ pub trait LocalResource: Send + Sync + 'static {
     fn info(&self) -> ProvideInfo;
     fn on_request(&self, peer: Arc<Peer>) -> DynFut<()>;
 }
+
+#[allow(unused_variables)]
 pub trait EventHandler: Send + Sync + 'static {
-    fn peer_join(&self, peer: Arc<Peer>) -> DynFut<()>;
-    fn peer_leave(&self, peer: Arc<Peer>) -> DynFut<()>;
-    fn resource_added(&self, peer: Arc<Peer>, info: ProvideInfo) -> DynFut<()>;
-    fn resource_removed(&self, peer: Arc<Peer>, id: String) -> DynFut<()>;
+    fn peer_join(&self, peer: Arc<Peer>) -> DynFut<()> {
+        Box::pin(async move {})
+    }
+    fn peer_leave(&self, peer: Arc<Peer>) -> DynFut<()> {
+        Box::pin(async move {})
+    }
+    fn resource_added(&self, peer: Arc<Peer>, info: ProvideInfo) -> DynFut<()> {
+        Box::pin(async move {})
+    }
+    fn resource_removed(&self, peer: Arc<Peer>, id: String) -> DynFut<()> {
+        Box::pin(async move {})
+    }
     fn resource_connected(
         &self,
         peer: Arc<Peer>,
         resource: &ProvideInfo,
         channel: TransportChannel,
     ) -> DynFut<()>;
-    fn on_relay(&self, _peer: Arc<Peer>, _message: &RelayMessage) -> DynFut<()> {
+    fn on_relay(&self, peer: Arc<Peer>, message: &RelayMessage) -> DynFut<()> {
+        Box::pin(async move {})
+    }
+    fn room_info(&self, hash: String, user_count: usize) -> DynFut<()> {
         Box::pin(async move {})
     }
 }