✨ Add rooms topics management

src/matrix_interface/client.rs

@@ -1,4 +1,5 @@
 // TODO: make a choice: mpsc vs flume.
+use std::cell::RefCell;
 use std::sync::Arc;
 use std::time::Duration;
 
@@ -13,24 +14,27 @@ use matrix_sdk::{
     config::SyncSettings,
     event_handler::Ctx,
     room::Room as MatrixRoom,
-    ruma::events::{
-        key::verification::{
-            done::{OriginalSyncKeyVerificationDoneEvent, ToDeviceKeyVerificationDoneEvent},
-            key::{OriginalSyncKeyVerificationKeyEvent, ToDeviceKeyVerificationKeyEvent},
-            request::ToDeviceKeyVerificationRequestEvent,
-            start::{OriginalSyncKeyVerificationStartEvent, ToDeviceKeyVerificationStartEvent},
+    ruma::{
+        events::{
+            key::verification::{
+                done::{OriginalSyncKeyVerificationDoneEvent, ToDeviceKeyVerificationDoneEvent},
+                key::{OriginalSyncKeyVerificationKeyEvent, ToDeviceKeyVerificationKeyEvent},
+                request::ToDeviceKeyVerificationRequestEvent,
+                start::{OriginalSyncKeyVerificationStartEvent, ToDeviceKeyVerificationStartEvent},
+            },
+            presence::PresenceEvent,
+            reaction::ReactionEventContent,
+            room::{
+                member::{OriginalSyncRoomMemberEvent, RoomMemberEventContent},
+                message::RoomMessageEventContent,
+                name::RoomNameEventContent,
+                redaction::OriginalSyncRoomRedactionEvent,
+                topic::RoomTopicEventContent,
+            },
+            typing::SyncTypingEvent,
+            SyncMessageLikeEvent, SyncStateEvent,
         },
-        presence::PresenceEvent,
-        reaction::ReactionEventContent,
-        room::{
-            member::{OriginalSyncRoomMemberEvent, RoomMemberEventContent},
-            message::RoomMessageEventContent,
-            name::RoomNameEventContent,
-            redaction::OriginalSyncRoomRedactionEvent,
-            topic::RoomTopicEventContent,
-        },
-        typing::SyncTypingEvent,
-        SyncMessageLikeEvent, SyncStateEvent,
+        OwnedRoomId,
     },
     Client as MatrixClient,
 };
@@ -45,14 +49,23 @@ pub enum ClientError {
     Matrix(#[from] matrix_sdk::Error),
 }
 
+pub struct RoomTopicEvent(pub OwnedRoomId, pub String);
+
 #[derive(Clone)]
 struct Senders {
     rooms_sender: flume::Sender<Room>,
+    room_topic_sender: flume::Sender<RoomTopicEvent>,
 }
 
 impl Senders {
-    fn new(rooms_sender: flume::Sender<Room>) -> Self {
-        Self { rooms_sender }
+    fn new(
+        rooms_sender: flume::Sender<Room>,
+        room_topic_sender: flume::Sender<RoomTopicEvent>,
+    ) -> Self {
+        Self {
+            rooms_sender,
+            room_topic_sender,
+        }
     }
 }
 
@@ -65,13 +78,17 @@ pub struct Client {
 }
 
 impl Client {
-    pub fn new(client: Arc<MatrixClient>, rooms_sender: flume::Sender<Room>) -> Self {
+    pub fn new(
+        client: Arc<MatrixClient>,
+        rooms_sender: flume::Sender<Room>,
+        room_topic_sender: flume::Sender<RoomTopicEvent>,
+    ) -> Self {
         Self {
             initialized: false,
             client: Some(client),
             load_handle: None,
             sync_handle: None,
-            senders: Senders::new(rooms_sender),
+            senders: Senders::new(rooms_sender, room_topic_sender),
         }
     }
 
@@ -91,21 +108,25 @@ impl Client {
         dbg!(_ev);
     }
 
-    async fn on_room_topic_event(ev: SyncStateEvent<RoomTopicEventContent>, room: MatrixRoom) {
+    async fn on_room_topic_event(
+        ev: SyncStateEvent<RoomTopicEventContent>,
+        room: MatrixRoom,
+        senders: Ctx<Senders>,
+    ) {
         debug!("== on_room_topic_event ==");
         dbg!(&ev);
-        // if let SyncStateEvent::Original(ev) = ev {
-        //     let room_id = room.room_id().to_owned();
-        //     let store = reactive_store.read().unwrap().to_owned();
 
-        //     if let Some(store_room) = store.rooms.get(&room_id) {
-        //         // store_room.write().unwrap().topic = Some(ev.content.topic);
-        //         // let _ = reactive_store.write(store);
-        //         println!("HOP");
-        //     } else {
-        //         println!("No room with \"{room_id}\" id known");
-        //     }
-        // }
+        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
+            {
+                error!("Unable to publish the \"{}\" new topic: {}", room_id, err);
+            }
+        }
     }
 
     async fn on_room_member_event(ev: SyncStateEvent<RoomMemberEventContent>, _room: MatrixRoom) {
@@ -221,7 +242,9 @@ 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 matrix_client = Arc::new(
             MatrixClient::builder()
@@ -231,7 +254,7 @@ impl Client {
                 .unwrap(),
         );
 
-        let mut client = Client::new(matrix_client.clone(), rooms_sender);
+        let mut client = Client::new(matrix_client.clone(), rooms_sender, room_topic_sender);
 
         tokio::spawn({
             async move {
@@ -243,6 +266,7 @@ impl Client {
             matrix_client,
             tx,
             rooms_receiver,
+            room_topic_receiver,
         }
     }
 
@@ -277,9 +301,14 @@ impl Client {
 
         for matrix_rooms in vec![joined_matrix_rooms_ref, invited_matrix_rooms_ref] {
             for matrix_room in matrix_rooms.iter() {
+                let topic = match matrix_room.topic() {
+                    None => None,
+                    Some(topic) => Some(RefCell::new(topic)),
+                };
+
                 let room = Room::new(
                     Arc::new(matrix_room.to_owned()),
-                    None,
+                    topic,
                     matrix_room.is_direct().await.ok(),
                 );
                 if let Err(err) = rooms_sender.send_async(room).await {

src/matrix_interface/requester.rs

@@ -3,6 +3,7 @@ use std::sync::Arc;
 use matrix_sdk::Client as MatrixClient;
 use tokio::sync::mpsc::UnboundedSender;
 
+use super::client::RoomTopicEvent;
 use super::worker_tasks::{oneshot, LoginStyle, WorkerTask};
 use crate::base::Room;
 
@@ -11,6 +12,7 @@ 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>,
 }
 
 impl Requester {