♻️ Replace flume with tokio and share Matrix client infos to chats

- Remove of the flume dependency.
- Add the capability to share data provided by the Matrix client to the ChatsWindow. Indeed, until the 0.6 Dioxus
  release, each window runs in a separate virtual DOM so the context and Fermi states are completely seperate
  (cf. https://discord.com/channels/899851952891002890/1188206938215948378).

src/matrix_interface/client.rs

@@ -1,12 +1,11 @@
-// TODO: make a choice: mpsc vs flume.
 use std::cell::RefCell;
 use std::sync::Arc;
 use std::time::Duration;
 
 use dioxus::prelude::to_owned;
-use flume::{bounded, unbounded};
-use flume::{Receiver as FlumeReceiver, Sender};
+use tokio::sync::broadcast::Sender;
 use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver};
+use tokio::sync::{broadcast, oneshot};
 use tokio::task::JoinHandle;
 use tracing::{debug, error, warn};
 
@@ -39,7 +38,7 @@ use matrix_sdk::{
     Client as MatrixClient,
 };
 
-use super::requester::Requester;
+use super::requester::{Receivers, Requester};
 use super::worker_tasks::{LoginStyle, WorkerTask};
 use crate::base::Room;
 
@@ -49,19 +48,17 @@ pub enum ClientError {
     Matrix(#[from] matrix_sdk::Error),
 }
 
+#[derive(Clone)]
 pub struct RoomTopicEvent(pub OwnedRoomId, pub String);
 
 #[derive(Clone)]
 struct Senders {
-    rooms_sender: flume::Sender<Room>,
-    room_topic_sender: flume::Sender<RoomTopicEvent>,
+    rooms_sender: Sender<Room>,
+    room_topic_sender: Sender<RoomTopicEvent>,
 }
 
 impl Senders {
-    fn new(
-        rooms_sender: flume::Sender<Room>,
-        room_topic_sender: flume::Sender<RoomTopicEvent>,
-    ) -> Self {
+    fn new(rooms_sender: Sender<Room>, room_topic_sender: Sender<RoomTopicEvent>) -> Self {
         Self {
             rooms_sender,
             room_topic_sender,
@@ -80,8 +77,8 @@ pub struct Client {
 impl Client {
     pub fn new(
         client: Arc<MatrixClient>,
-        rooms_sender: flume::Sender<Room>,
-        room_topic_sender: flume::Sender<RoomTopicEvent>,
+        rooms_sender: Sender<Room>,
+        room_topic_sender: Sender<RoomTopicEvent>,
     ) -> Self {
         Self {
             initialized: false,
@@ -105,7 +102,6 @@ impl Client {
 
     async fn on_sync_state_event(_ev: SyncStateEvent<RoomNameEventContent>, _room: MatrixRoom) {
         debug!("== on_sync_state_event ==");
-        dbg!(_ev);
     }
 
     async fn on_room_topic_event(
@@ -113,25 +109,20 @@ impl Client {
         room: MatrixRoom,
         senders: Ctx<Senders>,
     ) {
-        debug!("== on_room_topic_event ==");
-        dbg!(&ev);
-
         if let SyncStateEvent::Original(ev) = ev {
             let room_topic_sender = &senders.room_topic_sender;
             let room_id = room.room_id();
 
-            if let Err(err) = room_topic_sender
-                .send_async(RoomTopicEvent(room_id.to_owned(), ev.content.topic))
-                .await
+            if let Err(err) =
+                room_topic_sender.send(RoomTopicEvent(room_id.to_owned(), ev.content.topic))
             {
                 error!("Unable to publish the \"{}\" new topic: {}", room_id, err);
             }
         }
     }
 
-    async fn on_room_member_event(ev: SyncStateEvent<RoomMemberEventContent>, _room: MatrixRoom) {
+    async fn on_room_member_event(_ev: SyncStateEvent<RoomMemberEventContent>, _room: MatrixRoom) {
         debug!("== on_room_member_event ==");
-        dbg!(ev);
         // // dbg!(room);
         // if room.invited_members_count() > 0 {
         //     dbg!(room);
@@ -165,12 +156,11 @@ impl Client {
     }
 
     async fn on_original_sync_room_member_event(
-        ev: OriginalSyncRoomMemberEvent,
+        _ev: OriginalSyncRoomMemberEvent,
         room: MatrixRoom,
         _client: MatrixClient,
     ) {
         debug!("== on_original_sync_room_member_event ==");
-        dbg!(ev);
         let room_id = room.room_id();
         dbg!(room_id);
 
@@ -243,8 +233,8 @@ impl Client {
     pub async fn spawn(homeserver_url: String) -> Requester {
         let (tx, rx) = unbounded_channel::<WorkerTask>();
 
-        let (rooms_sender, rooms_receiver) = unbounded::<Room>();
-        let (room_topic_sender, room_topic_receiver) = unbounded::<RoomTopicEvent>();
+        let (rooms_sender, rooms_receiver) = broadcast::channel(32);
+        let (room_topic_sender, room_topic_receiver) = broadcast::channel(32);
 
         let matrix_client = Arc::new(
             MatrixClient::builder()
@@ -265,8 +255,10 @@ impl Client {
         Requester {
             matrix_client,
             tx,
-            rooms_receiver,
-            room_topic_receiver,
+            receivers: Receivers {
+                rooms_receiver: RefCell::new(rooms_receiver),
+                room_topic_receiver: RefCell::new(room_topic_receiver),
+            },
         }
     }
 
@@ -311,7 +303,8 @@ impl Client {
                     topic,
                     matrix_room.is_direct().await.ok(),
                 );
-                if let Err(err) = rooms_sender.send_async(room).await {
+
+                if let Err(err) = rooms_sender.send(room) {
                     warn!("Error: {}", err);
                 }
             }
@@ -344,7 +337,7 @@ impl Client {
             }
         }
 
-        let (synchronized_tx, synchronized_rx) = bounded(1);
+        let (synchronized_tx, synchronized_rx) = oneshot::channel();
 
         self.sync_handle = tokio::spawn({
             async move {
@@ -370,7 +363,7 @@ impl Client {
         Ok(())
     }
 
-    fn start_background_tasks(&mut self, synchronized_rx: FlumeReceiver<bool>) {
+    fn start_background_tasks(&mut self, synchronized_rx: oneshot::Receiver<bool>) {
         let client = self.client.clone().unwrap();
         let rooms_sender_ref = &self.senders.rooms_sender;
 
@@ -378,7 +371,7 @@ impl Client {
             to_owned![rooms_sender_ref];
 
             async move {
-                if let Err(err) = synchronized_rx.recv() {
+                if let Err(err) = synchronized_rx.await {
                     error!("Unable to setup the rx channel notifying that the Matrix client is now synchronized ({err})");
                 }
 

src/matrix_interface/requester.rs

@@ -1,18 +1,34 @@
+use std::cell::RefCell;
 use std::sync::Arc;
 
 use matrix_sdk::Client as MatrixClient;
+use tokio::sync::broadcast::Receiver;
 use tokio::sync::mpsc::UnboundedSender;
 
 use super::client::RoomTopicEvent;
 use super::worker_tasks::{oneshot, LoginStyle, WorkerTask};
 use crate::base::Room;
 
+#[derive(Debug)]
+pub struct Receivers {
+    pub rooms_receiver: RefCell<Receiver<Room>>,
+    pub room_topic_receiver: RefCell<Receiver<RoomTopicEvent>>,
+}
+
+impl Clone for Receivers {
+    fn clone(&self) -> Self {
+        Self {
+            rooms_receiver: RefCell::new(self.rooms_receiver.borrow().resubscribe()),
+            room_topic_receiver: RefCell::new(self.room_topic_receiver.borrow().resubscribe()),
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct Requester {
     pub matrix_client: Arc<MatrixClient>,
     pub tx: UnboundedSender<WorkerTask>,
-    pub rooms_receiver: flume::Receiver<Room>,
-    pub room_topic_receiver: flume::Receiver<RoomTopicEvent>,
+    pub receivers: Receivers,
 }
 
 impl Requester {