Adrien/beau-gosse-du-92
1
0
Fork 0
Code Issues 2 Pull Requests 1 Packages Projects Releases Wiki Activity

⚡️ Remove the periodic pooling to get the rooms (joined or not)

Browse Source
This commit is contained in:
Adrien
2023-12-31 15:04:18 +01:00
parent 66f4ba6a7e
commit 04628ae10d
5 changed files with 170 additions and 114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
src/base.rs
View File

@@ -16,7 +16,7 @@ use tokio::select;
use tracing::{debug, error, warn}; use tracing::{debug, error, warn};
use crate::components::chats_window::interface::Interface as ChatsWinInterface; use crate::components::chats_window::interface::Interface as ChatsWinInterface;
use crate::matrix_interface::client::{Client, RoomTopicEvent}; use crate::matrix_interface::client::{Client, RoomEvent};
use crate::matrix_interface::requester::{Receivers, Requester}; use crate::matrix_interface::requester::{Receivers, Requester};
use crate::matrix_interface::worker_tasks::LoginStyle; use crate::matrix_interface::worker_tasks::LoginStyle;
@@ -133,21 +133,30 @@ impl AppSettings {
pub static APP_SETTINGS: AtomRef<AppSettings> = AtomRef(|_| AppSettings::new()); pub static APP_SETTINGS: AtomRef<AppSettings> = AtomRef(|_| AppSettings::new());
async fn on_room(room: Room, rooms_ref: &UseAtomRef<ByIdRooms>) { async fn on_room(room_id: OwnedRoomId, room: Room, rooms_ref: &UseAtomRef<ByIdRooms>) {
let room_id = room.id();
// TODO: Update rooms // TODO: Update rooms
rooms_ref rooms_ref
.write() .write()
.insert(room_id, RefCell::<Room>::new(room)); .insert(room_id, RefCell::<Room>::new(room));
} }
pub async fn on_room_topic(room_topic_event: RoomTopicEvent, rooms_ref: &UseAtomRef<ByIdRooms>) { async fn on_joining_invitation(
let room_id = room_topic_event.0; room_id: OwnedRoomId,
room: Room,
rooms_ref: &UseAtomRef<ByIdRooms>,
) {
debug!(
"You're invited to join the \"{}\" room",
room.name().unwrap()
);
// TODO: Update rooms
rooms_ref
.write()
.insert(room_id, RefCell::<Room>::new(room));
}
pub async fn on_room_topic(room_id: OwnedRoomId, topic: String, rooms_ref: &UseAtomRef<ByIdRooms>) {
if let Some(room_ref) = rooms_ref.read().get(&room_id) { if let Some(room_ref) = rooms_ref.read().get(&room_id) {
let topic = room_topic_event.1;
let mut room = room_ref.borrow_mut(); let mut room = room_ref.borrow_mut();
room.topic = Some(RefCell::new(topic)); room.topic = Some(RefCell::new(topic));
} else { } else {
@@ -161,21 +170,20 @@ pub async fn sync_rooms(
rooms_ref: UseAtomRef<ByIdRooms>, rooms_ref: UseAtomRef<ByIdRooms>,
) { ) {
if let Some(_is_logged) = rx.next().await { if let Some(_is_logged) = rx.next().await {
let mut rooms_receiver = receivers.rooms_receiver.borrow_mut(); let mut rooms_receiver = receivers.room_receiver.borrow_mut();
let mut room_topic_receiver = receivers.room_topic_receiver.borrow_mut();
loop { loop {
// TODO: Remove select if no more receivers will be used.
select! { select! {
res = rooms_receiver.recv() => { res = rooms_receiver.recv() => {
if let Ok(room) = res { if let Ok(room_event) = res {
on_room(room, &rooms_ref).await; match room_event {
RoomEvent::MemberEvent(room_id, room) => on_room(room_id, room, &rooms_ref).await,
RoomEvent::InviteEvent(room_id, room) => on_joining_invitation(room_id, room, &rooms_ref).await,
RoomEvent::TopicEvent(room_id, topic) => on_room_topic(room_id, topic, &rooms_ref).await,
};
} }
}, },
res = room_topic_receiver.recv() => {
if let Ok(room_topic_event) = res {
on_room_topic(room_topic_event, &rooms_ref).await;
}
}
} }
} }
} }
@@ -195,7 +203,8 @@ pub async fn login(
if homeserver_url.is_some() && username.is_some() && password.is_some() { if homeserver_url.is_some() && username.is_some() && password.is_some() {
let client = Client::spawn(homeserver_url.unwrap()).await; let client = Client::spawn(homeserver_url.unwrap()).await;
client.init().await; // TODO: Handle error case.
let _ = client.init().await;
match client match client
.login(LoginStyle::Password(username.unwrap(), password.unwrap())) .login(LoginStyle::Password(username.unwrap(), password.unwrap()))

3
src/components/chats_window/mod.rs
View File

@@ -67,9 +67,10 @@ async fn handle_controls<'a>(
let mut displayed_room_ids = displayed_room_ids_ref.write(); let mut displayed_room_ids = displayed_room_ids_ref.write();
match displayed_room_ids.take(&room_id) { match displayed_room_ids.take(&room_id) {
Some(_) => { Some(_) => {
error!("Toggle {} already dispayed... close it", room_id); error!("{} room already dispayed... close it", room_id);
} }
None => { None => {
error!("{} room isn't dispayed... open it", room_id);
displayed_room_ids.insert(room_id); displayed_room_ids.insert(room_id);
} }
} }

224
src/matrix_interface/client.rs
View File

@@ -1,12 +1,11 @@
use std::sync::Arc; use std::sync::Arc;
use std::time::Duration;
use dioxus::prelude::*; use dioxus::prelude::*;
use tokio::sync::broadcast;
use tokio::sync::broadcast::Sender; use tokio::sync::broadcast::Sender;
use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver}; use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver};
use tokio::sync::{broadcast, oneshot};
use tokio::task::JoinHandle; use tokio::task::JoinHandle;
use tracing::{debug, error, warn}; use tracing::{debug, error};
use matrix_sdk::{ use matrix_sdk::{
config::SyncSettings, config::SyncSettings,
@@ -23,7 +22,9 @@ use matrix_sdk::{
presence::PresenceEvent, presence::PresenceEvent,
reaction::ReactionEventContent, reaction::ReactionEventContent,
room::{ room::{
member::{OriginalSyncRoomMemberEvent, RoomMemberEventContent}, member::{
OriginalSyncRoomMemberEvent, RoomMemberEventContent, StrippedRoomMemberEvent,
},
message::RoomMessageEventContent, message::RoomMessageEventContent,
name::RoomNameEventContent, name::RoomNameEventContent,
redaction::OriginalSyncRoomRedactionEvent, redaction::OriginalSyncRoomRedactionEvent,
@@ -34,7 +35,7 @@ use matrix_sdk::{
}, },
OwnedRoomId, OwnedRoomId,
}, },
Client as MatrixClient, Client as MatrixClient, RoomState as MatrixRoomState,
}; };
use super::requester::{Receivers, Requester}; use super::requester::{Receivers, Requester};
@@ -48,43 +49,37 @@ pub enum ClientError {
} }
#[derive(Clone)] #[derive(Clone)]
pub struct RoomTopicEvent(pub OwnedRoomId, pub String); pub enum RoomEvent {
TopicEvent(OwnedRoomId, String),
MemberEvent(OwnedRoomId, Room),
InviteEvent(OwnedRoomId, Room),
}
#[derive(Clone)] #[derive(Clone)]
struct Senders { struct Senders {
rooms_sender: Sender<Room>, room_sender: Sender<RoomEvent>,
room_topic_sender: Sender<RoomTopicEvent>,
} }
impl Senders { impl Senders {
fn new(rooms_sender: Sender<Room>, room_topic_sender: Sender<RoomTopicEvent>) -> Self { fn new(room_sender: Sender<RoomEvent>) -> Self {
Self { Self { room_sender }
rooms_sender,
room_topic_sender,
}
} }
} }
pub struct Client { pub struct Client {
initialized: bool, initialized: bool,
client: Option<Arc<MatrixClient>>, client: Option<Arc<MatrixClient>>,
load_handle: Option<JoinHandle<()>>,
sync_handle: Option<JoinHandle<()>>, sync_handle: Option<JoinHandle<()>>,
senders: Senders, senders: Senders,
} }
impl Client { impl Client {
pub fn new( pub fn new(client: Arc<MatrixClient>, room_sender: Sender<RoomEvent>) -> Self {
client: Arc<MatrixClient>,
rooms_sender: Sender<Room>,
room_topic_sender: Sender<RoomTopicEvent>,
) -> Self {
Self { Self {
initialized: false, initialized: false,
client: Some(client), client: Some(client),
load_handle: None,
sync_handle: None, sync_handle: None,
senders: Senders::new(rooms_sender, room_topic_sender), senders: Senders::new(room_sender),
} }
} }
@@ -99,34 +94,88 @@ impl Client {
dbg!(_ev); dbg!(_ev);
} }
async fn on_sync_state_event(_ev: SyncStateEvent<RoomNameEventContent>, _room: MatrixRoom) { async fn on_sync_state_event(ev: SyncStateEvent<RoomNameEventContent>, _room: MatrixRoom) {
debug!("== on_sync_state_event =="); error!("== on_sync_state_event ==");
if let SyncStateEvent::Original(ev) = ev {
dbg!(ev);
}
}
async fn on_stripped_room_member_event(
ev: StrippedRoomMemberEvent,
matrix_client: MatrixClient,
matrix_room: MatrixRoom,
senders: Ctx<Senders>,
) {
if ev.state_key == matrix_client.user_id().unwrap() {
if matrix_room.state() == MatrixRoomState::Invited {
let room_id = matrix_room.room_id();
let room_topic = matrix_room.topic().map(RefCell::new);
let room = Room::new(
Arc::new(matrix_room.to_owned()),
room_topic,
matrix_room.is_direct().await.ok(),
);
if let Err(err) = senders
.room_sender
.send(RoomEvent::InviteEvent(room_id.to_owned(), room))
{
error!(
"Unable to publish the new room with \"{}\" id: {}",
room_id, err
);
}
}
}
} }
async fn on_room_topic_event( async fn on_room_topic_event(
ev: SyncStateEvent<RoomTopicEventContent>, ev: SyncStateEvent<RoomTopicEventContent>,
room: MatrixRoom, matrix_room: MatrixRoom,
senders: Ctx<Senders>, senders: Ctx<Senders>,
) { ) {
if let SyncStateEvent::Original(ev) = ev { if let SyncStateEvent::Original(ev) = ev {
let room_topic_sender = &senders.room_topic_sender; let room_id = matrix_room.room_id();
let room_id = room.room_id();
if let Err(err) = if let Err(err) = senders
room_topic_sender.send(RoomTopicEvent(room_id.to_owned(), ev.content.topic)) .room_sender
.send(RoomEvent::TopicEvent(room_id.to_owned(), ev.content.topic))
{ {
error!("Unable to publish the \"{}\" new topic: {}", room_id, err); 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(
debug!("== on_room_member_event =="); ev: SyncStateEvent<RoomMemberEventContent>,
// // dbg!(room); matrix_room: MatrixRoom,
// if room.invited_members_count() > 0 { senders: Ctx<Senders>,
// dbg!(room); ) {
// } error!("== on_room_member_event ==");
// if let SyncStateEvent::Original(ev) = ev {} // dbg!(&matrix_room);
dbg!(matrix_room.room_id());
dbg!(ev.membership());
if let SyncStateEvent::Original(_ev) = ev {
let room_sender = &senders.room_sender;
let room_id = matrix_room.room_id();
let room_topic = matrix_room.topic().map(RefCell::new);
let room = Room::new(
Arc::new(matrix_room.to_owned()),
room_topic,
matrix_room.is_direct().await.ok(),
);
if let Err(err) = room_sender.send(RoomEvent::MemberEvent(room_id.to_owned(), room)) {
error!(
"Unable to publish the new room with \"{}\" id: {}",
room_id, err
);
}
}
} }
async fn on_sync_message_like_room_message_event( async fn on_sync_message_like_room_message_event(
@@ -230,8 +279,7 @@ impl Client {
pub async fn spawn(homeserver_url: String) -> Requester { pub async fn spawn(homeserver_url: String) -> Requester {
let (tx, rx) = unbounded_channel::<WorkerTask>(); let (tx, rx) = unbounded_channel::<WorkerTask>();
let (rooms_sender, rooms_receiver) = broadcast::channel(32); let (room_sender, room_receiver) = broadcast::channel(32);
let (room_topic_sender, room_topic_receiver) = broadcast::channel(32);
let matrix_client = Arc::new( let matrix_client = Arc::new(
MatrixClient::builder() MatrixClient::builder()
@@ -241,7 +289,7 @@ impl Client {
.unwrap(), .unwrap(),
); );
let mut client = Client::new(matrix_client.clone(), rooms_sender, room_topic_sender); let mut client = Client::new(matrix_client.clone(), room_sender);
tokio::spawn({ tokio::spawn({
async move { async move {
@@ -253,8 +301,7 @@ impl Client {
matrix_client, matrix_client,
tx, tx,
receivers: Receivers { receivers: Receivers {
rooms_receiver: RefCell::new(rooms_receiver), room_receiver: RefCell::new(room_receiver),
room_topic_receiver: RefCell::new(room_topic_receiver),
}, },
} }
} }
@@ -267,6 +314,7 @@ impl Client {
let _ = client.add_event_handler(Client::on_sync_typing_event); let _ = client.add_event_handler(Client::on_sync_typing_event);
let _ = client.add_event_handler(Client::on_presence_event); let _ = client.add_event_handler(Client::on_presence_event);
let _ = client.add_event_handler(Client::on_sync_state_event); let _ = client.add_event_handler(Client::on_sync_state_event);
let _ = client.add_event_handler(Client::on_stripped_room_member_event);
let _ = client.add_event_handler(Client::on_sync_message_like_room_message_event); let _ = client.add_event_handler(Client::on_sync_message_like_room_message_event);
let _ = client.add_event_handler(Client::on_sync_message_like_reaction_event); let _ = client.add_event_handler(Client::on_sync_message_like_reaction_event);
let _ = client.add_event_handler(Client::on_original_sync_room_redaction_event); let _ = client.add_event_handler(Client::on_original_sync_room_redaction_event);
@@ -284,36 +332,36 @@ impl Client {
self.initialized = true; self.initialized = true;
} }
async fn refresh_rooms(matrix_client: &MatrixClient, rooms_sender: &Sender<Room>) { // async fn refresh_rooms(matrix_client: &MatrixClient, room_sender: &Sender<RoomMemberEvent>) {
let joined_matrix_rooms_ref = &matrix_client.joined_rooms(); // let joined_matrix_rooms_ref = &matrix_client.joined_rooms();
let invited_matrix_rooms_ref = &matrix_client.invited_rooms(); // let invited_matrix_rooms_ref = &matrix_client.invited_rooms();
for matrix_rooms in [joined_matrix_rooms_ref, invited_matrix_rooms_ref] { // for matrix_rooms in [joined_matrix_rooms_ref, invited_matrix_rooms_ref] {
for matrix_room in matrix_rooms.iter() { // for matrix_room in matrix_rooms.iter() {
let topic = matrix_room.topic().map(RefCell::new); // let topic = matrix_room.topic().map(RefCell::new);
let room = Room::new( // let room = Room::new(
Arc::new(matrix_room.to_owned()), // Arc::new(matrix_room.to_owned()),
topic, // topic,
matrix_room.is_direct().await.ok(), // matrix_room.is_direct().await.ok(),
); // );
if let Err(err) = rooms_sender.send(room) { // if let Err(err) = room_sender.send(room) {
warn!("Error: {}", err); // warn!("Error: {}", err);
} // }
} // }
} // }
} // }
async fn refresh_rooms_forever(matrix_client: &MatrixClient, rooms_channel: &Sender<Room>) { // async fn refresh_rooms_forever(matrix_client: &MatrixClient, room_channel: &Sender<RoomEvent>) {
// TODO: Add interval to config // // TODO: Add interval to config
let mut interval = tokio::time::interval(Duration::from_secs(5)); // let mut interval = tokio::time::interval(Duration::from_secs(5));
loop { // loop {
Self::refresh_rooms(matrix_client, rooms_channel).await; // // Self::refresh_rooms(matrix_client, room_channel).await;
interval.tick().await; // interval.tick().await;
} // }
} // }
async fn login_and_sync(&mut self, style: LoginStyle) -> anyhow::Result<()> { async fn login_and_sync(&mut self, style: LoginStyle) -> anyhow::Result<()> {
let client = self.client.clone().unwrap(); let client = self.client.clone().unwrap();
@@ -330,7 +378,7 @@ impl Client {
} }
} }
let (synchronized_tx, synchronized_rx) = oneshot::channel(); // let (synchronized_tx, synchronized_rx) = oneshot::channel();
self.sync_handle = tokio::spawn({ self.sync_handle = tokio::spawn({
async move { async move {
@@ -339,9 +387,9 @@ impl Client {
debug!("User connected to the homeserver"); debug!("User connected to the homeserver");
if let Err(err) = synchronized_tx.send(true) { // if let Err(err) = synchronized_tx.send(true) {
warn!("Unable to notify that the Matrix client is now synchronized ({err})"); // warn!("Unable to notify that the Matrix client is now synchronized ({err})");
} // }
loop { loop {
let settings = SyncSettings::default(); let settings = SyncSettings::default();
@@ -351,32 +399,32 @@ impl Client {
}) })
.into(); .into();
self.start_background_tasks(synchronized_rx); // self.start_background_tasks(synchronized_rx);
Ok(()) Ok(())
} }
fn start_background_tasks(&mut self, synchronized_rx: oneshot::Receiver<bool>) { // fn start_background_tasks(&mut self, synchronized_rx: oneshot::Receiver<bool>) {
let client = self.client.clone().unwrap(); // let client = self.client.clone().unwrap();
let rooms_sender_ref = &self.senders.rooms_sender; // let room_sender_ref = &self.senders.room_sender;
self.load_handle = tokio::spawn({ // self.load_handle = tokio::spawn({
to_owned![rooms_sender_ref]; // to_owned![room_sender_ref];
async move { // async move {
if let Err(err) = synchronized_rx.await { // if let Err(err) = synchronized_rx.await {
error!("Unable to setup the rx channel notifying that the Matrix client is now synchronized ({err})"); // error!("Unable to setup the rx channel notifying that the Matrix client is now synchronized ({err})");
} // }
let rooms_refresh = Self::refresh_rooms_forever( // let rooms_refresh = Self::refresh_rooms_forever(
client.as_ref(), // client.as_ref(),
&rooms_sender_ref // &room_sender_ref
); // );
let ((),) = tokio::join!(rooms_refresh); // let ((),) = tokio::join!(rooms_refresh);
} // }
}) // })
.into(); // .into();
} // }
async fn work(&mut self, mut rx: UnboundedReceiver<WorkerTask>) { async fn work(&mut self, mut rx: UnboundedReceiver<WorkerTask>) {
loop { loop {

11
src/matrix_interface/requester.rs
View File

@@ -5,21 +5,18 @@ use matrix_sdk::Client as MatrixClient;
use tokio::sync::broadcast::Receiver; use tokio::sync::broadcast::Receiver;
use tokio::sync::mpsc::UnboundedSender; use tokio::sync::mpsc::UnboundedSender;
use super::client::RoomTopicEvent; use super::client::RoomEvent;
use super::worker_tasks::{LoginStyle, WorkerTask}; use super::worker_tasks::{LoginStyle, WorkerTask};
use crate::base::Room;
use crate::utils::oneshot; use crate::utils::oneshot;
pub struct Receivers { pub struct Receivers {
pub rooms_receiver: RefCell<Receiver<Room>>, pub room_receiver: RefCell<Receiver<RoomEvent>>,
pub room_topic_receiver: RefCell<Receiver<RoomTopicEvent>>,
} }
impl Clone for Receivers { impl Clone for Receivers {
fn clone(&self) -> Self { fn clone(&self) -> Self {
Self { Self {
rooms_receiver: RefCell::new(self.rooms_receiver.borrow().resubscribe()), room_receiver: RefCell::new(self.room_receiver.borrow().resubscribe()),
room_topic_receiver: RefCell::new(self.room_topic_receiver.borrow().resubscribe()),
} }
} }
} }
@@ -33,6 +30,7 @@ pub struct Requester {
impl Requester { impl Requester {
pub async fn init(&self) -> anyhow::Result<()> { pub async fn init(&self) -> anyhow::Result<()> {
let (reply, mut response) = oneshot(); let (reply, mut response) = oneshot();
// TODO: Handle error case. // TODO: Handle error case.
self.tx.send(WorkerTask::Init(reply)).unwrap(); self.tx.send(WorkerTask::Init(reply)).unwrap();
match response.recv().await { match response.recv().await {
@@ -43,6 +41,7 @@ impl Requester {
pub async fn login(&self, style: LoginStyle) -> anyhow::Result<()> { pub async fn login(&self, style: LoginStyle) -> anyhow::Result<()> {
let (reply, mut response) = oneshot(); let (reply, mut response) = oneshot();
// TODO: Handle error case. // TODO: Handle error case.
self.tx.send(WorkerTask::Login(style, reply)).unwrap(); self.tx.send(WorkerTask::Login(style, reply)).unwrap();
match response.recv().await { match response.recv().await {

1
src/utils.rs
View File

@@ -13,7 +13,6 @@ pub struct Sender<T>(_Sender<T>);
// TODO: Handle error // TODO: Handle error
impl<T> Sender<T> { impl<T> Sender<T> {
pub(super) async fn send(self, t: T) { pub(super) async fn send(self, t: T) {
// self.0.send(t).unwrap();
let _ = self.0.send(t).await; let _ = self.0.send(t).await;
} }
} }