async_client: Properly handle the EventResult for our timeline.

examples/login.rs

@@ -7,17 +7,23 @@ use matrix_nio::{
     events::{
         collections::all::RoomEvent,
         room::message::{MessageEvent, MessageEventContent, TextMessageEventContent},
+        EventResult,
     },
     AsyncClient, AsyncClientConfig, Room, SyncSettings,
 };
 
-async fn async_cb(room: Arc<RwLock<Room>>, event: Arc<RoomEvent>) {
+async fn async_cb(room: Arc<RwLock<Room>>, event: Arc<EventResult<RoomEvent>>) {
     let room = room.read().unwrap();
+    let event = if let EventResult::Ok(event) = &*event {
+        event
+    } else {
+        return;
+    };
     if let RoomEvent::RoomMessage(MessageEvent {
         content: MessageEventContent::Text(TextMessageEventContent { body: msg_body, .. }),
         sender,
         ..
-    }) = &*event
+    }) = event
     {
         let user = room.members.get(&sender.to_string()).unwrap();
         println!(

src/async_client.rs

@@ -24,7 +24,7 @@ use crate::session::Session;
 use crate::VERSION;
 
 type RoomEventCallbackF =
-    Box<dyn FnMut(Arc<RwLock<Room>>, Arc<RoomEvent>) -> BoxFuture<'static, ()> + Send>;
+    Box<dyn FnMut(Arc<RwLock<Room>>, Arc<EventResult<RoomEvent>>) -> BoxFuture<'static, ()> + Send>;
 
 #[derive(Clone)]
 pub struct AsyncClient {
@@ -163,7 +163,7 @@ impl AsyncClient {
 
     pub fn add_event_future<C: 'static>(
         &mut self,
-        mut callback: impl FnMut(Arc<RwLock<Room>>, Arc<RoomEvent>) -> C + 'static + Send,
+        mut callback: impl FnMut(Arc<RwLock<Room>>, Arc<EventResult<RoomEvent>>) -> C + 'static + Send,
     ) where
         C: Future<Output = ()> + Send,
     {
@@ -226,11 +226,6 @@ impl AsyncClient {
             };
 
             for event in &room.timeline.events {
-                let event = match event.clone().into_result() {
-                    Ok(e) => e,
-                    Err(e) => continue,
-                };
-
                 {
                     let mut client = self.base_client.write().unwrap();
                     client.receive_joined_timeline_event(&room_id, &event);

src/base_client.rs

@@ -3,6 +3,7 @@ use std::collections::HashMap;
 use crate::api::r0 as api;
 use crate::events::collections::all::{RoomEvent, StateEvent};
 use crate::events::room::member::{MemberEvent, MembershipState};
+use crate::events::EventResult;
 use crate::session::Session;
 use std::sync::{Arc, RwLock};
 
@@ -215,9 +216,18 @@ impl Client {
     ///
     /// Returns true if the membership list of the room changed, false
     /// otherwise.
-    pub fn receive_joined_timeline_event(&mut self, room_id: &RoomId, event: &RoomEvent) -> bool {
+    pub fn receive_joined_timeline_event(
-        let mut room = self.get_or_create_room(room_id).write().unwrap();
+        &mut self,
-        room.receive_timeline_event(event)
+        room_id: &RoomId,
+        event: &EventResult<RoomEvent>,
+    ) -> bool {
+        match event {
+            EventResult::Ok(e) => {
+                let mut room = self.get_or_create_room(room_id).write().unwrap();
+                room.receive_timeline_event(e)
+            }
+            _ => false,
+        }
     }
 
     /// Receive a state event for a joined room and update the client state.