From 15f22441826983120a940fda00e5cfa39dddd7b3 Mon Sep 17 00:00:00 2001
From: metamuffin <metamuffin@disroot.org>
Date: Sun, 11 Dec 2022 10:24:32 +0100
Subject: list remote resource (native gui)

---
 client-native-gui/src/main.rs     | 43 +++++++++++++++++++++++++++++----------
 client-native-lib/src/instance.rs |  3 ++-
 client-native-lib/src/protocol.rs |  6 +++---
 3 files changed, 37 insertions(+), 15 deletions(-)

diff --git a/client-native-gui/src/main.rs b/client-native-gui/src/main.rs
index c95ac68..c973fb6 100644
--- a/client-native-gui/src/main.rs
+++ b/client-native-gui/src/main.rs
@@ -2,17 +2,19 @@
 
 use async_std::task::block_on;
 use client_native_lib::{
-    instance::Instance, peer::Peer, protocol::RelayMessage, Config, EventHandler,
+    instance::Instance,
+    peer::Peer,
+    protocol::{ProvideInfo, RelayMessage},
+    Config, EventHandler,
 };
-use eframe::{egui, epaint::ahash::HashMap};
+use eframe::egui;
 use egui::{Ui, Visuals};
 use std::{
-    future::Future,
+    collections::{HashMap, HashSet},
     ops::Deref,
-    pin::Pin,
     sync::{Arc, RwLock},
 };
-use tokio::task::{block_in_place, JoinHandle};
+use tokio::task::JoinHandle;
 
 #[tokio::main]
 async fn main() {
@@ -37,30 +39,33 @@ async fn main() {
 }
 
 enum App {
-    Prejoin(String),
+    Prejoin(String, String),
     Joining(Option<JoinHandle<Ingame>>),
     Ingame(Ingame),
 }
 
 impl App {
     pub fn new() -> Self {
-        Self::Prejoin("longtest".to_string())
+        Self::Prejoin("longtest".to_string(), "blub".to_string())
     }
 }
 
 impl eframe::App for App {
     fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
         egui::CentralPanel::default().show(ctx, |ui| match self {
-            App::Prejoin(secret) => {
+            App::Prejoin(secret, username) => {
                 ui.heading("Join a meeting");
                 ui.label("Room secret:");
                 ui.text_edit_singleline(secret);
+                ui.label("Username:");
+                ui.text_edit_singleline(username);
                 if ui.button("Join").clicked() {
                     let secret = secret.clone();
+                    let username = username.clone();
                     *self = Self::Joining(Some(tokio::spawn(async move {
                         Ingame::new(Config {
                             secret,
-                            username: "blub".to_string(),
+                            username,
                             signaling_uri: "wss://meet.metamuffin.org".to_string(),
                         })
                         .await
@@ -95,8 +100,16 @@ impl Ingame {
     }
 
     pub fn ui(&self, ui: &mut Ui) {
-        for (pid, peer) in self.handler.peers.read().unwrap().deref() {
-            ui.collapsing(peer.display_name(), |ui| {});
+        for (_pid, peer) in self.handler.peers.read().unwrap().deref() {
+            ui.collapsing(peer.display_name(), |ui| {
+                for (_rid, resource) in peer.resources.iter() {
+                    ui.label(&format!(
+                        "{} {} {:?}",
+                        resource.id, resource.kind, resource.label
+                    ));
+                    if ui.button("Request").clicked() {}
+                }
+            });
         }
     }
 }
@@ -107,6 +120,7 @@ struct Handler {
 
 struct GuiPeer {
     peer: Arc<Peer>,
+    resources: HashMap<String, ProvideInfo>,
     username: Option<String>,
 }
 
@@ -134,6 +148,7 @@ impl EventHandler for Handler {
         self.peers.write().unwrap().insert(
             peer.id,
             GuiPeer {
+                resources: HashMap::new(),
                 peer: peer.clone(),
                 username: None,
             },
@@ -154,6 +169,9 @@ impl EventHandler for Handler {
         peer: std::sync::Arc<client_native_lib::peer::Peer>,
         info: client_native_lib::protocol::ProvideInfo,
     ) -> client_native_lib::DynFut<()> {
+        if let Some(gp) = self.peers.write().unwrap().get_mut(&peer.id) {
+            gp.resources.insert(info.id.clone(), info);
+        }
         Box::pin(async move {})
     }
 
@@ -162,6 +180,9 @@ impl EventHandler for Handler {
         peer: std::sync::Arc<client_native_lib::peer::Peer>,
         id: String,
     ) -> client_native_lib::DynFut<()> {
+        if let Some(gp) = self.peers.write().unwrap().get_mut(&peer.id) {
+            gp.resources.remove(&id);
+        }
         Box::pin(async move {})
     }
 
diff --git a/client-native-lib/src/instance.rs b/client-native-lib/src/instance.rs
index 74e6f3d..3edf50a 100644
--- a/client-native-lib/src/instance.rs
+++ b/client-native-lib/src/instance.rs
@@ -113,7 +113,8 @@ impl Instance {
     pub async fn on_relay(&self, sender: usize, p: RelayMessage) {
         debug!("(relay) <- ({sender}) {p:?}");
         if let Some(peer) = self.peers.read().await.get(&sender) {
-            peer.on_relay(p).await
+            peer.on_relay(p.clone()).await;
+            self.event_handler.on_relay(peer.to_owned(), &p).await;
         } else {
             warn!("got a packet from a non-existent peer")
         }
diff --git a/client-native-lib/src/protocol.rs b/client-native-lib/src/protocol.rs
index c361f6b..b7d0b89 100644
--- a/client-native-lib/src/protocol.rs
+++ b/client-native-lib/src/protocol.rs
@@ -49,21 +49,21 @@ pub enum RelayMessage {
     IceCandidate(RTCIceCandidateInit),
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
 #[serde(rename_all = "snake_case")]
 pub enum ChatMesssage {
     Text(String),
     Image(String),
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
 #[serde(rename_all = "snake_case")]
 pub enum TrackKind {
     Audio,
     Video,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
 pub struct ProvideInfo {
     pub id: String,
     pub kind: String, // not an enum so we dont fail if we dont support it
-- 
cgit v1.2.3-70-g09d2