From 5657931dd606845bd50a609b3f5ac9a1294213c6 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Fri, 4 Oct 2024 12:31:38 +0800
Subject: [PATCH 01/40] reduce complexity of send_read_receipt

---
 src/home/room_screen.rs | 65 +++++++++--------------------------------
 1 file changed, 13 insertions(+), 52 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index a836df4f..038ef098 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -962,49 +962,16 @@ impl RoomScreen{
         let Some(room_id) = self.room_id.as_ref() else { return };
         if let Some(ref mut index) = tl_state.prev_first_index {
             // to detect change of scroll when scroll ends
-            if *index != first_index {  
+            if *index != first_index {
                 // scroll changed         
-                self.fully_read_timer = cx.start_interval(5.0);
-                let time_now = std::time::Instant::now();
                 if first_index > *index {
-                    // Store visible event messages with current time into a hashmap
-                    let mut read_receipt_event = None;
-                    for r in first_index .. (first_index + portal_list.visible_items() + 1) {
-                        if let Some(v) = tl_state.items.get(r) {
-                            if let Some(e) = v.as_event().and_then(|f| f.event_id()) {
-                                read_receipt_event = Some(e.to_owned());
-                                if !tl_state.read_event_hashmap.contains_key(&e.to_string()) {
-                                    tl_state.read_event_hashmap.insert(
-                                        e.to_string(),
-                                        (room_id.clone(), e.to_owned(), time_now, false),
-                                    );
-                                }
-                            }
-                        }
-                    }
-                    if let Some(event_id) = read_receipt_event {
-                        submit_async_request(MatrixRequest::ReadReceipt { room_id: room_id.clone(), event_id });
-                    }
-                    let mut fully_read_receipt_event = None;
-                    // Implements sending fully read receipts when message is scrolled out of first row
-                    for r in *index..first_index {
-                        if let Some(v) = tl_state.items.get(r).clone() {
-                            if let Some(e) = v.as_event().and_then(|f| f.event_id()) {
-                                let mut to_remove = vec![];
-                                for (event_id_string, (_, event_id)) in &tl_state.marked_fully_read_queue {
-                                    if e == event_id {
-                                        fully_read_receipt_event = Some(event_id.clone());
-                                        to_remove.push(event_id_string.clone());
-                                    }
-                                }
-                                for r in to_remove {
-                                    tl_state.marked_fully_read_queue.remove(&r);
-                                }
-                            }
-                        }
-                    }
-                    if let Some(event_id) = fully_read_receipt_event {
-                        submit_async_request(MatrixRequest::FullyReadReceipt { room_id: room_id.clone(), event_id: event_id.clone()});
+                    cx.stop_timer(self.fully_read_timer);
+                    self.fully_read_timer = cx.start_interval(5.0);
+                    let index_to_send_read = first_index + portal_list.visible_items();
+                    if let Some(event_id) = tl_state.items.get(index_to_send_read)
+                        .and_then(|f|f.as_event()).and_then(|f|f.event_id()) {
+                        submit_async_request(MatrixRequest::ReadReceipt { room_id: room_id.clone(), event_id: event_id.to_owned() });
+                        tl_state.last_displayed_event = Some(event_id.to_owned());
                     }
                 }
                 *index = first_index;
@@ -1264,13 +1231,9 @@ impl Widget for RoomScreen {
 
         // Mark events as fully read after they have been displayed on screen for 5 seconds.
         if self.fully_read_timer.is_event(event).is_some() {
-            if let (Some(ref mut tl_state), Some(ref _room_id)) = (&mut self.tl_state, &self.room_id) {
-                for (k, (room, event, start, ref mut moved_to_queue)) in &mut tl_state.read_event_hashmap {
-                    if start.elapsed() > std::time::Duration::new(5, 0) && !*moved_to_queue{
-                        tl_state.marked_fully_read_queue.insert(k.clone(), (room.clone(), event.clone()));
-                        *moved_to_queue = true;
-                    }
-                }
+            if let (Some(ref mut tl_state), Some(ref room_id)) = (&mut self.tl_state, &self.room_id) {
+                let Some(last_displayed_event) = &tl_state.last_displayed_event else { return };
+                submit_async_request(MatrixRequest::FullyReadReceipt { room_id: room_id.clone(), event_id: last_displayed_event.clone()});
             }
             cx.stop_timer(self.fully_read_timer);
         }
@@ -1664,8 +1627,7 @@ impl RoomScreen {
                 saved_state: SavedState::default(),
                 message_highlight_animation_state: MessageHighlightAnimationState::default(),
                 prev_first_index: None,
-                read_event_hashmap: HashMap::new(),
-                marked_fully_read_queue: HashMap::new(),
+                last_displayed_event: None,
             };
             (new_tl_state, true)
         };
@@ -1918,8 +1880,7 @@ struct TimelineUiState {
     message_highlight_animation_state: MessageHighlightAnimationState,
 
     prev_first_index: Option<usize>,
-    read_event_hashmap: HashMap<String, (OwnedRoomId, OwnedEventId, Instant, bool)>,
-    marked_fully_read_queue: HashMap<String, (OwnedRoomId, OwnedEventId)>,
+    last_displayed_event: Option<OwnedEventId>,
 }
 
 /// The item index, scroll position, and optional unique IDs of the first `N` events

From bb92afbd4e5502fb593148ff6627583b20671b2a Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Fri, 4 Oct 2024 13:44:31 +0800
Subject: [PATCH 02/40] cleanup

---
 src/home/room_screen.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 038ef098..6622c815 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -967,9 +967,9 @@ impl RoomScreen{
                 if first_index > *index {
                     cx.stop_timer(self.fully_read_timer);
                     self.fully_read_timer = cx.start_interval(5.0);
-                    let index_to_send_read = first_index + portal_list.visible_items();
-                    if let Some(event_id) = tl_state.items.get(index_to_send_read)
-                        .and_then(|f|f.as_event()).and_then(|f|f.event_id()) {
+                    if let Some(event_id) = tl_state.items.get(first_index + portal_list.visible_items())
+                            .and_then(|f| f.as_event() )
+                            .and_then(|f| f.event_id() ) {
                         submit_async_request(MatrixRequest::ReadReceipt { room_id: room_id.clone(), event_id: event_id.to_owned() });
                         tl_state.last_displayed_event = Some(event_id.to_owned());
                     }

From 925536594f05226eaee06ce6f2073a8c4c71b8c5 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Fri, 4 Oct 2024 14:07:31 +0800
Subject: [PATCH 03/40] removed unnecessary import

---
 src/home/room_screen.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 6622c815..4a365d36 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -1,7 +1,7 @@
 //! A room screen is the UI page that displays a single Room's timeline of events/messages
 //! along with a message input bar at the bottom.
 
-use std::{borrow::Cow, collections::{BTreeMap, HashMap}, ops::{DerefMut, Range}, sync::{Arc, Mutex}, time::Instant};
+use std::{borrow::Cow, collections::BTreeMap, ops::{DerefMut, Range}, sync::{Arc, Mutex}};
 
 use imbl::Vector;
 use makepad_widgets::*;

From 24be468fb95b5254994be9471c24eceb474f059a Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Thu, 10 Oct 2024 23:37:07 +0800
Subject: [PATCH 04/40] added unread_message_badge

---
 src/home/room_screen.rs | 64 +++++++++++++++++++++++++++++++++++++----
 1 file changed, 59 insertions(+), 5 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 37aaa5fd..73293a22 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -656,26 +656,56 @@ live_design! {
             flow: Down,
             align: {x: 1.0, y: 1.0},
             margin: {right: 15.0, bottom: 15.0},
-            visible: false,
+            visible: true,
 
             jump_to_bottom_button = <IconButton> {
                 width: 50, height: 50,
                 draw_icon: {svg_file: (ICO_JUMP_TO_BOTTOM)},
-                icon_walk: {width: 20, height: 20, margin: {top: 10, right: 4.5} }
-                // draw a circular background for the button
+                icon_walk: {width: 20, height: 20, margin: {top: 10, right: 4.5} },
                 draw_bg: {
                     instance background_color: #edededee,
                     fn pixel(self) -> vec4 {
                         let sdf = Sdf2d::viewport(self.pos * self.rect_size);
                         let c = self.rect_size * 0.5;
-                        sdf.circle(c.x, c.x, c.x)
+                        sdf.circle(c.x, c.x, c.x);
                         sdf.fill_keep(self.background_color);
                         return sdf.result
                     }
                 }
             }
-        }
 
+            // Badge overlay for unread messages
+            unread_message_badge = <View> {
+                width: 20, height: 20,
+                margin: {top: -10.0, right: 15.0},
+                visible: true,
+                show_bg: true,
+                draw_bg: {
+                    instance background_color: (#5D5E5E)
+        
+                    fn pixel(self) -> vec4 {
+                        let sdf = Sdf2d::viewport(self.pos * self.rect_size);
+                        let c = self.rect_size * 0.5;
+                        sdf.circle(c.x, c.x, c.x);
+                        sdf.fill_keep(self.background_color);
+                        return sdf.result;
+                    }
+                }
+
+                // Text to display the unread message count
+                label = <Label> {
+                    width: Fill,
+                    height: Fill,
+                    text: "0",
+                    margin: {top: 4.0, left: 5.0},
+                    draw_text:{
+                        color: #ffffff,
+                        wrap: Ellipsis,
+                        text_style: <USERNAME_TEXT_STYLE>{ font_size: 8. }
+                    }
+                }
+            }
+        }
     }
 
     IMG_SMILEY_FACE_BW = dep("crate://self/resources/img/smiley_face_bw.png")
@@ -948,6 +978,8 @@ impl RoomScreen{
         actions: &ActionsBuf,
     ) {
         let portal_list = self.portal_list(id!(list));
+        let jump_to_bottom_view = self.view(id!(jump_to_bottom_view));
+
         //stopped scrolling
         if portal_list.scrolled(actions) {
             return;
@@ -1001,6 +1033,13 @@ impl RoomScreen{
                     }
                     if let Some(event_id) = fully_read_receipt_event {
                         submit_async_request(MatrixRequest::FullyReadReceipt { room_id: room_id.clone(), event_id: event_id.clone()});
+                        // Clear the unread message badge number count when send fully read receipt
+                        // Temporary hack
+                        // -TODO integrate and calculate the leftover message after PR 172 is merged.
+                        let unread_message_badge = jump_to_bottom_view.view(id!(unread_message_badge));
+                        unread_message_badge.label(id!(label)).set_text("");
+                        unread_message_badge.set_visible(false);
+
                     }
                 }
                 *index = first_index;
@@ -1417,6 +1456,7 @@ impl RoomScreen {
     /// Redraws this RoomScreen view if any updates were applied.
     fn process_timeline_updates(&mut self, cx: &mut Cx) {
         let portal_list = self.portal_list(id!(list));
+        let jump_to_bottom_view = self.view(id!(jump_to_bottom_view));
         let curr_first_id = portal_list.first_id();
         let Some(tl) = self.tl_state.as_mut() else { return };
 
@@ -1501,6 +1541,20 @@ impl RoomScreen {
                         // log!("Timeline::handle_event(): changed_indices: {changed_indices:?}, items len: {}\ncontent drawn: {:#?}\nprofile drawn: {:#?}", items.len(), tl.content_drawn_since_last_update, tl.profile_drawn_since_last_update);
                     }
                     tl.items = new_items;
+                    // Set number of unread messages to unread_notification_badge
+                    if let Some(room_id) = &self.room_id {
+                        if let Some(num_unread) = get_client()
+                        .and_then(|c| c.get_room(room_id)).map(|room| room.num_unread_messages()) {
+                            let unread_message_badge = jump_to_bottom_view.view(id!(unread_message_badge));
+                            if num_unread > 0 {
+                                unread_message_badge.label(id!(label)).set_text(&format!("{}",num_unread));
+                                unread_message_badge.set_visible(true);
+                            } else {
+                                unread_message_badge.set_visible(false);
+                            }
+                        }
+                    }
+                    
                 }
                 TimelineUpdate::TimelineStartReached => {
                     log!("Timeline::handle_event(): timeline start reached for room {}", tl.room_id);

From c1d1ab6046f1b031f7067a5a31998ca09645f419 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Fri, 11 Oct 2024 09:53:59 +0800
Subject: [PATCH 05/40] remove unneccesary changes

---
 src/home/room_screen.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 73293a22..fedc38ea 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -656,18 +656,19 @@ live_design! {
             flow: Down,
             align: {x: 1.0, y: 1.0},
             margin: {right: 15.0, bottom: 15.0},
-            visible: true,
+            visible: false,
 
             jump_to_bottom_button = <IconButton> {
                 width: 50, height: 50,
                 draw_icon: {svg_file: (ICO_JUMP_TO_BOTTOM)},
-                icon_walk: {width: 20, height: 20, margin: {top: 10, right: 4.5} },
+                icon_walk: {width: 20, height: 20, margin: {top: 10, right: 4.5} }
+                // draw a circular background for the button
                 draw_bg: {
                     instance background_color: #edededee,
                     fn pixel(self) -> vec4 {
                         let sdf = Sdf2d::viewport(self.pos * self.rect_size);
                         let c = self.rect_size * 0.5;
-                        sdf.circle(c.x, c.x, c.x);
+                        sdf.circle(c.x, c.x, c.x)
                         sdf.fill_keep(self.background_color);
                         return sdf.result
                     }

From 35c597739c2907bc099a4614c810dc252589bdd4 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Fri, 11 Oct 2024 17:16:49 +0800
Subject: [PATCH 06/40] add jump to top

---
 resources/icon_jump_to_top.svg | 38 ++++++++++++++++++++++++++++++++++
 src/home/room_screen.rs        |  1 +
 2 files changed, 39 insertions(+)
 create mode 100644 resources/icon_jump_to_top.svg

diff --git a/resources/icon_jump_to_top.svg b/resources/icon_jump_to_top.svg
new file mode 100644
index 00000000..c14e3a1a
--- /dev/null
+++ b/resources/icon_jump_to_top.svg
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   width="256"
+   height="256"
+   viewBox="0 0 256 256"
+   version="1.1"
+   id="svg1"
+   sodipodi:docname="icon_jump_to_bottom.svg"
+   inkscape:version="1.3.2 (091e20e, 2023-11-25, custom)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs1" />
+  <sodipodi:namedview
+     id="namedview1"
+     pagecolor="#ffffff"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     inkscape:zoom="3.1679688"
+     inkscape:cx="127.84217"
+     inkscape:cy="128"
+     inkscape:window-width="1920"
+     inkscape:window-height="1046"
+     inkscape:window-x="-11"
+     inkscape:window-y="-11"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg1" />
+  <path
+     d="m 129.4,105.7 c 1.7,0 3.4,0.7 4.7,2.1 l 72,72 c 2.8,2.8 2.8,7.3 0,10.1 -2.8,2.8 -7.3,2.8 -10.1,0 l -67.3,-67.3 -67.3,67.3 c -2.8,2.8 -7.3,2.8 -10.1,0 -2.8,-2.8 -2.8,-7.3 0,-10.1 l 72,-72 c 1.3,-1.4 3,-2.1 4.7,-2.1 z"
+     fill="#000000"
+     id="path1" />
+</svg>
diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index fedc38ea..21dde177 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -61,6 +61,7 @@ live_design! {
     ICO_ADD = dep("crate://self/resources/icon_add.svg")
     ICO_CLOSE = dep("crate://self/resources/icons/close.svg")
     ICO_JUMP_TO_BOTTOM = dep("crate://self/resources/icon_jump_to_bottom.svg")
+    ICO_JUMP_TO_TOP = dep("crate://self/resources/icon_jump_to_top.svg")
 
     TEXT_SUB = {
         font_size: (10),

From bc2aa8c0f61f76286ae1adf0d17c86ff663368a5 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Fri, 11 Oct 2024 23:24:17 +0800
Subject: [PATCH 07/40] added unread_notification_badge

---
 src/home/room_screen.rs | 78 +++++++++++++++++++++++++++++++++--------
 1 file changed, 64 insertions(+), 14 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 21dde177..2b96276c 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -48,6 +48,7 @@ live_design! {
     import crate::shared::avatar::Avatar;
     import crate::shared::text_or_image::TextOrImage;
     import crate::shared::html_or_plaintext::*;
+    import crate::shared::icon_button::*;
     import crate::profile::user_profile::UserProfileSlidingPane;
     import crate::shared::typing_animation::TypingAnimation;
 
@@ -654,15 +655,16 @@ live_design! {
         jump_to_bottom_view = <View> {
             width: Fill,
             height: Fill,
-            flow: Down,
+            flow: Overlay,
             align: {x: 1.0, y: 1.0},
-            margin: {right: 15.0, bottom: 15.0},
+            margin: {right: 15.0, bottom: 0},
             visible: false,
-
-            jump_to_bottom_button = <IconButton> {
+            jump_button = <RobrixIconButton> {
                 width: 50, height: 50,
                 draw_icon: {svg_file: (ICO_JUMP_TO_BOTTOM)},
-                icon_walk: {width: 20, height: 20, margin: {top: 10, right: 4.5} }
+                padding: 15,
+                margin: {bottom : 20}
+                icon_walk: {width: 20, height: 10, margin: {top: 0, right: 100} }
                 // draw a circular background for the button
                 draw_bg: {
                     instance background_color: #edededee,
@@ -674,13 +676,53 @@ live_design! {
                         return sdf.result
                     }
                 }
+                draw_icon: {
+                    instance color: #000
+                    instance color_hover: #000
+                    // 180.0: point upwards
+                    uniform rotation_angle: 180.0,
+                }
+                animator: {
+                    jump_button = {
+                        default: down
+                        down = {
+                            redraw: true,
+                            from: { all: Forward {duration: 2.0} }
+                            ease: ExpDecay {d1: 0.80, d2: 0.97}
+                            apply: { draw_icon: {rotation_angle: 0.0} }
+                        }
+                        up = {
+                            redraw: true,
+                            from: { all: Forward {duration: 0.5} }
+                            ease: ExpDecay {d1: 0.80, d2: 0.97}
+                            apply: { draw_icon: {rotation_angle: 180.0} }
+                        }
+                    }
+                }
+            }
+            // Badge overlay for unread messages
+            unread_notification_badge = <View> {
+                width: 12, height: 12,
+                abs_pos: vec2(-20.0, 85.0)
+                visible: false,
+                show_bg: true,
+                draw_bg: {
+                    instance background_color: (#58DC6C)
+        
+                    fn pixel(self) -> vec4 {
+                        let sdf = Sdf2d::viewport(self.pos * self.rect_size);
+                        let c = self.rect_size * 0.5;
+                        sdf.circle(c.x, c.x, c.x);
+                        sdf.fill_keep(self.background_color);
+                        return sdf.result;
+                    }
+                }
             }
-
             // Badge overlay for unread messages
             unread_message_badge = <View> {
                 width: 20, height: 20,
-                margin: {top: -10.0, right: 15.0},
-                visible: true,
+                abs_pos: vec2(-15.0, 135.0)
+                visible: false,
                 show_bg: true,
                 draw_bg: {
                     instance background_color: (#5D5E5E)
@@ -1279,14 +1321,16 @@ impl Widget for RoomScreen {
 
                 const SCROLL_TO_BOTTOM_NUM_ANIMATION_ITEMS: usize = 30;
                 const SCROLL_TO_BOTTOM_SPEED: f64 = 90.0;
-                if self.button(id!(jump_to_bottom_button)).clicked(&actions) {
-                    portal_list.smooth_scroll_to_end(
+  
+                if let Some(ref mut but) = self.button(id!(jump_button)).borrow_mut() {
+                    if but.clicked(&actions) {
+                        portal_list.smooth_scroll_to_end(
                         cx,
                         SCROLL_TO_BOTTOM_NUM_ANIMATION_ITEMS,
                         SCROLL_TO_BOTTOM_SPEED,
-                    );
-                    jump_to_bottom_view.set_visible(false);
-                    self.redraw(cx);
+                        );
+                        jump_to_bottom_view.set_visible(false);
+                    }
                 }
             }
 
@@ -1545,12 +1589,18 @@ impl RoomScreen {
                     tl.items = new_items;
                     // Set number of unread messages to unread_notification_badge
                     if let Some(room_id) = &self.room_id {
-                        if let Some(num_unread) = get_client()
+                        if let Some(num_unread)= get_client()
                         .and_then(|c| c.get_room(room_id)).map(|room| room.num_unread_messages()) {
+                            println!("num_unread {:?}", num_unread);
+                            let unread_notifications_badge = jump_to_bottom_view.view(id!(unread_notifications_badge));
                             let unread_message_badge = jump_to_bottom_view.view(id!(unread_message_badge));
                             if num_unread > 0 {
                                 unread_message_badge.label(id!(label)).set_text(&format!("{}",num_unread));
                                 unread_message_badge.set_visible(true);
+                                unread_notifications_badge.set_visible(false);
+                                if let Some(ref mut but) = jump_to_bottom_view.button(id!(jump_button)).borrow_mut() {
+                                    but.animator_play(cx, id!(jump_button.down));
+                                }
                             } else {
                                 unread_message_badge.set_visible(false);
                             }

From e4c1268913e4adbe2714255234956de709aca449 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Sun, 13 Oct 2024 21:35:07 +0800
Subject: [PATCH 08/40] Added scroll past marker

---
 src/home/room_screen.rs | 66 ++++++++++++++++-------------------------
 1 file changed, 25 insertions(+), 41 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 4ef558aa..ab16893e 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -1422,6 +1422,11 @@ impl Widget for RoomScreen {
                             (item, ItemDrawnStatus::both_drawn())
                         }
                         TimelineItemKind::Virtual(VirtualTimelineItem::ReadMarker) => {
+                            let prev_event = tl_items.get(tl_idx.saturating_sub(1));
+                            if let Some(event_id) = prev_event.and_then(|timeline|timeline.as_event()).and_then(|e|e.event_id()) {
+                                tl_state.read_marker = Some((tl_idx,event_id.to_owned()));
+                                tl_state.scroll_pass_read_marker = false;
+                            }
                             let item = list.item(cx, item_id, live_id!(ReadMarker));
                             (item, ItemDrawnStatus::both_drawn())
                         }
@@ -1710,6 +1715,8 @@ impl RoomScreen {
                 last_scrolled_index: usize::MAX,
                 prev_first_index: None,
                 last_displayed_event: None,
+                read_marker: None,
+                scroll_pass_read_marker: false,
             };
             (new_tl_state, true)
         };
@@ -1852,54 +1859,28 @@ impl RoomScreen {
             return;
         }
         let first_index = portal_list.first_id();
-
+        
         let Some(tl_state) = self.tl_state.as_mut() else { return };
         let Some(room_id) = self.room_id.as_ref() else { return };
         if let Some(ref mut index) = tl_state.prev_first_index {
             // to detect change of scroll when scroll ends
             if *index != first_index {
-                // scroll changed
-                self.fully_read_timer = cx.start_interval(5.0);
-                let time_now = std::time::Instant::now();
-                if first_index > *index {
-                    // Store visible event messages with current time into a hashmap
-                    let mut read_receipt_event = None;
-                    for r in first_index .. (first_index + portal_list.visible_items() + 1) {
-                        if let Some(v) = tl_state.items.get(r) {
-                            if let Some(e) = v.as_event().and_then(|f| f.event_id()) {
-                                read_receipt_event = Some(e.to_owned());
-                                if !tl_state.read_event_hashmap.contains_key(&e.to_string()) {
-                                    tl_state.read_event_hashmap.insert(
-                                        e.to_string(),
-                                        (room_id.clone(), e.to_owned(), time_now, false),
-                                    );
-                                }
-                            }
-                        }
-                    }
-                    if let Some(event_id) = read_receipt_event {
-                        submit_async_request(MatrixRequest::ReadReceipt { room_id: room_id.clone(), event_id });
+                // if the scroll ends on page that contains read marker, set scroll_pass_read_marker to true
+                if let Some((read_marker_index, _)) = tl_state.read_marker {
+                    if read_marker_index >= first_index && read_marker_index <= first_index + portal_list.visible_items() {
+                        tl_state.scroll_pass_read_marker = true;
                     }
-                    let mut fully_read_receipt_event = None;
-                    // Implements sending fully read receipts when message is scrolled out of first row
-                    for r in *index..first_index {
-                        if let Some(v) = tl_state.items.get(r).clone() {
-                            if let Some(e) = v.as_event().and_then(|f| f.event_id()) {
-                                let mut to_remove = vec![];
-                                for (event_id_string, (_, event_id)) in &tl_state.marked_fully_read_queue {
-                                    if e == event_id {
-                                        fully_read_receipt_event = Some(event_id.clone());
-                                        to_remove.push(event_id_string.clone());
-                                    }
-                                }
-                                for r in to_remove {
-                                    tl_state.marked_fully_read_queue.remove(&r);
-                                }
-                            }
-                        }
+                }
+                if first_index > *index {
+                    if tl_state.scroll_pass_read_marker {
+                        cx.stop_timer(self.fully_read_timer);
+                        self.fully_read_timer = cx.start_interval(5.0);
                     }
-                    if let Some(event_id) = fully_read_receipt_event {
-                        submit_async_request(MatrixRequest::FullyReadReceipt { room_id: room_id.clone(), event_id: event_id.clone()});
+                    if let Some(event_id) = tl_state.items.get(first_index + portal_list.visible_items())
+                            .and_then(|f| f.as_event() )
+                            .and_then(|f| f.event_id() ) {
+                        submit_async_request(MatrixRequest::ReadReceipt { room_id: room_id.clone(), event_id: event_id.to_owned() });
+                        tl_state.last_displayed_event = Some(event_id.to_owned());
                     }
                 }
                 *index = first_index;
@@ -2067,6 +2048,9 @@ struct TimelineUiState {
 
     prev_first_index: Option<usize>,
     last_displayed_event: Option<OwnedEventId>,
+    read_marker: Option<(usize, OwnedEventId)>,
+    /// Only send fully read receipt after scroll
+    scroll_pass_read_marker: bool,
 }
 
 /// The item index, scroll position, and optional unique IDs of the first `N` events

From 3884a66677504620fa66f912f72a35bfc43c403d Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Mon, 14 Oct 2024 16:47:19 +0800
Subject: [PATCH 09/40] wip

---
 src/home/room_screen.rs | 79 +++++++++++++++++++++++++++++++----------
 1 file changed, 60 insertions(+), 19 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 116dfcc2..cf790cab 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -7,13 +7,12 @@ use imbl::Vector;
 use makepad_widgets::*;
 use matrix_sdk::{
     ruma::{
-        events::room::{
+        api::client::read_marker, events::room::{
             message::{
                 FormattedBody, ImageMessageEventContent, LocationMessageEventContent, MessageFormat, MessageType, NoticeMessageEventContent, RoomMessageEventContent, TextMessageEventContent
             },
             MediaSource,
-        },
-        matrix_uri::MatrixId, uint, EventId, MatrixToUri, MatrixUri, MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedRoomId, RoomId, UserId
+        }, matrix_uri::MatrixId, uint, EventId, MatrixToUri, MatrixUri, MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedRoomId, RoomId, UserId
     },
     OwnedServerName,
 };
@@ -1345,20 +1344,45 @@ impl Widget for RoomScreen {
                 let jump_to_bottom_view = self.view(id!(jump_to_bottom_view));
                 if portal_list.scrolled(&actions) {
                     // TODO: is_at_end() isn't perfect, see: <https://github.com/makepad/makepad/issues/517>
-                    jump_to_bottom_view.set_visible(!portal_list.is_at_end());
+                    if let Some(ref mut tl_state) = &mut self.tl_state {
+                        //println!("tl_state.scroll_pass_read_marker {:?} tl_state.read_marker {:?}",tl_state.scroll_pass_read_marker, tl_state.read_marker);
+                        if !tl_state.scroll_pass_read_marker && tl_state.read_marker.is_some() {
+                            jump_to_bottom_view.set_visible(true);
+                            if let Some(ref mut but) = jump_to_bottom_view.button(id!(jump_button)).borrow_mut() {
+                                but.animator_play(cx, id!(jump_button.up));
+                            }
+                        } else {
+                            if !portal_list.is_at_end() {
+                                jump_to_bottom_view.set_visible(true);
+                                if let Some(ref mut but) = jump_to_bottom_view.button(id!(jump_button)).borrow_mut() {
+                                    but.animator_play(cx, id!(jump_button.down));
+                                }
+                            }
+                        }
+                    }
+                    
                 }
 
                 const SCROLL_TO_BOTTOM_NUM_ANIMATION_ITEMS: usize = 30;
                 const SCROLL_TO_BOTTOM_SPEED: f64 = 90.0;
-  
                 if let Some(ref mut but) = self.button(id!(jump_button)).borrow_mut() {
+                    
                     if but.clicked(&actions) {
-                        portal_list.smooth_scroll_to_end(
-                        cx,
-                        SCROLL_TO_BOTTOM_NUM_ANIMATION_ITEMS,
-                        SCROLL_TO_BOTTOM_SPEED,
-                        );
-                        jump_to_bottom_view.set_visible(false);
+                        if but.animator_in_state(cx, id!(jump_button.down) ) {
+                            portal_list.smooth_scroll_to_end(
+                                cx,
+                                SCROLL_TO_BOTTOM_NUM_ANIMATION_ITEMS,
+                                SCROLL_TO_BOTTOM_SPEED,
+                            );
+                            but.animator_play(cx, id!(jump_button.up));
+                        } else {
+                            if let Some(ref mut tl_state) = &mut self.tl_state {
+                                if let Some((read_marker_index, _)) = tl_state.read_marker.clone() {
+                                    portal_list.smooth_scroll_to(cx, read_marker_index, SCROLL_TO_BOTTOM_SPEED);    
+                                }
+                            }
+                        }
+                        
                     }
                 }
             }
@@ -1498,12 +1522,7 @@ impl Widget for RoomScreen {
                             item.label(id!(date)).set_text(&text);
                             (item, ItemDrawnStatus::both_drawn())
                         }
-                        TimelineItemKind::Virtual(VirtualTimelineItem::ReadMarker) => {
-                            let prev_event = tl_items.get(tl_idx.saturating_sub(1));
-                            if let Some(event_id) = prev_event.and_then(|timeline|timeline.as_event()).and_then(|e|e.event_id()) {
-                                tl_state.read_marker = Some((tl_idx,event_id.to_owned()));
-                                tl_state.scroll_pass_read_marker = false;
-                            }
+                        TimelineItemKind::Virtual(VirtualTimelineItem::ReadMarker) => { 
                             let item = list.item(cx, item_id, live_id!(ReadMarker));
                             (item, ItemDrawnStatus::both_drawn())
                         }
@@ -1637,7 +1656,29 @@ impl RoomScreen {
                             }
                         }
                     }
-                    
+                    for (tl_idx, timeline) in tl.items.iter().enumerate() {
+                        if let Some(v_timeline) = timeline.as_virtual() {
+                            match v_timeline {
+                                VirtualTimelineItem::ReadMarker => {
+                                    if let Some(previous_event_id) = tl.items.get(tl_idx.saturating_sub(1))
+                                    .and_then(|f|f.as_event())
+                                    .and_then(|f|f.event_id()) {
+                                        if let Some((s, event_id)) = &mut tl.read_marker {
+                                            if previous_event_id.to_owned() != *event_id {
+                                                *event_id = previous_event_id.to_owned();
+                                                tl.scroll_pass_read_marker = false;
+                                                println!("virtual timeline tl_idx {:?}", tl_idx);
+                                            } 
+                                        } else {
+                                            tl.read_marker = Some((tl_idx,previous_event_id.to_owned()));
+                                            tl.scroll_pass_read_marker = false;
+                                        }
+                                    }
+                                }
+                                _ => {}
+                            }
+                        }
+                    }
                 }
                 TimelineUpdate::PaginationRunning(direction) => {
                     if direction == PaginationDirection::Backwards {
@@ -2146,7 +2187,7 @@ struct TimelineUiState {
 
     prev_first_index: Option<usize>,
     last_displayed_event: Option<OwnedEventId>,
-    read_marker: Option<(usize, OwnedEventId)>,
+    read_marker: Option<(usize,OwnedEventId)>,
     /// Only send fully read receipt after scroll
     scroll_pass_read_marker: bool,
 }

From b7a83a0f2f02450dec566bada4e95f368ef4177e Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Tue, 15 Oct 2024 11:49:36 +0800
Subject: [PATCH 10/40] send  read +jtb

---
 src/home/room_screen.rs | 230 ++++++++++++++++++++++------------------
 src/sliding_sync.rs     |  21 +++-
 2 files changed, 142 insertions(+), 109 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index cf790cab..7f248f34 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -32,7 +32,7 @@ use crate::{
         html_or_plaintext::{HtmlOrPlaintextRef, HtmlOrPlaintextWidgetRefExt},
         text_or_image::{TextOrImageRef, TextOrImageWidgetRefExt},
         typing_animation::TypingAnimationWidgetExt,
-    }, sliding_sync::{get_client, submit_async_request, take_timeline_update_receiver, MatrixRequest, PaginationDirection}, utils::{self, unix_time_millis_to_datetime, MediaFormatConst}
+    }, sliding_sync::{get_client, submit_async_request, take_timeline_update_receiver, take_fully_read_event, MatrixRequest, PaginationDirection}, utils::{self, unix_time_millis_to_datetime, MediaFormatConst}
 };
 use rangemap::RangeSet;
 
@@ -653,7 +653,7 @@ live_design! {
             align: {x: 1.0, y: 1.0},
             margin: {right: 15.0, bottom: 0},
             visible: false,
-            jump_button = <RobrixIconButton> {
+            jump_to_bottom_button = <RobrixIconButton> {
                 width: 50, height: 50,
                 draw_icon: {svg_file: (ICO_JUMP_TO_BOTTOM)},
                 padding: 15,
@@ -674,50 +674,14 @@ live_design! {
                 draw_icon: {
                     instance color: #000
                     instance color_hover: #000
-                    // 180.0: point upwards
-                    uniform rotation_angle: 180.0,
-                }
-                animator: {
-                    jump_button = {
-                        default: down
-                        down = {
-                            redraw: true,
-                            from: { all: Forward {duration: 2.0} }
-                            ease: ExpDecay {d1: 0.80, d2: 0.97}
-                            apply: { draw_icon: {rotation_angle: 0.0} }
-                        }
-                        up = {
-                            redraw: true,
-                            from: { all: Forward {duration: 0.5} }
-                            ease: ExpDecay {d1: 0.80, d2: 0.97}
-                            apply: { draw_icon: {rotation_angle: 180.0} }
-                        }
-                    }
-                }
-            }
-            // Badge overlay for unread messages
-            unread_notification_badge = <View> {
-                width: 12, height: 12,
-                abs_pos: vec2(-20.0, 15.0)
-                visible: true,
-                show_bg: true,
-                draw_bg: {
-                    instance background_color: (#58DC6C)
-        
-                    fn pixel(self) -> vec4 {
-                        let sdf = Sdf2d::viewport(self.pos * self.rect_size);
-                        let c = self.rect_size * 0.5;
-                        sdf.circle(c.x, c.x, c.x);
-                        sdf.fill_keep(self.background_color);
-                        return sdf.result;
-                    }
+                    uniform rotation_angle: 0.0,
                 }
             }
             // Badge overlay for unread messages
             unread_message_badge = <View> {
                 width: 20, height: 20,
-                abs_pos: vec2(-15.0, 72.0)
-                visible: true,
+                margin: { right: 15, bottom: 10},
+                visible: false,
                 show_bg: true,
                 draw_bg: {
                     instance background_color: (#5D5E5E)
@@ -745,7 +709,59 @@ live_design! {
                 }
             }
         }
-
+        jump_to_top_view = <View> {
+            width: Fill,
+            height: 80,
+            flow: Overlay,
+            align: {x: 1.0, y: 1.0},
+            margin: {right: 15.0, bottom: 30},
+            visible: true,
+            jump_to_top_button = <RobrixIconButton> {
+                width: 50, height: 50,
+                draw_icon: {svg_file: (ICO_JUMP_TO_BOTTOM)},
+                padding: 15,
+                margin: {bottom : 20}
+                icon_walk: {width: 20, height: 10, margin: {top: 0, right: 100} }
+                // draw a circular background for the button
+                draw_bg: {
+                    instance background_color: #edededee,
+                    fn pixel(self) -> vec4 {
+                        let sdf = Sdf2d::viewport(self.pos * self.rect_size);
+                        let c = self.rect_size * 0.5;
+                        sdf.circle(c.x, c.x, c.x)
+                        sdf.fill_keep(self.background_color);
+                        return sdf.result
+                    }
+    
+                }
+                draw_icon: {
+                    instance color: #000
+                    instance color_hover: #000
+                    // 180.0: point upwards
+                    uniform rotation_angle: 180.0,
+                }
+                
+            }
+            // Badge overlay for unread messages
+            unread_notification_badge = <View> {
+                width: 12, height: 12,
+                margin: { right: 19, bottom: 60},
+                visible: true,
+                show_bg: true,
+                draw_bg: {
+                    instance background_color: (#58DC6C)
+        
+                    fn pixel(self) -> vec4 {
+                        let sdf = Sdf2d::viewport(self.pos * self.rect_size);
+                        let c = self.rect_size * 0.5;
+                        sdf.circle(c.x, c.x, c.x);
+                        sdf.fill_keep(self.background_color);
+                        return sdf.result;
+                    }
+                }
+            }
+           
+        }
     }
 
     LocationPreview = {{LocationPreview}} {
@@ -1344,46 +1360,22 @@ impl Widget for RoomScreen {
                 let jump_to_bottom_view = self.view(id!(jump_to_bottom_view));
                 if portal_list.scrolled(&actions) {
                     // TODO: is_at_end() isn't perfect, see: <https://github.com/makepad/makepad/issues/517>
-                    if let Some(ref mut tl_state) = &mut self.tl_state {
-                        //println!("tl_state.scroll_pass_read_marker {:?} tl_state.read_marker {:?}",tl_state.scroll_pass_read_marker, tl_state.read_marker);
-                        if !tl_state.scroll_pass_read_marker && tl_state.read_marker.is_some() {
-                            jump_to_bottom_view.set_visible(true);
-                            if let Some(ref mut but) = jump_to_bottom_view.button(id!(jump_button)).borrow_mut() {
-                                but.animator_play(cx, id!(jump_button.up));
-                            }
-                        } else {
-                            if !portal_list.is_at_end() {
-                                jump_to_bottom_view.set_visible(true);
-                                if let Some(ref mut but) = jump_to_bottom_view.button(id!(jump_button)).borrow_mut() {
-                                    but.animator_play(cx, id!(jump_button.down));
-                                }
-                            }
-                        }
-                    }
-                    
+                    jump_to_bottom_view.set_visible(!portal_list.is_at_end());
                 }
 
                 const SCROLL_TO_BOTTOM_NUM_ANIMATION_ITEMS: usize = 30;
                 const SCROLL_TO_BOTTOM_SPEED: f64 = 90.0;
-                if let Some(ref mut but) = self.button(id!(jump_button)).borrow_mut() {
-                    
-                    if but.clicked(&actions) {
-                        if but.animator_in_state(cx, id!(jump_button.down) ) {
-                            portal_list.smooth_scroll_to_end(
-                                cx,
-                                SCROLL_TO_BOTTOM_NUM_ANIMATION_ITEMS,
-                                SCROLL_TO_BOTTOM_SPEED,
-                            );
-                            but.animator_play(cx, id!(jump_button.up));
-                        } else {
-                            if let Some(ref mut tl_state) = &mut self.tl_state {
-                                if let Some((read_marker_index, _)) = tl_state.read_marker.clone() {
-                                    portal_list.smooth_scroll_to(cx, read_marker_index, SCROLL_TO_BOTTOM_SPEED);    
-                                }
-                            }
-                        }
-                        
-                    }
+                if self.button(id!(jump_to_bottom_button)).clicked(&actions) {
+                    portal_list.smooth_scroll_to_end(
+                        cx,
+                        SCROLL_TO_BOTTOM_NUM_ANIMATION_ITEMS,
+                        SCROLL_TO_BOTTOM_SPEED,
+                    );
+                    jump_to_bottom_view.set_visible(false);
+                    self.redraw(cx);
+                }
+                if self.button(id!(jump_to_top_button)).clicked(&actions) {
+                    self.scroll_up_to_search_read_marker(cx, actions, &portal_list);
                 }
             }
 
@@ -1401,6 +1393,7 @@ impl Widget for RoomScreen {
             if let (Some(ref mut tl_state), Some(ref room_id)) = (&mut self.tl_state, &self.room_id) {
                 let Some(last_displayed_event) = &tl_state.last_displayed_event else { return };
                 submit_async_request(MatrixRequest::FullyReadReceipt { room_id: room_id.clone(), event_id: last_displayed_event.clone()});
+                self.view(id!(jump_to_top_view)).set_visible(false);
             }
             cx.stop_timer(self.fully_read_timer);
         }
@@ -1552,6 +1545,7 @@ impl RoomScreen {
     fn process_timeline_updates(&mut self, cx: &mut Cx, portal_list: &PortalListRef) {
         let top_space = self.view(id!(top_space));
         let jump_to_bottom_view = self.view(id!(jump_to_bottom_view));
+        let jump_to_top_view = self.view(id!(jump_to_top_view));
         let curr_first_id = portal_list.first_id();
         let Some(tl) = self.tl_state.as_mut() else { return };
 
@@ -1641,7 +1635,6 @@ impl RoomScreen {
                     if let Some(room_id) = &self.room_id {
                         if let Some(num_unread)= get_client()
                         .and_then(|c| c.get_room(room_id)).map(|room| room.num_unread_messages()) {
-                            println!("num_unread {:?}", num_unread);
                             let unread_notifications_badge = jump_to_bottom_view.view(id!(unread_notifications_badge));
                             let unread_message_badge = jump_to_bottom_view.view(id!(unread_message_badge));
                             if num_unread > 0 {
@@ -1656,29 +1649,6 @@ impl RoomScreen {
                             }
                         }
                     }
-                    for (tl_idx, timeline) in tl.items.iter().enumerate() {
-                        if let Some(v_timeline) = timeline.as_virtual() {
-                            match v_timeline {
-                                VirtualTimelineItem::ReadMarker => {
-                                    if let Some(previous_event_id) = tl.items.get(tl_idx.saturating_sub(1))
-                                    .and_then(|f|f.as_event())
-                                    .and_then(|f|f.event_id()) {
-                                        if let Some((s, event_id)) = &mut tl.read_marker {
-                                            if previous_event_id.to_owned() != *event_id {
-                                                *event_id = previous_event_id.to_owned();
-                                                tl.scroll_pass_read_marker = false;
-                                                println!("virtual timeline tl_idx {:?}", tl_idx);
-                                            } 
-                                        } else {
-                                            tl.read_marker = Some((tl_idx,previous_event_id.to_owned()));
-                                            tl.scroll_pass_read_marker = false;
-                                        }
-                                    }
-                                }
-                                _ => {}
-                            }
-                        }
-                    }
                 }
                 TimelineUpdate::PaginationRunning(direction) => {
                     if direction == PaginationDirection::Backwards {
@@ -1854,7 +1824,7 @@ impl RoomScreen {
                 last_scrolled_index: usize::MAX,
                 prev_first_index: None,
                 last_displayed_event: None,
-                read_marker: None,
+                read_marker_index: None,
                 scroll_pass_read_marker: false,
             };
             (new_tl_state, true)
@@ -1998,14 +1968,13 @@ impl RoomScreen {
             return;
         }
         let first_index = portal_list.first_id();
-        
         let Some(tl_state) = self.tl_state.as_mut() else { return };
         let Some(room_id) = self.room_id.as_ref() else { return };
         if let Some(ref mut index) = tl_state.prev_first_index {
             // to detect change of scroll when scroll ends
             if *index != first_index {
                 // if the scroll ends on page that contains read marker, set scroll_pass_read_marker to true
-                if let Some((read_marker_index, _)) = tl_state.read_marker {
+                if let Some((read_marker_index, _)) = tl_state.read_marker_index {
                     if read_marker_index >= first_index && read_marker_index <= first_index + portal_list.visible_items() {
                         tl_state.scroll_pass_read_marker = true;
                     }
@@ -2054,6 +2023,55 @@ impl RoomScreen {
         }
         tl.last_scrolled_index = first_index;
     }
+    fn scroll_up_to_search_read_marker(
+        &mut self,
+        cx: &mut Cx,
+        actions: &ActionsBuf,
+        portal_list: &PortalListRef,
+    ) {
+        const SCROLL_TO_BOTTOM_SPEED: f64 = 90.0;
+        let jump_to_top_view = &self.view(id!(jump_to_top_view));
+        let Some(ref mut tl_state) = &mut self.tl_state else {
+            return;
+        };
+        let Some(ref room_id) = &self.room_id else {
+            return;
+        };
+    
+        let Some(ref fully_read_event_id) = take_fully_read_event(room_id) else {
+            return;
+        };
+        let len = tl_state.items.len();
+        let mut iter = tl_state.items.iter_mut();
+        let mut found = false;
+        for read_marker_index in (0..len).rev() {
+            if let Some(item) = iter
+                .next_back()
+                .and_then(|ti| ti.as_event().and_then(|e| e.event_id()))
+            {
+                if item.to_owned() == fully_read_event_id.clone() {
+                    portal_list.smooth_scroll_to(
+                        cx,
+                        read_marker_index.saturating_sub(1),
+                        SCROLL_TO_BOTTOM_SPEED,
+                    );
+                    tl_state.last_scrolled_index = read_marker_index.saturating_sub(1);
+                    jump_to_top_view.set_visible(false);
+                    found = true;
+                    break;
+                }
+            }
+        }
+        if !found {
+            portal_list.smooth_scroll_to(cx, 0, SCROLL_TO_BOTTOM_SPEED);
+            tl_state.last_scrolled_index = 0;
+            submit_async_request(MatrixRequest::PaginateRoomTimeline {
+                room_id: room_id.clone(),
+                num_events: 50,
+                direction: PaginationDirection::Backwards,
+            });
+        }
+    }    
 }
 
 impl RoomScreenRef {
@@ -2187,7 +2205,7 @@ struct TimelineUiState {
 
     prev_first_index: Option<usize>,
     last_displayed_event: Option<OwnedEventId>,
-    read_marker: Option<(usize,OwnedEventId)>,
+    read_marker_index: Option<(usize,OwnedEventId)>,
     /// Only send fully read receipt after scroll
     scroll_pass_read_marker: bool,
 }
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index d60e70a7..a7eb4381 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -12,6 +12,7 @@ use matrix_sdk::{
     ruma::{
         api::client::{receipt::create_receipt::v3::ReceiptType, session::get_login_types::v3::LoginType},
         events::{
+            fully_read::FullyReadEventContent,
             receipt::ReceiptThread, room::{
                 message::{ForwardThread, RoomMessageEventContent},
                 MediaSource,
@@ -323,7 +324,7 @@ async fn async_worker(mut receiver: UnboundedReceiver<MatrixRequest>) -> Result<
                     } else {
                         timeline.paginate_backwards(num_events).await
                     };
-
+                    
                     match res {
                         Ok(fully_paginated) => {
                             log!("Completed {direction} pagination request for room {room_id}, hit {} of timeline? {}",
@@ -433,6 +434,7 @@ async fn async_worker(mut receiver: UnboundedReceiver<MatrixRequest>) -> Result<
                     }
 
                     if update.is_none() && !local_only {
+                        
                         if let Ok(response) = client.account().fetch_user_profile_of(&user_id).await {
                             update = Some(UserProfileUpdate::UserProfileOnly(
                                 UserProfile {
@@ -485,6 +487,7 @@ async fn async_worker(mut receiver: UnboundedReceiver<MatrixRequest>) -> Result<
                                 if room_member.is_ignored() { "" } else { "un" },
                                 if new_room_member.is_ignored() { "" } else { "un" },
                             );
+                            
                             enqueue_user_profile_update(UserProfileUpdate::RoomMemberOnly {
                                 room_id: room_id.clone(),
                                 room_member: new_room_member,
@@ -763,6 +766,8 @@ struct RoomInfo {
     timeline_update_receiver: Option<crossbeam_channel::Receiver<TimelineUpdate>>,
     /// A drop guard for the event handler that represents a subscription to typing notices for this room.
     typing_notice_subscriber: Option<EventHandlerDropGuard>,
+    /// event_id for read marker
+    fully_read_event: Option<OwnedEventId>
 }
 
 /// Information about all of the rooms we currently know about.
@@ -816,7 +821,14 @@ pub fn take_timeline_update_receiver(
             .map(|receiver| (ri.timeline_update_sender.clone(), receiver))
         )
 }
-
+/// Return an option of OwnEventId for user's fully read event
+pub fn take_fully_read_event(
+    room_id: &OwnedRoomId,
+) -> Option<OwnedEventId>
+{
+    ALL_ROOM_INFO.lock().unwrap().get(room_id)
+    .and_then(|ri|ri.fully_read_event.clone())
+}
 
 async fn async_main_loop() -> Result<()> {
     tracing_subscriber::fmt::init();
@@ -1094,7 +1106,9 @@ async fn add_new_room(room: &room_list_service::Room) -> Result<()> {
     }));
 
     spawn_fetch_room_avatar(room.inner_room().clone());
-
+    let fully_read_event = room.account_data_static::<FullyReadEventContent>().await?
+        .and_then(|f|f.deserialize().ok())
+        .and_then(|f|Some(f.content.event_id));
     ALL_ROOM_INFO.lock().unwrap().insert(
         room_id.clone(),
         RoomInfo {
@@ -1103,6 +1117,7 @@ async fn add_new_room(room: &room_list_service::Room) -> Result<()> {
             timeline_update_receiver: Some(timeline_update_receiver),
             timeline_update_sender,
             typing_notice_subscriber: None,
+            fully_read_event
         },
     );
 

From 3824160f71118e59fcf8823be9a48303275a45f7 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Mon, 4 Nov 2024 11:03:12 +0800
Subject: [PATCH 11/40] added some docs, remove icon_jump_to_top

---
 resources/icon_jump_to_top.svg | 38 ----------------------------------
 src/home/room_screen.rs        | 12 +++++++++--
 2 files changed, 10 insertions(+), 40 deletions(-)
 delete mode 100644 resources/icon_jump_to_top.svg

diff --git a/resources/icon_jump_to_top.svg b/resources/icon_jump_to_top.svg
deleted file mode 100644
index c14e3a1a..00000000
--- a/resources/icon_jump_to_top.svg
+++ /dev/null
@@ -1,38 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg
-   width="256"
-   height="256"
-   viewBox="0 0 256 256"
-   version="1.1"
-   id="svg1"
-   sodipodi:docname="icon_jump_to_bottom.svg"
-   inkscape:version="1.3.2 (091e20e, 2023-11-25, custom)"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:svg="http://www.w3.org/2000/svg">
-  <defs
-     id="defs1" />
-  <sodipodi:namedview
-     id="namedview1"
-     pagecolor="#ffffff"
-     bordercolor="#000000"
-     borderopacity="0.25"
-     inkscape:showpageshadow="2"
-     inkscape:pageopacity="0.0"
-     inkscape:pagecheckerboard="0"
-     inkscape:deskcolor="#d1d1d1"
-     inkscape:zoom="3.1679688"
-     inkscape:cx="127.84217"
-     inkscape:cy="128"
-     inkscape:window-width="1920"
-     inkscape:window-height="1046"
-     inkscape:window-x="-11"
-     inkscape:window-y="-11"
-     inkscape:window-maximized="1"
-     inkscape:current-layer="svg1" />
-  <path
-     d="m 129.4,105.7 c 1.7,0 3.4,0.7 4.7,2.1 l 72,72 c 2.8,2.8 2.8,7.3 0,10.1 -2.8,2.8 -7.3,2.8 -10.1,0 l -67.3,-67.3 -67.3,67.3 c -2.8,2.8 -7.3,2.8 -10.1,0 -2.8,-2.8 -2.8,-7.3 0,-10.1 l 72,-72 c 1.3,-1.4 3,-2.1 4.7,-2.1 z"
-     fill="#000000"
-     id="path1" />
-</svg>
diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index cc0c495e..f60bd3e7 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -2055,6 +2055,7 @@ impl RoomScreen {
                 .and_then(|ti| ti.as_event().and_then(|e| e.event_id()))
             {
                 if item.to_owned() == fully_read_event_id.clone() {
+                    tl_state.read_marker_index = Some((read_marker_index,fully_read_event_id.clone()));
                     portal_list.smooth_scroll_to(
                         cx,
                         read_marker_index.saturating_sub(1),
@@ -2207,11 +2208,18 @@ struct TimelineUiState {
     /// upwards to the first visible item (index 0), which is the top of the timeline,
     /// at which point we submit a backwards pagination request to fetch more events.
     last_scrolled_index: usize,
-
+    /// Previous first index before scrolling
     prev_first_index: Option<usize>,
+
+    /// Last displayed event after scrolling.
+    /// Used for sending fully read receipt
     last_displayed_event: Option<OwnedEventId>,
+
+    /// Index of Read Marker. It is only set once upon first entering the room.
+    /// It's position is used to determine if the user scroll pass the read marker
     read_marker_index: Option<(usize,OwnedEventId)>,
-    /// Only send fully read receipt after scroll
+
+    /// Used to send fully read receipt after scrolling pass the read marker
     scroll_pass_read_marker: bool,
 }
 

From 44f4c2590fe07fbd98537a8b4f4c7cf5124cc7a1 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Mon, 4 Nov 2024 11:06:50 +0800
Subject: [PATCH 12/40] merge .cargo

---
 .cargo/config.toml | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 .cargo/config.toml

diff --git a/.cargo/config.toml b/.cargo/config.toml
new file mode 100644
index 00000000..1e4c8000
--- /dev/null
+++ b/.cargo/config.toml
@@ -0,0 +1,5 @@
+## Add these flags onto all target builds cumulatively.
+## <https://github.com/rust-lang/cargo/issues/5376#issuecomment-2163350032>
+[target.'cfg(all())']
+rustflags = ["--cfg", "ruma_identifiers_storage=\"Arc\""]
+

From 9076c5317cc2105d0c748bc52a0155c43dd8f9f5 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Mon, 4 Nov 2024 13:00:32 +0800
Subject: [PATCH 13/40] minor formating

---
 src/sliding_sync.rs | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index b75721d4..1dc2fb87 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -463,7 +463,6 @@ async fn async_worker(
                     }
 
                     if update.is_none() && !local_only {
-                        
                         if let Ok(response) = client.account().fetch_user_profile_of(&user_id).await {
                             update = Some(UserProfileUpdate::UserProfileOnly(
                                 UserProfile {
@@ -861,12 +860,12 @@ pub fn take_timeline_update_receiver(
         )
 }
 /// Return an option of OwnEventId for user's fully read event
-pub fn take_fully_read_event(
-    room_id: &OwnedRoomId,
-) -> Option<OwnedEventId>
-{
-    ALL_ROOM_INFO.lock().unwrap().get(room_id)
-    .and_then(|ri|ri.fully_read_event.clone())
+pub fn take_fully_read_event(room_id: &OwnedRoomId) -> Option<OwnedEventId> {
+    ALL_ROOM_INFO
+        .lock()
+        .unwrap()
+        .get(room_id)
+        .and_then(|ri| ri.fully_read_event.clone())
 }
 
 const DEFAULT_HOMESERVER: &str = "matrix.org";
@@ -1193,9 +1192,11 @@ async fn add_new_room(room: &room_list_service::Room) -> Result<()> {
     }));
 
     spawn_fetch_room_avatar(room.inner_room().clone());
-    let fully_read_event = room.account_data_static::<FullyReadEventContent>().await?
-        .and_then(|f|f.deserialize().ok())
-        .and_then(|f|Some(f.content.event_id));
+    let fully_read_event = room
+        .account_data_static::<FullyReadEventContent>()
+        .await?
+        .and_then(|f| f.deserialize().ok())
+        .and_then(|f| Some(f.content.event_id));
     let tombstoned_room_replaced_by_this_room = TOMBSTONED_ROOMS.lock()
         .unwrap()
         .remove(&room_id);

From 5bf241387644c54ee7aa55ac42605c7edab1eb1c Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Mon, 4 Nov 2024 21:22:01 +0800
Subject: [PATCH 14/40] change to start_timeout

---
 src/home/room_screen.rs | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 75495f60..a8e0b259 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -1073,7 +1073,12 @@ live_design! {
                 user_profile_sliding_pane = <UserProfileSlidingPane> { }
             }
         }
-
+        cursor_not_allowed_template: <RobrixIconButton>{
+            cursor: NotAllowed,
+        }
+        cursor_hand_template: <RobrixIconButton>{
+            cursor: Hand,
+        }
         animator: {
             typing_notice_animator = {
                 default: show,
@@ -1106,6 +1111,11 @@ pub struct RoomScreen {
     #[rust] tl_state: Option<TimelineUiState>,
     /// 5 secs timer when scroll ends
     #[rust] fully_read_timer: Timer,
+    /// To apply cursor NotAllowed on Robrix Icon Button
+    #[live] cursor_not_allowed_template: Option<LivePtr>,
+    /// To apply cursor Hand on Robrix Icon Button
+    #[live] cursor_hand_template: Option<LivePtr>
+
 }
 impl Drop for RoomScreen {
     fn drop(&mut self) {
@@ -1404,9 +1414,8 @@ impl Widget for RoomScreen {
                 });
             }
         }
-
         // Mark events as fully read after they have been displayed on screen for 5 seconds.
-        if self.fully_read_timer.is_event(event).is_some() {
+        if let Some(_) = self.fully_read_timer.is_event(event) {
             if let (Some(ref mut tl_state), Some(ref room_id)) = (&mut self.tl_state, &self.room_id) {
                 let Some(last_displayed_event) = &tl_state.last_displayed_event else { return };
                 submit_async_request(MatrixRequest::FullyReadReceipt { room_id: room_id.clone(), event_id: last_displayed_event.clone()});
@@ -1666,9 +1675,6 @@ impl RoomScreen {
                                 unread_message_badge.label(id!(label)).set_text(&format!("{}",num_unread));
                                 unread_message_badge.set_visible(true);
                                 unread_notifications_badge.set_visible(false);
-                                if let Some(ref mut but) = jump_to_bottom_view.button(id!(jump_button)).borrow_mut() {
-                                    but.animator_play(cx, id!(jump_button.down));
-                                }
                             } else {
                                 unread_message_badge.set_visible(false);
                             }
@@ -2024,7 +2030,7 @@ impl RoomScreen {
                 if first_index > *index {
                     if tl_state.scroll_pass_read_marker {
                         cx.stop_timer(self.fully_read_timer);
-                        self.fully_read_timer = cx.start_interval(5.0);
+                        self.fully_read_timer = cx.start_timeout(5.0);
                     }
                     if let Some(event_id) = tl_state.items.get(first_index + portal_list.visible_items())
                             .and_then(|f| f.as_event() )

From 8bbde587bc1ad7b88138f70c875f7c6042dd7b16 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Wed, 6 Nov 2024 13:57:46 +0800
Subject: [PATCH 15/40] removed jump_to_top & fix timer issue

---
 src/home/room_screen.rs | 137 ++++++----------------------------------
 1 file changed, 19 insertions(+), 118 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index a8e0b259..0fee75ca 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -710,59 +710,6 @@ live_design! {
                 }
             }
         }
-        jump_to_top_view = <View> {
-            width: Fill,
-            height: 80,
-            flow: Overlay,
-            align: {x: 1.0, y: 1.0},
-            margin: {right: 15.0, bottom: 30},
-            visible: true,
-            jump_to_top_button = <RobrixIconButton> {
-                width: 50, height: 50,
-                draw_icon: {svg_file: (ICO_JUMP_TO_BOTTOM)},
-                padding: 15,
-                margin: {bottom : 20}
-                icon_walk: {width: 20, height: 10, margin: {top: 0, right: 100} }
-                // draw a circular background for the button
-                draw_bg: {
-                    instance background_color: #edededee,
-                    fn pixel(self) -> vec4 {
-                        let sdf = Sdf2d::viewport(self.pos * self.rect_size);
-                        let c = self.rect_size * 0.5;
-                        sdf.circle(c.x, c.x, c.x)
-                        sdf.fill_keep(self.background_color);
-                        return sdf.result
-                    }
-    
-                }
-                draw_icon: {
-                    instance color: #000
-                    instance color_hover: #000
-                    // 180.0: point upwards
-                    uniform rotation_angle: 180.0,
-                }
-                
-            }
-            // Badge overlay for unread messages
-            unread_notification_badge = <View> {
-                width: 12, height: 12,
-                margin: { right: 19, bottom: 60},
-                visible: true,
-                show_bg: true,
-                draw_bg: {
-                    instance background_color: (#58DC6C)
-        
-                    fn pixel(self) -> vec4 {
-                        let sdf = Sdf2d::viewport(self.pos * self.rect_size);
-                        let c = self.rect_size * 0.5;
-                        sdf.circle(c.x, c.x, c.x);
-                        sdf.fill_keep(self.background_color);
-                        return sdf.result;
-                    }
-                }
-            }
-           
-        }
     }
 
     LocationPreview = {{LocationPreview}} {
@@ -1110,7 +1057,7 @@ pub struct RoomScreen {
     /// The UI-relevant states for the room that this widget is currently displaying.
     #[rust] tl_state: Option<TimelineUiState>,
     /// 5 secs timer when scroll ends
-    #[rust] fully_read_timer: Timer,
+    #[rust] fully_read_timer: Option<Timer>,
     /// To apply cursor NotAllowed on Robrix Icon Button
     #[live] cursor_not_allowed_template: Option<LivePtr>,
     /// To apply cursor Hand on Robrix Icon Button
@@ -1386,6 +1333,7 @@ impl Widget for RoomScreen {
             {
                 let jump_to_bottom_view = self.view(id!(jump_to_bottom_view));
                 if portal_list.scrolled(&actions) {
+                    println!("portal_list.is_at_end() {:?}",portal_list.is_at_end());
                     // TODO: is_at_end() isn't perfect, see: <https://github.com/makepad/makepad/issues/517>
                     jump_to_bottom_view.set_visible(!portal_list.is_at_end());
                 }
@@ -1401,9 +1349,6 @@ impl Widget for RoomScreen {
                     jump_to_bottom_view.set_visible(false);
                     self.redraw(cx);
                 }
-                if self.button(id!(jump_to_top_button)).clicked(&actions) {
-                    self.scroll_up_to_search_read_marker(cx, actions, &portal_list);
-                }
             }
 
             // Handle a typing action on the message input box.
@@ -1415,13 +1360,15 @@ impl Widget for RoomScreen {
             }
         }
         // Mark events as fully read after they have been displayed on screen for 5 seconds.
-        if let Some(_) = self.fully_read_timer.is_event(event) {
-            if let (Some(ref mut tl_state), Some(ref room_id)) = (&mut self.tl_state, &self.room_id) {
-                let Some(last_displayed_event) = &tl_state.last_displayed_event else { return };
-                submit_async_request(MatrixRequest::FullyReadReceipt { room_id: room_id.clone(), event_id: last_displayed_event.clone()});
-                self.view(id!(jump_to_top_view)).set_visible(false);
+        if let Some(timer) = self.fully_read_timer {
+            if timer.is_event(event).is_some() {
+                if let (Some(ref mut tl_state), Some(ref room_id)) = (&mut self.tl_state, &self.room_id) {
+                    let Some(last_displayed_event) = &tl_state.last_displayed_event else { return };
+                    submit_async_request(MatrixRequest::FullyReadReceipt { room_id: room_id.clone(), event_id: last_displayed_event.clone()});
+                }
+                cx.stop_timer(timer);
+                self.fully_read_timer = None;
             }
-            cx.stop_timer(self.fully_read_timer);
         }
 
         if self.animator_handle_event(cx, event).must_redraw() {
@@ -1577,7 +1524,6 @@ impl RoomScreen {
     fn process_timeline_updates(&mut self, cx: &mut Cx, portal_list: &PortalListRef) {
         let top_space = self.view(id!(top_space));
         let jump_to_bottom_view = self.view(id!(jump_to_bottom_view));
-        let jump_to_top_view = self.view(id!(jump_to_top_view));
         let curr_first_id = portal_list.first_id();
         let Some(tl) = self.tl_state.as_mut() else { return };
 
@@ -1635,7 +1581,10 @@ impl RoomScreen {
                             log!("Timeline::handle_event(): jumping view from event index {curr_item_idx} to new index {new_item_idx}, scroll {new_item_scroll}, event ID {_event_id}");
                             portal_list.set_first_id_and_scroll(new_item_idx, new_item_scroll);
                             tl.prev_first_index = Some(new_item_idx);
-                            cx.stop_timer(self.fully_read_timer);
+                            if let Some(timer) = self.fully_read_timer {
+                                cx.stop_timer(timer);
+                            }
+                            self.fully_read_timer = None;
                         }
                     }
                     // TODO: after an (un)ignore user event, all timelines are cleared.
@@ -2029,8 +1978,10 @@ impl RoomScreen {
                 }
                 if first_index > *index {
                     if tl_state.scroll_pass_read_marker {
-                        cx.stop_timer(self.fully_read_timer);
-                        self.fully_read_timer = cx.start_timeout(5.0);
+                        if let Some(timer) = self.fully_read_timer {
+                            cx.stop_timer(timer);
+                        }
+                        self.fully_read_timer = Some(cx.start_timeout(5.0));
                     }
                     if let Some(event_id) = tl_state.items.get(first_index + portal_list.visible_items())
                             .and_then(|f| f.as_event() )
@@ -2070,57 +2021,7 @@ impl RoomScreen {
             });
         }
         tl.last_scrolled_index = first_index;
-    }
-    fn scroll_up_to_search_read_marker(
-        &mut self,
-        cx: &mut Cx,
-        actions: &ActionsBuf,
-        portal_list: &PortalListRef,
-    ) {
-        const SCROLL_TO_BOTTOM_SPEED: f64 = 90.0;
-        let jump_to_top_view = &self.view(id!(jump_to_top_view));
-        let Some(ref mut tl_state) = &mut self.tl_state else {
-            return;
-        };
-        let Some(ref room_id) = &self.room_id else {
-            return;
-        };
-    
-        let Some(ref fully_read_event_id) = take_fully_read_event(room_id) else {
-            return;
-        };
-        let len = tl_state.items.len();
-        let mut iter = tl_state.items.iter_mut();
-        let mut found = false;
-        for read_marker_index in (0..len).rev() {
-            if let Some(item) = iter
-                .next_back()
-                .and_then(|ti| ti.as_event().and_then(|e| e.event_id()))
-            {
-                if item.to_owned() == fully_read_event_id.clone() {
-                    tl_state.read_marker_index = Some((read_marker_index,fully_read_event_id.clone()));
-                    portal_list.smooth_scroll_to(
-                        cx,
-                        read_marker_index.saturating_sub(1),
-                        SCROLL_TO_BOTTOM_SPEED,
-                    );
-                    tl_state.last_scrolled_index = read_marker_index.saturating_sub(1);
-                    jump_to_top_view.set_visible(false);
-                    found = true;
-                    break;
-                }
-            }
-        }
-        if !found {
-            portal_list.smooth_scroll_to(cx, 0, SCROLL_TO_BOTTOM_SPEED);
-            tl_state.last_scrolled_index = 0;
-            submit_async_request(MatrixRequest::PaginateRoomTimeline {
-                room_id: room_id.clone(),
-                num_events: 50,
-                direction: PaginationDirection::Backwards,
-            });
-        }
-    }    
+    }   
 }
 
 impl RoomScreenRef {

From b99a57d08e13fbb7f366d36bd5df2729cb54e10b Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Wed, 6 Nov 2024 14:42:51 +0800
Subject: [PATCH 16/40] set read event into RoomInfo's fully read when sending

---
 src/home/room_screen.rs |  5 ++---
 src/sliding_sync.rs     | 15 +++++++++++++--
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 0fee75ca..75a5e8e2 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -7,7 +7,7 @@ use imbl::Vector;
 use makepad_widgets::*;
 use matrix_sdk::{
     ruma::{
-        api::client::read_marker, events::room::{
+        events::room::{
             message::{
                 FormattedBody, ImageMessageEventContent, LocationMessageEventContent, MessageFormat, MessageType, NoticeMessageEventContent, RoomMessageEventContent, TextMessageEventContent
             },
@@ -32,7 +32,7 @@ use crate::{
         html_or_plaintext::{HtmlOrPlaintextRef, HtmlOrPlaintextWidgetRefExt},
         text_or_image::{TextOrImageRef, TextOrImageWidgetRefExt},
         typing_animation::TypingAnimationWidgetExt,
-    }, sliding_sync::{get_client, submit_async_request, take_timeline_update_receiver, take_fully_read_event, MatrixRequest, PaginationDirection}, utils::{self, unix_time_millis_to_datetime, MediaFormatConst}
+    }, sliding_sync::{get_client, submit_async_request, take_timeline_update_receiver, MatrixRequest, PaginationDirection}, utils::{self, unix_time_millis_to_datetime, MediaFormatConst}
 };
 use rangemap::RangeSet;
 
@@ -1333,7 +1333,6 @@ impl Widget for RoomScreen {
             {
                 let jump_to_bottom_view = self.view(id!(jump_to_bottom_view));
                 if portal_list.scrolled(&actions) {
-                    println!("portal_list.is_at_end() {:?}",portal_list.is_at_end());
                     // TODO: is_at_end() isn't perfect, see: <https://github.com/makepad/makepad/issues/517>
                     jump_to_bottom_view.set_visible(!portal_list.is_at_end());
                 }
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index b51dc3b5..57d80b6b 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -676,7 +676,10 @@ async fn async_worker(
                 };
                 let _send_rr_task = Handle::current().spawn(async move {
                     match timeline.send_single_receipt(ReceiptType::Read, ReceiptThread::Unthreaded, event_id.clone()).await {
-                        Ok(sent) => log!("{} read receipt to room {room_id} for event {event_id}", if sent { "Sent" } else { "Already sent" }),
+                        Ok(sent) => log!("{} read receipt to room {room_id} for event {event_id}", if sent { 
+                            set_fully_read_event(&room_id, event_id.clone());
+                            "Sent" 
+                        } else { "Already sent" }),
                         Err(_e) => error!("Failed to send read receipt to room {room_id} for event {event_id}; error: {_e:?}"),
                     }
                 });
@@ -867,7 +870,15 @@ pub fn take_fully_read_event(room_id: &OwnedRoomId) -> Option<OwnedEventId> {
         .get(room_id)
         .and_then(|ri| ri.fully_read_event.clone())
 }
-
+/// Update fully read event inside All Room Info after sending out read_receipt
+fn set_fully_read_event(room_id: &OwnedRoomId, read_event: OwnedEventId) {
+    if let Some(ref mut room_info) = ALL_ROOM_INFO
+        .lock()
+        .unwrap()
+        .get_mut(room_id) {
+            room_info.fully_read_event = Some(read_event)
+        }
+}
 const DEFAULT_HOMESERVER: &str = "matrix.org";
 
 fn username_to_full_user_id(

From 99ff1b12241fb41f4fc7a4fecab6c4cdc78548d6 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Wed, 6 Nov 2024 18:04:46 +0800
Subject: [PATCH 17/40] restructure scroll pass read marker logic

---
 src/home/room_screen.rs | 20 +++++++++++---------
 src/sliding_sync.rs     |  1 -
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 75a5e8e2..7aabf4b2 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -32,7 +32,7 @@ use crate::{
         html_or_plaintext::{HtmlOrPlaintextRef, HtmlOrPlaintextWidgetRefExt},
         text_or_image::{TextOrImageRef, TextOrImageWidgetRefExt},
         typing_animation::TypingAnimationWidgetExt,
-    }, sliding_sync::{get_client, submit_async_request, take_timeline_update_receiver, MatrixRequest, PaginationDirection}, utils::{self, unix_time_millis_to_datetime, MediaFormatConst}
+    }, sliding_sync::{get_client, submit_async_request, take_fully_read_event, take_timeline_update_receiver, MatrixRequest, PaginationDirection}, utils::{self, unix_time_millis_to_datetime, MediaFormatConst}
 };
 use rangemap::RangeSet;
 
@@ -1584,6 +1584,7 @@ impl RoomScreen {
                                 cx.stop_timer(timer);
                             }
                             self.fully_read_timer = None;
+                            tl.scroll_pass_read_marker = false;
                         }
                     }
                     // TODO: after an (un)ignore user event, all timelines are cleared.
@@ -1815,7 +1816,7 @@ impl RoomScreen {
                 last_scrolled_index: usize::MAX,
                 prev_first_index: None,
                 last_displayed_event: None,
-                read_marker_index: None,
+                read_marker: None,
                 scroll_pass_read_marker: false,
             };
             (new_tl_state, true)
@@ -1969,12 +1970,6 @@ impl RoomScreen {
         if let Some(ref mut index) = tl_state.prev_first_index {
             // to detect change of scroll when scroll ends
             if *index != first_index {
-                // if the scroll ends on page that contains read marker, set scroll_pass_read_marker to true
-                if let Some((read_marker_index, _)) = tl_state.read_marker_index {
-                    if read_marker_index >= first_index && read_marker_index <= first_index + portal_list.visible_items() {
-                        tl_state.scroll_pass_read_marker = true;
-                    }
-                }
                 if first_index > *index {
                     if tl_state.scroll_pass_read_marker {
                         if let Some(timer) = self.fully_read_timer {
@@ -1985,7 +1980,14 @@ impl RoomScreen {
                     if let Some(event_id) = tl_state.items.get(first_index + portal_list.visible_items())
                             .and_then(|f| f.as_event() )
                             .and_then(|f| f.event_id() ) {
+                        // Scroll pass read marker, can then subsequently send fully read events
+                        if let Some(fully_read_event) = take_fully_read_event(&room_id) {
+                            if &fully_read_event == event_id {
+                                tl_state.scroll_pass_read_marker = true;
+                            }
+                        }
                         submit_async_request(MatrixRequest::ReadReceipt { room_id: room_id.clone(), event_id: event_id.to_owned() });
+                        
                         tl_state.last_displayed_event = Some(event_id.to_owned());
                     }
                 }
@@ -2160,7 +2162,7 @@ struct TimelineUiState {
 
     /// Index of Read Marker. It is only set once upon first entering the room.
     /// It's position is used to determine if the user scroll pass the read marker
-    read_marker_index: Option<(usize,OwnedEventId)>,
+    read_marker: Option<(usize,OwnedEventId)>,
 
     /// Used to send fully read receipt after scrolling pass the read marker
     scroll_pass_read_marker: bool,
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index 57d80b6b..147dbc10 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -353,7 +353,6 @@ async fn async_worker(
                     } else {
                         timeline.paginate_backwards(num_events).await
                     };
-                    
                     match res {
                         Ok(fully_paginated) => {
                             log!("Completed {direction} pagination request for room {room_id}, hit {} of timeline? {}",

From 009077fc04583503df08b596eb666d7617a4a574 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Tue, 19 Nov 2024 14:12:00 +0800
Subject: [PATCH 18/40] Added unread_notification badge

---
 src/home/room_screen.rs             | 49 ++++++-----------------------
 src/shared/jump_to_bottom_button.rs | 27 ++++++++++------
 src/sliding_sync.rs                 | 10 +-----
 3 files changed, 27 insertions(+), 59 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 9c01df8a..35f1d09b 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -967,8 +967,6 @@ pub struct RoomScreen {
     #[live] cursor_not_allowed_template: Option<LivePtr>,
     /// To apply cursor Hand on Robrix Icon Button
     #[live] cursor_hand_template: Option<LivePtr>,
-    /// number of unread messages
-    #[rust] unread_message_count: u64,
 
 }
 impl Drop for RoomScreen {
@@ -1050,22 +1048,6 @@ impl Widget for RoomScreen {
                             log!("TODO: the replied-to message was not yet available in the timeline.");
                         }
                     }
-                    MessageAction::UnReadCount(unread_message_count) => {
-                        println!(" unread_message_count {:?}", unread_message_count);
-                        let jump_to_bottom = self.jump_to_bottom_button(id!(jump_to_bottom));
-                        // let unread_notifications_badge = jump_to_bottom.view(id!(unread_notifications_badge));
-                        //self.unread_message_count = unread_message_count;
-                        jump_to_bottom.show_unread_message_badge(unread_message_count as usize);
-                        self.redraw(cx);
-                        // let unread_message_badge = jump_to_bottom.view(id!(unread_message_badge));
-                        // if num_unread > 0 {
-                        //     unread_message_badge.label(id!(label)).set_text(&format!("{}", num_unread));
-                        //     unread_message_badge.set_visible(true);
-                        //     unread_notifications_badge.set_visible(false);
-                        // } else {
-                        //     unread_message_badge.set_visible(false);
-                        // }
-                    }
                     _ => {}
                 }
 
@@ -1521,8 +1503,14 @@ impl RoomScreen {
 
                     // If new items were appended to the end of the timeline, show an unread messages badge on the jump to bottom button.
                     if is_append && !portal_list.is_at_end() {
-                        // log!("is_append was true, showing unread message badge on the jump to bottom button visible");
-                        //jump_to_bottom.show_unread_message_badge(self.unread_message_count as usize);
+                        log!("is_append was true, showing unread message badge on the jump to bottom button visible");
+                        // Set number of unread messages to unread_notification_badge
+                        if let Some(room_id) = &self.room_id {
+                            if let Some(num_unread)= get_client()
+                            .and_then(|c| c.get_room(room_id)).map(|room| room.num_unread_messages()) {
+                                jump_to_bottom.show_unread_message_badge(num_unread as usize);
+                            }
+                        }
                     }
 
                     if clear_cache {
@@ -1536,25 +1524,7 @@ impl RoomScreen {
                     }
                     tl.items = new_items;
                     done_loading = true;
-                    // Set number of unread messages to unread_notification_badge
-                    if let Some(room_id) = &self.room_id {
-                        if let Some(num_unread)= get_client()
-                        .and_then(|c| c.get_room(room_id)).map(|room| room.num_unread_messages()) {
-                            println!("calling num_unread_messages {:?} room_id {:?} num_unread", room_id, num_unread);
-                        // let unread_notifications_badge = jump_to_bottom.view(id!(unread_notifications_badge));
-                        //self.unread_message_count = unread_message_count;
-                                 jump_to_bottom.show_unread_message_badge(num_unread as usize);
-                            // let unread_notifications_badge = jump_to_bottom.view(id!(unread_notifications_badge));
-                            // let unread_message_badge = jump_to_bottom.view(id!(unread_message_badge));
-                            // if num_unread > 0 {
-                            //     unread_message_badge.label(id!(label)).set_text(&format!("{}",num_unread));
-                            //     unread_message_badge.set_visible(true);
-                            //     unread_notifications_badge.set_visible(false);
-                            // } else {
-                            //     unread_message_badge.set_visible(false);
-                            // }
-                        }
-                    }
+                    
                 }
                 TimelineUpdate::PaginationRunning(direction) => {
                     if direction == PaginationDirection::Backwards {
@@ -3134,7 +3104,6 @@ pub enum MessageAction {
     },
     /// The message with the given item ID should be highlighted.
     MessageHighlight(usize),
-    UnReadCount(u64),
     None,
 }
 
diff --git a/src/shared/jump_to_bottom_button.rs b/src/shared/jump_to_bottom_button.rs
index ab617a7c..95611709 100644
--- a/src/shared/jump_to_bottom_button.rs
+++ b/src/shared/jump_to_bottom_button.rs
@@ -41,10 +41,13 @@ live_design! {
 
         // A badge overlay on the jump to bottom button showing unread messages
         unread_message_badge = <View> {
-            width: 12, height: 12,
-            margin: {right: 33.0, bottom: 11.0},
+            width: 20, height: 20,
+            margin: {right: 28.0, bottom: 8.0},
+            align: {
+                x: 0.5,
+                y: 0.5
+            }
             visible: false,
-
             show_bg: true,
             draw_bg: {
                 color: (COLOR_UNREAD_MESSAGE_BADGE)
@@ -59,10 +62,9 @@ live_design! {
 
             // Label that displays the unread message count
             unread_messages_count = <Label> {
-                width: Fill,
-                height: Fill,
+                width: Fit,
+                height: Fit,
                 text: "",
-                align: {x: 0.5, y: 0.5},
                 draw_text: {
                     color: #ffffff,
                     text_style: {font_size: 8.0},
@@ -112,10 +114,15 @@ impl JumpToBottomButton {
     ///
     /// TODO: in the future, we'll display the actual count of unread messages in the badge.
     pub fn show_unread_message_badge(&mut self, unread_message_count: usize) {
-        self.visible = true;
-        self.view(id!(unread_message_badge)).set_visible(true);
-        self.label(id!(unread_messages_count)).set_text(&format!("{}", unread_message_count));
-        
+        if unread_message_count > 0 {
+            self.visible = true;
+            self.view(id!(unread_message_badge)).set_visible(true);
+            self.label(id!(unread_messages_count)).set_text(&format!("{}", unread_message_count));
+        } else {
+            self.visible = false;
+            self.view(id!(unread_message_badge)).set_visible(false);
+            self.label(id!(unread_messages_count)).set_text(&format!("{}", ""));
+        }
     }
 
     /// Updates the visibility of the jump to bottom button and the unread message badge
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index f0ff81df..8b096ad6 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -30,7 +30,7 @@ use std::{cmp::{max, min}, collections::{BTreeMap, BTreeSet}, path:: Path, sync:
 
 use crate::{
     app_data_dir, avatar_cache::AvatarUpdate, event_preview::text_preview_of_timeline_item, home::{
-        room_screen::{MessageAction, TimelineUpdate}, rooms_list::{self, enqueue_rooms_list_update, RoomPreviewAvatar, RoomPreviewEntry, RoomsListUpdate}
+        room_screen::TimelineUpdate, rooms_list::{self, enqueue_rooms_list_update, RoomPreviewAvatar, RoomPreviewEntry, RoomsListUpdate}
     }, login::login_screen::LoginAction, media_cache::MediaCacheEntry, persistent_state::{self, ClientSessionPersisted}, profile::{
         user_profile::{AvatarState, UserProfile},
         user_profile_cache::{enqueue_user_profile_update, UserProfileUpdate},
@@ -1566,14 +1566,6 @@ async fn timeline_subscriber_handler(
                 clear_cache,
                 is_append,
             }).expect("Error: timeline update sender couldn't send update with new items!");
-
-            // if let Some(num_unread) = get_client()
-            //     .and_then(|c| c.get_room(&room_id))
-            //     .map(|room| room.num_unread_messages())
-            // {
-            //     println!("calling num_unread_messages {:?} room_id", num_unread);
-            //     Cx::post_action(MessageAction::UnReadCount(num_unread));
-            // }
             
             // Send a Makepad-level signal to update this room's timeline UI view.
             SignalToUI::set_ui_signal();

From aba7e690c842b11d895162dce5c6f31e1a62532b Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Tue, 19 Nov 2024 14:32:20 +0800
Subject: [PATCH 19/40] code cleanup

---
 src/home/room_screen.rs             | 14 +-------------
 src/shared/jump_to_bottom_button.rs |  1 +
 src/sliding_sync.rs                 | 20 +++++++++++++++++---
 3 files changed, 19 insertions(+), 16 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 35f1d09b..8682b365 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -925,12 +925,6 @@ live_design! {
                 user_profile_sliding_pane = <UserProfileSlidingPane> { }
             }
         }
-        cursor_not_allowed_template: <RobrixIconButton>{
-            cursor: NotAllowed,
-        }
-        cursor_hand_template: <RobrixIconButton>{
-            cursor: Hand,
-        }
         animator: {
             typing_notice_animator = {
                 default: show,
@@ -963,10 +957,6 @@ pub struct RoomScreen {
     #[rust] tl_state: Option<TimelineUiState>,
     /// 5 secs timer when scroll ends
     #[rust] fully_read_timer: Option<Timer>,
-    /// To apply cursor NotAllowed on Robrix Icon Button
-    #[live] cursor_not_allowed_template: Option<LivePtr>,
-    /// To apply cursor Hand on Robrix Icon Button
-    #[live] cursor_hand_template: Option<LivePtr>,
 
 }
 impl Drop for RoomScreen {
@@ -1524,7 +1514,6 @@ impl RoomScreen {
                     }
                     tl.items = new_items;
                     done_loading = true;
-                    
                 }
                 TimelineUpdate::PaginationRunning(direction) => {
                     if direction == PaginationDirection::Backwards {
@@ -1720,7 +1709,6 @@ impl RoomScreen {
 
         // Subscribe to typing notices, but hide the typing notice view initially.
         self.view(id!(typing_notice)).set_visible(false);
-        println!("show_timeline {:?}", room_id);
         submit_async_request(
             MatrixRequest::SubscribeToTypingNotices {
                 room_id: room_id.clone(),
@@ -1919,7 +1907,7 @@ impl RoomScreen {
             });
         }
         tl.last_scrolled_index = first_index;
-    }   
+    }
 }
 
 impl RoomScreenRef {
diff --git a/src/shared/jump_to_bottom_button.rs b/src/shared/jump_to_bottom_button.rs
index 95611709..78f89218 100644
--- a/src/shared/jump_to_bottom_button.rs
+++ b/src/shared/jump_to_bottom_button.rs
@@ -48,6 +48,7 @@ live_design! {
                 y: 0.5
             }
             visible: false,
+
             show_bg: true,
             draw_bg: {
                 color: (COLOR_UNREAD_MESSAGE_BADGE)
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index 8b096ad6..103a53b9 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -352,6 +352,7 @@ async fn async_worker(
                     } else {
                         timeline.paginate_backwards(num_events).await
                     };
+
                     match res {
                         Ok(fully_paginated) => {
                             log!("Completed {direction} pagination request for room {room_id}, hit {} of timeline? {}",
@@ -513,7 +514,6 @@ async fn async_worker(
                                 if room_member.is_ignored() { "" } else { "un" },
                                 if new_room_member.is_ignored() { "" } else { "un" },
                             );
-                            
                             enqueue_user_profile_update(UserProfileUpdate::RoomMemberOnly {
                                 room_id: room_id.clone(),
                                 room_member: new_room_member,
@@ -804,7 +804,19 @@ struct RoomInfo {
     /// event_id for read marker
     fully_read_event: Option<OwnedEventId>,
 }
-
+impl Drop for RoomInfo {
+    fn drop(&mut self) {
+        log!("Dropping RoomInfo for room {}", self.room_id);
+        self.timeline_subscriber_handler_task.abort();
+        drop(self.typing_notice_subscriber.take());
+        if let Some(replaces_tombstoned_room) = self.replaces_tombstoned_room.take() {
+            TOMBSTONED_ROOMS.lock().unwrap().insert(
+                self.room_id.clone(),
+                replaces_tombstoned_room,
+            );
+        }
+    }
+}
 /// Information about all of the rooms we currently know about.
 static ALL_ROOM_INFO: Mutex<BTreeMap<OwnedRoomId, RoomInfo>> = Mutex::new(BTreeMap::new());
 
@@ -862,6 +874,8 @@ pub fn take_timeline_update_receiver(
             .map(|receiver| (ri.timeline_update_sender.clone(), receiver))
         )
 }
+
+
 /// Return an option of OwnEventId for user's fully read event
 pub fn take_fully_read_event(room_id: &OwnedRoomId) -> Option<OwnedEventId> {
     ALL_ROOM_INFO
@@ -1566,7 +1580,7 @@ async fn timeline_subscriber_handler(
                 clear_cache,
                 is_append,
             }).expect("Error: timeline update sender couldn't send update with new items!");
-            
+
             // Send a Makepad-level signal to update this room's timeline UI view.
             SignalToUI::set_ui_signal();
         

From 945d3a1438ff5c30223dedb1da63a8f9339ec059 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Tue, 19 Nov 2024 17:18:50 +0800
Subject: [PATCH 20/40] fix indentation and grammar

---
 src/home/room_screen.rs             | 21 +++++++++++----------
 src/shared/jump_to_bottom_button.rs |  2 --
 src/sliding_sync.rs                 |  7 +++++--
 3 files changed, 16 insertions(+), 14 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 9a59b750..5c92ad36 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -1536,7 +1536,7 @@ impl RoomScreen {
                                 cx.stop_timer(timer);
                             }
                             self.fully_read_timer = None;
-                            tl.scrolled_pass_read_marker = false;
+                            tl.scrolled_past_read_marker = false;
                         }
                     }
                     //
@@ -1549,11 +1549,13 @@ impl RoomScreen {
                     // If new items were appended to the end of the timeline, show an unread messages badge on the jump to bottom button.
                     if is_append && !portal_list.is_at_end() {
                         log!("is_append was true, showing unread message badge on the jump to bottom button visible");
-                        // Set number of unread messages to unread_notification_badge
+                        // Set the number of unread messages to unread_notification_badge
                         if let Some(room_id) = &self.room_id {
-                            if let Some(num_unread)= get_client()
-                            .and_then(|c| c.get_room(room_id)).map(|room| room.num_unread_messages()) {
-                                //jump_to_bottom.show_unread_message_badge(num_unread as usize);
+                            if let Some(num_unread) = get_client()
+                                .and_then(|c| c.get_room(room_id))
+                                .map(|room| room.num_unread_messages())
+                            {
+                                jump_to_bottom.show_unread_message_badge(num_unread as usize);
                             }
                         }
                     }
@@ -1847,7 +1849,7 @@ impl RoomScreen {
                 last_scrolled_index: usize::MAX,
                 prev_first_index: None,
                 last_displayed_event: None,
-                scrolled_pass_read_marker: false,
+                scrolled_past_read_marker: false,
             };
             (new_tl_state, true)
         };
@@ -2004,7 +2006,7 @@ impl RoomScreen {
             // to detect change of scroll when scroll ends
             if *index != first_index {
                 if first_index > *index {
-                    if tl_state.scrolled_pass_read_marker {
+                    if tl_state.scrolled_past_read_marker {
                         if let Some(timer) = self.fully_read_timer {
                             cx.stop_timer(timer);
                         }
@@ -2013,10 +2015,9 @@ impl RoomScreen {
                     if let Some(event_id) = tl_state.items.get(first_index + portal_list.visible_items())
                             .and_then(|f| f.as_event() )
                             .and_then(|f| f.event_id() ) {
-                        // Scroll pass read marker, can then subsequently send fully read events
                         if let Some(fully_read_event) = take_fully_read_event(&room_id) {
                             if &fully_read_event == event_id {
-                                tl_state.scrolled_pass_read_marker = true;
+                                tl_state.scrolled_past_read_marker = true;
                             }
                         }
                         submit_async_request(MatrixRequest::ReadReceipt { room_id: room_id.clone(), event_id: event_id.to_owned() });
@@ -2223,7 +2224,7 @@ struct TimelineUiState {
     /// 
     /// Used to send fully read receipt after user scrolled pass the read marker
     /// Value is determined by comparing the fully read event with the event id of read receipt when sending out read receipt
-    scrolled_pass_read_marker: bool,
+    scrolled_past_read_marker: bool,
 }
 
 #[derive(Default, Debug)]
diff --git a/src/shared/jump_to_bottom_button.rs b/src/shared/jump_to_bottom_button.rs
index 78f89218..8ceafff4 100644
--- a/src/shared/jump_to_bottom_button.rs
+++ b/src/shared/jump_to_bottom_button.rs
@@ -112,8 +112,6 @@ impl JumpToBottomButton {
     /// Sets both the jump to bottom view and its unread message badge to be visible.
     ///
     /// This does not automatically redraw any views.
-    ///
-    /// TODO: in the future, we'll display the actual count of unread messages in the badge.
     pub fn show_unread_message_badge(&mut self, unread_message_count: usize) {
         if unread_message_count > 0 {
             self.visible = true;
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index 5d179c66..19029875 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -892,7 +892,10 @@ pub fn take_timeline_endpoints(
 }
 
 
-/// Return an option of OwnEventId for user's fully read event
+/// Return an option of user's fully read event id for a given room using Mutex Lock
+/// 
+/// Gets the fully read event for the given room
+/// Returns `None` if there is no fully read event
 pub fn take_fully_read_event(room_id: &OwnedRoomId) -> Option<OwnedEventId> {
     ALL_ROOM_INFO
         .lock()
@@ -900,7 +903,7 @@ pub fn take_fully_read_event(room_id: &OwnedRoomId) -> Option<OwnedEventId> {
         .get(room_id)
         .and_then(|ri| ri.fully_read_event.clone())
 }
-/// Update fully read event inside All Room Info after sending out read_receipt
+/// Update fully read event inside all Room Info after sending out read_receipt
 fn set_fully_read_event(room_id: &OwnedRoomId, read_event: OwnedEventId) {
     if let Some(ref mut room_info) = ALL_ROOM_INFO
         .lock()

From 170488c71f322db53d0c39f034acf07e475c01cf Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Tue, 19 Nov 2024 22:49:16 +0800
Subject: [PATCH 21/40] minor comment changes

---
 src/home/room_screen.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 5c92ad36..a466cd95 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -967,7 +967,7 @@ pub struct RoomScreen {
     #[rust] room_name: String,
     /// The persistent UI-relevant states for the room that this widget is currently displaying.
     #[rust] tl_state: Option<TimelineUiState>,
-    /// 5 secs timer when scroll ends
+    /// 5 secs timer starts when user scrolled past read marker
     #[rust] fully_read_timer: Option<Timer>,
 
 }
@@ -1296,11 +1296,12 @@ impl Widget for RoomScreen {
                 });
             }
         }
-        // Mark events as fully read after they have been displayed on screen for 5 seconds.
+        // Send fully read receipt for last displayed event 5 Seconds after user scrolled past the read marker
         if let Some(timer) = self.fully_read_timer {
             if timer.is_event(event).is_some() {
                 if let (Some(ref mut tl_state), Some(ref room_id)) = (&mut self.tl_state, &self.room_id) {
                     let Some(last_displayed_event) = &tl_state.last_displayed_event else { return };
+                    // let Some(last_displayed_event) = take_fully_read_event(room_id)  else { return };
                     submit_async_request(MatrixRequest::FullyReadReceipt { room_id: room_id.clone(), event_id: last_displayed_event.clone()});
                 }
                 cx.stop_timer(timer);

From 20982c2ad41958dc0577ac769b0f7d872307a80f Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Wed, 20 Nov 2024 00:36:00 +0800
Subject: [PATCH 22/40] fix not send read receipt when not scrolling

---
 src/home/room_screen.rs | 29 +++++++++++++++++++++++++----
 src/sliding_sync.rs     | 15 ++++++++-------
 2 files changed, 33 insertions(+), 11 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index a466cd95..8d19fbd6 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -1300,9 +1300,18 @@ impl Widget for RoomScreen {
         if let Some(timer) = self.fully_read_timer {
             if timer.is_event(event).is_some() {
                 if let (Some(ref mut tl_state), Some(ref room_id)) = (&mut self.tl_state, &self.room_id) {
-                    let Some(last_displayed_event) = &tl_state.last_displayed_event else { return };
-                    // let Some(last_displayed_event) = take_fully_read_event(room_id)  else { return };
-                    submit_async_request(MatrixRequest::FullyReadReceipt { room_id: room_id.clone(), event_id: last_displayed_event.clone()});
+                    let first_index = portal_list.first_id();
+                    if let Some(event_id) = tl_state
+                        .items
+                        .get(first_index + portal_list.visible_items())
+                        .and_then(|f| f.as_event())
+                        .and_then(|f| f.event_id())
+                    {
+                        submit_async_request(MatrixRequest::FullyReadReceipt {
+                            room_id: room_id.clone(),
+                            event_id: event_id.to_owned(),
+                        });
+                    }
                 }
                 cx.stop_timer(timer);
                 self.fully_read_timer = None;
@@ -1560,6 +1569,15 @@ impl RoomScreen {
                             }
                         }
                     }
+                    if is_append && portal_list.is_at_end() { //123
+                        let last_displayed_event = new_items.last().and_then(|f| f.as_event()).and_then(|f| f.event_id());
+                        if let (Some(event_id), Some(room_id)) = (last_displayed_event, &self.room_id) {
+                            submit_async_request(MatrixRequest::ReadReceipt {
+                                room_id: room_id.clone(),
+                                event_id: event_id.to_owned(),
+                            });
+                        }
+                    }
 
                     if clear_cache {
                         tl.content_drawn_since_last_update.clear();
@@ -1989,6 +2007,8 @@ impl RoomScreen {
         self.show_timeline(cx);
     }
 
+    
+
     /// Sends read receipts based on the current scroll position of the timeline.
     fn send_user_read_receipts_based_on_scroll_pos(
         &mut self,
@@ -2006,7 +2026,7 @@ impl RoomScreen {
         if let Some(ref mut index) = tl_state.prev_first_index {
             // to detect change of scroll when scroll ends
             if *index != first_index {
-                if first_index > *index {
+                if first_index >= *index {
                     if tl_state.scrolled_past_read_marker {
                         if let Some(timer) = self.fully_read_timer {
                             cx.stop_timer(timer);
@@ -2025,6 +2045,7 @@ impl RoomScreen {
                         
                         tl_state.last_displayed_event = Some(event_id.to_owned());
                     }
+                    //send_user_read_receipts(&mut self.fully_read_timer, cx, tl_state.items, first_index, portal_list, room_id);
                 }
                 *index = first_index;
             }
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index 19029875..35d0108e 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -674,10 +674,7 @@ async fn async_worker(
                 };
                 let _send_rr_task = Handle::current().spawn(async move {
                     match timeline.send_single_receipt(ReceiptType::Read, ReceiptThread::Unthreaded, event_id.clone()).await {
-                        Ok(sent) => log!("{} read receipt to room {room_id} for event {event_id}", if sent { 
-                            set_fully_read_event(&room_id, event_id.clone());
-                            "Sent" 
-                        } else { "Already sent" }),
+                        Ok(sent) => log!("{} read receipt to room {room_id} for event {event_id}", if sent { "Sent" } else { "Already sent" }),
                         Err(_e) => error!("Failed to send read receipt to room {room_id} for event {event_id}; error: {_e:?}"),
                     }
                 });
@@ -695,7 +692,10 @@ async fn async_worker(
                 let _send_frr_task = Handle::current().spawn(async move {
                     let receipt = Receipts::new().fully_read_marker(event_id.clone());
                     match timeline.send_multiple_receipts(receipt).await {
-                        Ok(()) => log!("Sent fully read receipt to room {room_id}, event {event_id}"),
+                        Ok(()) => {
+                            set_fully_read_event(&room_id, event_id.clone());
+                            log!("Sent fully read receipt to room {room_id}, event {event_id}")
+                        },
                         Err(_e) => error!("Failed to send fully read receipt to room {room_id}, event {event_id}; error: {_e:?}"),
                     }
                 });
@@ -897,11 +897,12 @@ pub fn take_timeline_endpoints(
 /// Gets the fully read event for the given room
 /// Returns `None` if there is no fully read event
 pub fn take_fully_read_event(room_id: &OwnedRoomId) -> Option<OwnedEventId> {
-    ALL_ROOM_INFO
+    let result = ALL_ROOM_INFO
         .lock()
         .unwrap()
         .get(room_id)
-        .and_then(|ri| ri.fully_read_event.clone())
+        .and_then(|ri| ri.fully_read_event.clone());
+    result
 }
 /// Update fully read event inside all Room Info after sending out read_receipt
 fn set_fully_read_event(room_id: &OwnedRoomId, read_event: OwnedEventId) {

From 1e5e36cfac076e73b61f0fe0097863cd2503cba0 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Wed, 20 Nov 2024 00:40:56 +0800
Subject: [PATCH 23/40] removed last_display_event

---
 src/home/room_screen.rs | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 8d19fbd6..f1f6b39a 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -1867,7 +1867,6 @@ impl RoomScreen {
                 message_highlight_animation_state: MessageHighlightAnimationState::default(),
                 last_scrolled_index: usize::MAX,
                 prev_first_index: None,
-                last_displayed_event: None,
                 scrolled_past_read_marker: false,
             };
             (new_tl_state, true)
@@ -2042,10 +2041,7 @@ impl RoomScreen {
                             }
                         }
                         submit_async_request(MatrixRequest::ReadReceipt { room_id: room_id.clone(), event_id: event_id.to_owned() });
-                        
-                        tl_state.last_displayed_event = Some(event_id.to_owned());
                     }
-                    //send_user_read_receipts(&mut self.fully_read_timer, cx, tl_state.items, first_index, portal_list, room_id);
                 }
                 *index = first_index;
             }
@@ -2238,10 +2234,6 @@ struct TimelineUiState {
     /// The index of the first item in the timeline that is currently visible
     prev_first_index: Option<usize>,
 
-    /// Last displayed event after scrolling.
-    /// 
-    /// Used for sending fully read receipt
-    last_displayed_event: Option<OwnedEventId>,
     /// Boolean to indicate if the user scrolled pass the read marker
     /// 
     /// Used to send fully read receipt after user scrolled pass the read marker

From b4b5116ad651e618905442cd7cb91e451bb4a94d Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Sat, 23 Nov 2024 11:40:15 +0800
Subject: [PATCH 24/40] Using fully_read_event's timestamp to determine
 scrolled_past_fully_read

---
 src/home/room_screen.rs |  73 +++++++++++++++++++---------
 src/sliding_sync.rs     | 105 ++++++++++++++++++++++++++++++----------
 2 files changed, 128 insertions(+), 50 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index f1f6b39a..8d2fb337 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -967,7 +967,10 @@ pub struct RoomScreen {
     #[rust] room_name: String,
     /// The persistent UI-relevant states for the room that this widget is currently displaying.
     #[rust] tl_state: Option<TimelineUiState>,
-    /// 5 secs timer starts when user scrolled past read marker
+    /// Timer to send fully read receipt
+    /// 
+    /// 5 secs timer starts when user scrolled down and scrolled_past_read_marker is true
+    /// Last displayed event will be sent as fully read receipt
     #[rust] fully_read_timer: Option<Timer>,
 
 }
@@ -1300,16 +1303,14 @@ impl Widget for RoomScreen {
         if let Some(timer) = self.fully_read_timer {
             if timer.is_event(event).is_some() {
                 if let (Some(ref mut tl_state), Some(ref room_id)) = (&mut self.tl_state, &self.room_id) {
-                    let first_index = portal_list.first_id();
-                    if let Some(event_id) = tl_state
-                        .items
-                        .get(first_index + portal_list.visible_items())
-                        .and_then(|f| f.as_event())
-                        .and_then(|f| f.event_id())
+                    if let Some((event_id, timestamp)) = tl_state
+                        .last_display_event
+                        .take()
                     {
                         submit_async_request(MatrixRequest::FullyReadReceipt {
                             room_id: room_id.clone(),
-                            event_id: event_id.to_owned(),
+                            event_id,
+                            timestamp,
                         });
                     }
                 }
@@ -1542,6 +1543,7 @@ impl RoomScreen {
                             log!("Timeline::handle_event(): jumping view from event index {curr_item_idx} to new index {new_item_idx}, scroll {new_item_scroll}, event ID {_event_id}");
                             portal_list.set_first_id_and_scroll(new_item_idx, new_item_scroll);
                             tl.prev_first_index = Some(new_item_idx);
+                            // Reset the fully read timer when we jump to a new event
                             if let Some(timer) = self.fully_read_timer {
                                 cx.stop_timer(timer);
                             }
@@ -1558,7 +1560,6 @@ impl RoomScreen {
 
                     // If new items were appended to the end of the timeline, show an unread messages badge on the jump to bottom button.
                     if is_append && !portal_list.is_at_end() {
-                        log!("is_append was true, showing unread message badge on the jump to bottom button visible");
                         // Set the number of unread messages to unread_notification_badge
                         if let Some(room_id) = &self.room_id {
                             if let Some(num_unread) = get_client()
@@ -1569,7 +1570,9 @@ impl RoomScreen {
                             }
                         }
                     }
-                    if is_append && portal_list.is_at_end() { //123
+                    // When new messages are appended to the end of the timeline, user sees them.
+                    // We want to send the read receipt
+                    if is_append && portal_list.is_at_end() {
                         let last_displayed_event = new_items.last().and_then(|f| f.as_event()).and_then(|f| f.event_id());
                         if let (Some(event_id), Some(room_id)) = (last_displayed_event, &self.room_id) {
                             submit_async_request(MatrixRequest::ReadReceipt {
@@ -1868,6 +1871,7 @@ impl RoomScreen {
                 last_scrolled_index: usize::MAX,
                 prev_first_index: None,
                 scrolled_past_read_marker: false,
+                last_display_event: None,
             };
             (new_tl_state, true)
         };
@@ -1881,6 +1885,9 @@ impl RoomScreen {
             }
         );
 
+        // Query for User's fully read event
+        submit_async_request(MatrixRequest::GetFullyReadEvent { room_id: room_id.clone() });
+
         // Kick off a back pagination request for this room. This is "urgent",
         // because we want to show the user some messages as soon as possible
         // when they first open the room, and there might not be any messages yet.
@@ -2006,8 +2013,6 @@ impl RoomScreen {
         self.show_timeline(cx);
     }
 
-    
-
     /// Sends read receipts based on the current scroll position of the timeline.
     fn send_user_read_receipts_based_on_scroll_pos(
         &mut self,
@@ -2025,22 +2030,36 @@ impl RoomScreen {
         if let Some(ref mut index) = tl_state.prev_first_index {
             // to detect change of scroll when scroll ends
             if *index != first_index {
+                // Any scrolling, resets the fully_read_timer
+                if let Some(timer) = self.fully_read_timer {
+                    cx.stop_timer(timer);
+                }
+                self.fully_read_timer = None;
                 if first_index >= *index {
+                    // Get event_id and timestamp for the last visible event
+                    let Some((last_event_id, last_timestamp)) = tl_state.items.get(first_index + portal_list.visible_items())
+                        .and_then(|f| f.as_event() )
+                        .and_then(|f| f.event_id().map(|e| (e, f.timestamp())) ) else { *index = first_index; return };
+                        submit_async_request(MatrixRequest::ReadReceipt { room_id: room_id.clone(), event_id: last_event_id.to_owned() });
+                    // If scrolled_past_read_marker is true, set last_display_event to last_event_id and start the timer
                     if tl_state.scrolled_past_read_marker {
-                        if let Some(timer) = self.fully_read_timer {
-                            cx.stop_timer(timer);
-                        }
                         self.fully_read_timer = Some(cx.start_timeout(5.0));
-                    }
-                    if let Some(event_id) = tl_state.items.get(first_index + portal_list.visible_items())
+                        tl_state.last_display_event = Some((last_event_id.to_owned(), last_timestamp));
+                    } else {
+                        // Get event_id and timestamp for the first visible event
+                        // If scrolled_past_read_marker is false, check if the saved fully read event's timestamp in between the first and last visible event
+                        // If true, set scrolled_past_read_marker to true
+                        // If true, set last_display_event to last_event_id
+                        // If true, start the 5 seconds timer
+                        let Some((_fully_read_event, fully_read_timestamp)) = take_fully_read_event(&room_id) else { *index = first_index; return;};
+                        let Some((_first_event_id, first_timestamp)) = tl_state.items.get(first_index)
                             .and_then(|f| f.as_event() )
-                            .and_then(|f| f.event_id() ) {
-                        if let Some(fully_read_event) = take_fully_read_event(&room_id) {
-                            if &fully_read_event == event_id {
-                                tl_state.scrolled_past_read_marker = true;
-                            }
+                            .and_then(|f| f.event_id().map(|e| (e, f.timestamp())) ) else { *index = first_index; return;};
+                        if fully_read_timestamp >= first_timestamp && fully_read_timestamp <= last_timestamp {
+                            tl_state.scrolled_past_read_marker = true;
+                            tl_state.last_display_event = Some((last_event_id.to_owned(), last_timestamp));
+                            self.fully_read_timer = Some(cx.start_timeout(5.0));
                         }
-                        submit_async_request(MatrixRequest::ReadReceipt { room_id: room_id.clone(), event_id: event_id.to_owned() });
                     }
                 }
                 *index = first_index;
@@ -2237,8 +2256,14 @@ struct TimelineUiState {
     /// Boolean to indicate if the user scrolled pass the read marker
     /// 
     /// Used to send fully read receipt after user scrolled pass the read marker
-    /// Value is determined by comparing the fully read event with the event id of read receipt when sending out read receipt
+    /// Read marker is referred to Red marker in the UI or also known as latest fully read receipt 
+    /// Value is determined by comparing the fully read event with the event id of read receipt being sent out
+    /// When scrolling down, if scrolled_past_read_marker is true, a 5 seconds timer is started.
+    /// Once the countdown ends, the app will send out last visible event's fully read receipt which will be stored as RoomInfo's fully_read_event
+    /// In between, any scrolling or new message comming in will reset the timer
     scrolled_past_read_marker: bool,
+    /// EventId and timestamp of the last displayed event in the timeline
+    last_display_event: Option<(OwnedEventId, MilliSecondsSinceUnixEpoch)>,
 }
 
 #[derive(Default, Debug)]
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index 35d0108e..692cd9b1 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -6,8 +6,8 @@ use futures_util::{pin_mut, StreamExt};
 use imbl::Vector;
 use makepad_widgets::{error, log, warning, Cx, SignalToUI};
 use matrix_sdk::{
-    config::RequestConfig, event_handler::EventHandlerDropGuard, media::MediaRequest, room::{Receipts, RoomMember}, ruma::{
-        api::client::{receipt::create_receipt::v3::ReceiptType, session::get_login_types::v3::LoginType}, events::{
+    config::RequestConfig, deserialized_responses::TimelineEventKind, event_handler::EventHandlerDropGuard, media::MediaRequest, room::{Receipts, RoomMember}, ruma::{
+        api::{client::{receipt::create_receipt::v3::ReceiptType, session::get_login_types::v3::LoginType}}, events::{
             fully_read::FullyReadEventContent,
             receipt::ReceiptThread, room::{
                 message::{ForwardThread, RoomMessageEventContent}, MediaSource
@@ -227,6 +227,9 @@ pub enum MatrixRequest {
         /// * If `false` (recommended), details will be fetched from the server.
         local_only: bool,
     },
+    GetFullyReadEvent{
+        room_id: OwnedRoomId,
+    },
     /// Request to ignore/block or unignore/unblock a user.
     IgnoreUser {
         /// Whether to ignore (`true`) or unignore (`false`) the user.
@@ -288,6 +291,7 @@ pub enum MatrixRequest {
     FullyReadReceipt{
         room_id: OwnedRoomId,
         event_id: OwnedEventId,
+        timestamp: MilliSecondsSinceUnixEpoch
     }
 }
 
@@ -483,7 +487,46 @@ async fn async_worker(
                     }
                 });
             }
-
+            MatrixRequest::GetFullyReadEvent { room_id } => {
+                let Some(room) = CLIENT.get().and_then(|c| c.get_room(&room_id)) else {
+                    error!("BUG: client/room not found for Get Fully Read Event {room_id}");
+                    continue;
+                };
+                
+                let _get_fully_read_event_task = Handle::current().spawn(async move {
+                    async fn fetch_fully_read_event(room: &Room, room_id: &OwnedRoomId) -> Result<(OwnedEventId, MilliSecondsSinceUnixEpoch),  anyhow::Error> {
+                        let fully_read_event =  room
+                            .account_data_static::<FullyReadEventContent>().await?
+                            .and_then(|f| f.deserialize().ok())
+                            .and_then(|f| Some(f.content.event_id));
+                        if let Some(event_id) = fully_read_event {
+                            let event = room.event(&event_id, None).await?;
+                            match event.kind {
+                                TimelineEventKind::Decrypted(decrypted_room_event) => {
+                                    return decrypted_room_event.event.deserialize().map(|e| (event_id, e.origin_server_ts())).map_err(|e| e.into());
+                                }
+                                TimelineEventKind::PlainText { event } => {
+                                    return event.deserialize().map(|e| (event_id, e.origin_server_ts())).map_err(|e| e.into());
+                                }
+                                _ => {
+                                    bail!("Failed to fetch fully read event for room {room_id} because there is no TimelineEventKind::Decrypted");
+                                }
+                            }
+                        } else {
+                            bail!("Failed to fetch fully read event for room {room_id} because there is no fully read event");
+                        }
+                    }
+                    match fetch_fully_read_event(&room, &room_id).await {
+                        Ok((event_id, timestamp)) => {
+                            log!("Successfully fetched fully read event for room {room_id} at {timestamp:?} for {event_id}");
+                            set_fully_read_event(&room_id, event_id, timestamp);
+                        }
+                        Err(e) => {
+                            log!("{}", e.to_string());
+                        }
+                    }
+                });
+            }
             MatrixRequest::IgnoreUser { ignore, room_member, room_id } => {
                 let Some(client) = CLIENT.get() else { continue };
                 let _ignore_task = Handle::current().spawn(async move {
@@ -680,20 +723,25 @@ async fn async_worker(
                 });
             },
 
-            MatrixRequest::FullyReadReceipt { room_id, event_id }=>{
+            MatrixRequest::FullyReadReceipt { room_id, event_id, timestamp }=>{
                 let timeline = {
                     let all_room_info = ALL_ROOM_INFO.lock().unwrap();
                     let Some(room_info) = all_room_info.get(&room_id) else {
                         log!("BUG: room info not found when sending fully read receipt, room {room_id}, {event_id}");
                         continue;
                     };
+                    if let Some((_existing_event_id, existing_timestamp)) = &room_info.fully_read_event {
+                        if timestamp < *existing_timestamp {
+                            continue;
+                        }
+                    }
                     room_info.timeline.clone()
                 };
                 let _send_frr_task = Handle::current().spawn(async move {
                     let receipt = Receipts::new().fully_read_marker(event_id.clone());
                     match timeline.send_multiple_receipts(receipt).await {
                         Ok(()) => {
-                            set_fully_read_event(&room_id, event_id.clone());
+                            set_fully_read_event(&room_id, event_id.clone(), timestamp);
                             log!("Sent fully read receipt to room {room_id}, event {event_id}")
                         },
                         Err(_e) => error!("Failed to send fully read receipt to room {room_id}, event {event_id}; error: {_e:?}"),
@@ -811,8 +859,8 @@ struct RoomInfo {
     typing_notice_subscriber: Option<EventHandlerDropGuard>,
     /// The ID of the old tombstoned room that this room has replaced, if any.
     replaces_tombstoned_room: Option<OwnedRoomId>,
-    /// event_id for read marker
-    fully_read_event: Option<OwnedEventId>,
+    /// Event_id and timestamp for read marker
+    fully_read_event: Option<(OwnedEventId, MilliSecondsSinceUnixEpoch)>,
 }
 impl Drop for RoomInfo {
     fn drop(&mut self) {
@@ -892,26 +940,36 @@ pub fn take_timeline_endpoints(
 }
 
 
-/// Return an option of user's fully read event id for a given room using Mutex Lock
+/// Return an option of user's fully read event id and timestamp for a given room using Mutex Lock
 /// 
 /// Gets the fully read event for the given room
 /// Returns `None` if there is no fully read event
-pub fn take_fully_read_event(room_id: &OwnedRoomId) -> Option<OwnedEventId> {
+pub fn take_fully_read_event(room_id: &OwnedRoomId) -> Option<(OwnedEventId, MilliSecondsSinceUnixEpoch)> {
     let result = ALL_ROOM_INFO
         .lock()
-        .unwrap()
-        .get(room_id)
-        .and_then(|ri| ri.fully_read_event.clone());
+        .map(|guard| {
+            guard
+                .get(room_id)
+                .and_then(|ri| ri.fully_read_event.clone())
+        })
+        .unwrap_or_else(|_| None);
     result
 }
-/// Update fully read event inside all Room Info after sending out read_receipt
-fn set_fully_read_event(room_id: &OwnedRoomId, read_event: OwnedEventId) {
-    if let Some(ref mut room_info) = ALL_ROOM_INFO
-        .lock()
-        .unwrap()
-        .get_mut(room_id) {
-            room_info.fully_read_event = Some(read_event)
-        }
+/// Update fully read event inside Room Info after sending out read_receipt
+fn set_fully_read_event(room_id: &OwnedRoomId, read_event: OwnedEventId, timestamp: MilliSecondsSinceUnixEpoch) {
+    let _ = ALL_ROOM_INFO
+    .lock()
+    .map(|mut guard| {
+        if let Some(room_info) = guard
+            .get_mut(room_id) {
+                room_info.fully_read_event = Some((read_event, timestamp));
+                return Ok(());
+            } else {
+                return Err(anyhow::anyhow!("Cannot find room info for room {}", room_id));
+            }
+    }).map_err(|e|{
+        error!("Error updating fully read event: {e:?}");
+    });
 }
 const DEFAULT_HOMESERVER: &str = "matrix.org";
 
@@ -1301,11 +1359,6 @@ async fn add_new_room(room: &room_list_service::Room) -> Result<()> {
     }));
 
     spawn_fetch_room_avatar(room.inner_room().clone());
-    let fully_read_event = room
-        .account_data_static::<FullyReadEventContent>()
-        .await?
-        .and_then(|f| f.deserialize().ok())
-        .and_then(|f| Some(f.content.event_id));
     let tombstoned_room_replaced_by_this_room = TOMBSTONED_ROOMS.lock()
         .unwrap()
         .remove(&room_id);
@@ -1321,7 +1374,7 @@ async fn add_new_room(room: &room_list_service::Room) -> Result<()> {
             timeline_subscriber_handler_task,
             typing_notice_subscriber: None,
             replaces_tombstoned_room: tombstoned_room_replaced_by_this_room,
-            fully_read_event
+            fully_read_event: None
         },
     );
     Ok(())

From 84faf5e94794f60561c21d83baddf579f94f02cb Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Sat, 23 Nov 2024 12:05:53 +0800
Subject: [PATCH 25/40] added doc, use timer.is_empty to check for events

---
 src/home/room_screen.rs | 48 ++++++++++++++++++-----------------------
 src/sliding_sync.rs     |  2 ++
 2 files changed, 23 insertions(+), 27 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 8d2fb337..ec0a6a46 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -937,6 +937,7 @@ live_design! {
                 }
             }
         }
+
         animator: {
             typing_notice_animator = {
                 default: show,
@@ -971,7 +972,7 @@ pub struct RoomScreen {
     /// 
     /// 5 secs timer starts when user scrolled down and scrolled_past_read_marker is true
     /// Last displayed event will be sent as fully read receipt
-    #[rust] fully_read_timer: Option<Timer>,
+    #[rust] fully_read_timer: Timer,
 
 }
 impl Drop for RoomScreen {
@@ -1300,23 +1301,20 @@ impl Widget for RoomScreen {
             }
         }
         // Send fully read receipt for last displayed event 5 Seconds after user scrolled past the read marker
-        if let Some(timer) = self.fully_read_timer {
-            if timer.is_event(event).is_some() {
-                if let (Some(ref mut tl_state), Some(ref room_id)) = (&mut self.tl_state, &self.room_id) {
-                    if let Some((event_id, timestamp)) = tl_state
-                        .last_display_event
-                        .take()
-                    {
-                        submit_async_request(MatrixRequest::FullyReadReceipt {
-                            room_id: room_id.clone(),
-                            event_id,
-                            timestamp,
-                        });
-                    }
+        if self.fully_read_timer.is_event(event).is_some() && !self.fully_read_timer.is_empty() {
+            if let (Some(ref mut tl_state), Some(ref room_id)) = (&mut self.tl_state, &self.room_id) {
+                if let Some((event_id, timestamp)) = tl_state
+                    .last_display_event
+                    .take()
+                {
+                    submit_async_request(MatrixRequest::FullyReadReceipt {
+                        room_id: room_id.clone(),
+                        event_id,
+                        timestamp,
+                    });
                 }
-                cx.stop_timer(timer);
-                self.fully_read_timer = None;
             }
+            cx.stop_timer(self.fully_read_timer);
         }
 
         if self.animator_handle_event(cx, event).must_redraw() {
@@ -1544,10 +1542,7 @@ impl RoomScreen {
                             portal_list.set_first_id_and_scroll(new_item_idx, new_item_scroll);
                             tl.prev_first_index = Some(new_item_idx);
                             // Reset the fully read timer when we jump to a new event
-                            if let Some(timer) = self.fully_read_timer {
-                                cx.stop_timer(timer);
-                            }
-                            self.fully_read_timer = None;
+                            cx.stop_timer(self.fully_read_timer);
                             tl.scrolled_past_read_marker = false;
                         }
                     }
@@ -2031,10 +2026,7 @@ impl RoomScreen {
             // to detect change of scroll when scroll ends
             if *index != first_index {
                 // Any scrolling, resets the fully_read_timer
-                if let Some(timer) = self.fully_read_timer {
-                    cx.stop_timer(timer);
-                }
-                self.fully_read_timer = None;
+                cx.stop_timer(self.fully_read_timer);
                 if first_index >= *index {
                     // Get event_id and timestamp for the last visible event
                     let Some((last_event_id, last_timestamp)) = tl_state.items.get(first_index + portal_list.visible_items())
@@ -2043,13 +2035,13 @@ impl RoomScreen {
                         submit_async_request(MatrixRequest::ReadReceipt { room_id: room_id.clone(), event_id: last_event_id.to_owned() });
                     // If scrolled_past_read_marker is true, set last_display_event to last_event_id and start the timer
                     if tl_state.scrolled_past_read_marker {
-                        self.fully_read_timer = Some(cx.start_timeout(5.0));
+                        self.fully_read_timer = cx.start_timeout(5.0);
                         tl_state.last_display_event = Some((last_event_id.to_owned(), last_timestamp));
                     } else {
                         // Get event_id and timestamp for the first visible event
                         // If scrolled_past_read_marker is false, check if the saved fully read event's timestamp in between the first and last visible event
                         // If true, set scrolled_past_read_marker to true
-                        // If true, set last_display_event to last_event_id
+                        // If true, set last_event_id to last_display_event
                         // If true, start the 5 seconds timer
                         let Some((_fully_read_event, fully_read_timestamp)) = take_fully_read_event(&room_id) else { *index = first_index; return;};
                         let Some((_first_event_id, first_timestamp)) = tl_state.items.get(first_index)
@@ -2058,7 +2050,7 @@ impl RoomScreen {
                         if fully_read_timestamp >= first_timestamp && fully_read_timestamp <= last_timestamp {
                             tl_state.scrolled_past_read_marker = true;
                             tl_state.last_display_event = Some((last_event_id.to_owned(), last_timestamp));
-                            self.fully_read_timer = Some(cx.start_timeout(5.0));
+                            self.fully_read_timer = cx.start_timeout(5.0);
                         }
                     }
                 }
@@ -2263,6 +2255,8 @@ struct TimelineUiState {
     /// In between, any scrolling or new message comming in will reset the timer
     scrolled_past_read_marker: bool,
     /// EventId and timestamp of the last displayed event in the timeline
+    /// 
+    /// To be send as fully read receipt
     last_display_event: Option<(OwnedEventId, MilliSecondsSinceUnixEpoch)>,
 }
 
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index 692cd9b1..2ebb22d8 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -730,6 +730,7 @@ async fn async_worker(
                         log!("BUG: room info not found when sending fully read receipt, room {room_id}, {event_id}");
                         continue;
                     };
+                    // If the new fully read event is older than the existing one, do not send the receipt
                     if let Some((_existing_event_id, existing_timestamp)) = &room_info.fully_read_event {
                         if timestamp < *existing_timestamp {
                             continue;
@@ -1359,6 +1360,7 @@ async fn add_new_room(room: &room_list_service::Room) -> Result<()> {
     }));
 
     spawn_fetch_room_avatar(room.inner_room().clone());
+
     let tombstoned_room_replaced_by_this_room = TOMBSTONED_ROOMS.lock()
         .unwrap()
         .remove(&room_id);

From e7481968334935e943bb782f40844ca58e1cb298 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Sat, 23 Nov 2024 12:28:15 +0800
Subject: [PATCH 26/40] code cleanup

---
 src/home/room_screen.rs             | 58 +++++++++++++++++++++--------
 src/shared/jump_to_bottom_button.rs |  1 +
 src/sliding_sync.rs                 |  4 +-
 3 files changed, 46 insertions(+), 17 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index ec0a6a46..c6b7fb31 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -1565,8 +1565,8 @@ impl RoomScreen {
                             }
                         }
                     }
-                    // When new messages are appended to the end of the timeline, user sees them.
-                    // We want to send the read receipt
+                    // When new messages are added to the end of the timeline, 
+                    // we want to send the read receipt when the user sees them.
                     if is_append && portal_list.is_at_end() {
                         let last_displayed_event = new_items.last().and_then(|f| f.as_event()).and_then(|f| f.event_id());
                         if let (Some(event_id), Some(room_id)) = (last_displayed_event, &self.room_id) {
@@ -2020,8 +2020,12 @@ impl RoomScreen {
             return;
         }
         let first_index = portal_list.first_id();
-        let Some(tl_state) = self.tl_state.as_mut() else { return };
-        let Some(room_id) = self.room_id.as_ref() else { return };
+        let Some(tl_state) = self.tl_state.as_mut() else {
+            return;
+        };
+        let Some(room_id) = self.room_id.as_ref() else {
+            return;
+        };
         if let Some(ref mut index) = tl_state.prev_first_index {
             // to detect change of scroll when scroll ends
             if *index != first_index {
@@ -2029,10 +2033,19 @@ impl RoomScreen {
                 cx.stop_timer(self.fully_read_timer);
                 if first_index >= *index {
                     // Get event_id and timestamp for the last visible event
-                    let Some((last_event_id, last_timestamp)) = tl_state.items.get(first_index + portal_list.visible_items())
-                        .and_then(|f| f.as_event() )
-                        .and_then(|f| f.event_id().map(|e| (e, f.timestamp())) ) else { *index = first_index; return };
-                        submit_async_request(MatrixRequest::ReadReceipt { room_id: room_id.clone(), event_id: last_event_id.to_owned() });
+                    let Some((last_event_id, last_timestamp)) = tl_state
+                        .items
+                        .get(first_index + portal_list.visible_items())
+                        .and_then(|f| f.as_event())
+                        .and_then(|f| f.event_id().map(|e| (e, f.timestamp())))
+                    else {
+                        *index = first_index;
+                        return;
+                    };
+                    submit_async_request(MatrixRequest::ReadReceipt {
+                        room_id: room_id.clone(),
+                        event_id: last_event_id.to_owned(),
+                    });
                     // If scrolled_past_read_marker is true, set last_display_event to last_event_id and start the timer
                     if tl_state.scrolled_past_read_marker {
                         self.fully_read_timer = cx.start_timeout(5.0);
@@ -2043,13 +2056,27 @@ impl RoomScreen {
                         // If true, set scrolled_past_read_marker to true
                         // If true, set last_event_id to last_display_event
                         // If true, start the 5 seconds timer
-                        let Some((_fully_read_event, fully_read_timestamp)) = take_fully_read_event(&room_id) else { *index = first_index; return;};
-                        let Some((_first_event_id, first_timestamp)) = tl_state.items.get(first_index)
-                            .and_then(|f| f.as_event() )
-                            .and_then(|f| f.event_id().map(|e| (e, f.timestamp())) ) else { *index = first_index; return;};
-                        if fully_read_timestamp >= first_timestamp && fully_read_timestamp <= last_timestamp {
+                        let Some((_fully_read_event, fully_read_timestamp)) =
+                            take_fully_read_event(&room_id)
+                        else {
+                            *index = first_index;
+                            return;
+                        };
+                        let Some((_first_event_id, first_timestamp)) = tl_state
+                            .items
+                            .get(first_index)
+                            .and_then(|f| f.as_event())
+                            .and_then(|f| f.event_id().map(|e| (e, f.timestamp())))
+                        else {
+                            *index = first_index;
+                            return;
+                        };
+                        if fully_read_timestamp >= first_timestamp
+                            && fully_read_timestamp <= last_timestamp
+                        {
                             tl_state.scrolled_past_read_marker = true;
-                            tl_state.last_display_event = Some((last_event_id.to_owned(), last_timestamp));
+                            tl_state.last_display_event =
+                                Some((last_event_id.to_owned(), last_timestamp));
                             self.fully_read_timer = cx.start_timeout(5.0);
                         }
                     }
@@ -2252,8 +2279,9 @@ struct TimelineUiState {
     /// Value is determined by comparing the fully read event with the event id of read receipt being sent out
     /// When scrolling down, if scrolled_past_read_marker is true, a 5 seconds timer is started.
     /// Once the countdown ends, the app will send out last visible event's fully read receipt which will be stored as RoomInfo's fully_read_event
-    /// In between, any scrolling or new message comming in will reset the timer
+    /// In between, any scrolling or new message coming in will reset the timer
     scrolled_past_read_marker: bool,
+
     /// EventId and timestamp of the last displayed event in the timeline
     /// 
     /// To be send as fully read receipt
diff --git a/src/shared/jump_to_bottom_button.rs b/src/shared/jump_to_bottom_button.rs
index 8ceafff4..a76e9b60 100644
--- a/src/shared/jump_to_bottom_button.rs
+++ b/src/shared/jump_to_bottom_button.rs
@@ -112,6 +112,7 @@ impl JumpToBottomButton {
     /// Sets both the jump to bottom view and its unread message badge to be visible.
     ///
     /// This does not automatically redraw any views.
+    /// If unread_message_count is `0`, the unread message badge is hidden.
     pub fn show_unread_message_badge(&mut self, unread_message_count: usize) {
         if unread_message_count > 0 {
             self.visible = true;
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index 2ebb22d8..292bbcf3 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -706,7 +706,7 @@ async fn async_worker(
                 });
             }
 
-            MatrixRequest::ReadReceipt { room_id, event_id }=>{
+            MatrixRequest::ReadReceipt { room_id, event_id } => {
                 let timeline = {
                     let all_room_info = ALL_ROOM_INFO.lock().unwrap();
                     let Some(room_info) = all_room_info.get(&room_id) else {
@@ -723,7 +723,7 @@ async fn async_worker(
                 });
             },
 
-            MatrixRequest::FullyReadReceipt { room_id, event_id, timestamp }=>{
+            MatrixRequest::FullyReadReceipt { room_id, event_id, timestamp } => {
                 let timeline = {
                     let all_room_info = ALL_ROOM_INFO.lock().unwrap();
                     let Some(room_info) = all_room_info.get(&room_id) else {

From 963a7221c15d6dad2b13b23b7dc43ec96fb49084 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Mon, 25 Nov 2024 22:46:59 +0800
Subject: [PATCH 27/40] Code improvement n log improvement

---
 src/home/room_screen.rs | 5 +----
 src/sliding_sync.rs     | 2 +-
 2 files changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index c6b7fb31..05968013 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -2020,10 +2020,7 @@ impl RoomScreen {
             return;
         }
         let first_index = portal_list.first_id();
-        let Some(tl_state) = self.tl_state.as_mut() else {
-            return;
-        };
-        let Some(room_id) = self.room_id.as_ref() else {
+        let (Some(tl_state), Some(room_id)) = (self.tl_state.as_mut(), self.room_id.as_ref()) else {
             return;
         };
         if let Some(ref mut index) = tl_state.prev_first_index {
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index 292bbcf3..151f1cd6 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -522,7 +522,7 @@ async fn async_worker(
                             set_fully_read_event(&room_id, event_id, timestamp);
                         }
                         Err(e) => {
-                            log!("{}", e.to_string());
+                            log!("Failed to fetch fully read event for room {room_id} {e:?}");
                         }
                     }
                 });

From 1566621a0971435e3ba25cc8b52e61094dd51719 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Wed, 27 Nov 2024 10:27:43 +0800
Subject: [PATCH 28/40] changed and_then to map

Co-authored-by: Kevin Boos <1139460+kevinaboos@users.noreply.github.com>
---
 src/sliding_sync.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index 151f1cd6..e1e96795 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -498,7 +498,7 @@ async fn async_worker(
                         let fully_read_event =  room
                             .account_data_static::<FullyReadEventContent>().await?
                             .and_then(|f| f.deserialize().ok())
-                            .and_then(|f| Some(f.content.event_id));
+                            .map(|f| f.content.event_id);
                         if let Some(event_id) = fully_read_event {
                             let event = room.event(&event_id, None).await?;
                             match event.kind {

From 3627a1f92b8d5518974594a364aa07f89c950946 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Wed, 27 Nov 2024 10:29:39 +0800
Subject: [PATCH 29/40] changed to get_fully_read_event

Co-authored-by: Kevin Boos <1139460+kevinaboos@users.noreply.github.com>
---
 src/sliding_sync.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index e1e96795..d89ab363 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -945,7 +945,7 @@ pub fn take_timeline_endpoints(
 /// 
 /// Gets the fully read event for the given room
 /// Returns `None` if there is no fully read event
-pub fn take_fully_read_event(room_id: &OwnedRoomId) -> Option<(OwnedEventId, MilliSecondsSinceUnixEpoch)> {
+pub fn get_fully_read_event(room_id: &OwnedRoomId) -> Option<(OwnedEventId, MilliSecondsSinceUnixEpoch)> {
     let result = ALL_ROOM_INFO
         .lock()
         .map(|guard| {

From 07df9fd551827a349dcac12e447572ae55bb9a67 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Wed, 27 Nov 2024 13:46:41 +0800
Subject: [PATCH 30/40] cap at 99+

---
 src/shared/jump_to_bottom_button.rs |  9 +++++++--
 src/sliding_sync.rs                 | 17 ++++-------------
 2 files changed, 11 insertions(+), 15 deletions(-)

diff --git a/src/shared/jump_to_bottom_button.rs b/src/shared/jump_to_bottom_button.rs
index a76e9b60..55677293 100644
--- a/src/shared/jump_to_bottom_button.rs
+++ b/src/shared/jump_to_bottom_button.rs
@@ -117,11 +117,16 @@ impl JumpToBottomButton {
         if unread_message_count > 0 {
             self.visible = true;
             self.view(id!(unread_message_badge)).set_visible(true);
-            self.label(id!(unread_messages_count)).set_text(&format!("{}", unread_message_count));
+            self.label(id!(unread_messages_count)).set_text(&format!(
+                "{}{}",
+                std::cmp::min(unread_message_count, 99),
+                if unread_message_count > 99 { "+" } else { "" }
+            ));
         } else {
             self.visible = false;
             self.view(id!(unread_message_badge)).set_visible(false);
-            self.label(id!(unread_messages_count)).set_text(&format!("{}", ""));
+            self.label(id!(unread_messages_count))
+                .set_text(&format!("{}", ""));
         }
     }
 
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index 151f1cd6..2f5f4dee 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -730,22 +730,13 @@ async fn async_worker(
                         log!("BUG: room info not found when sending fully read receipt, room {room_id}, {event_id}");
                         continue;
                     };
-                    // If the new fully read event is older than the existing one, do not send the receipt
-                    if let Some((_existing_event_id, existing_timestamp)) = &room_info.fully_read_event {
-                        if timestamp < *existing_timestamp {
-                            continue;
-                        }
-                    }
                     room_info.timeline.clone()
                 };
                 let _send_frr_task = Handle::current().spawn(async move {
-                    let receipt = Receipts::new().fully_read_marker(event_id.clone());
-                    match timeline.send_multiple_receipts(receipt).await {
-                        Ok(()) => {
-                            set_fully_read_event(&room_id, event_id.clone(), timestamp);
-                            log!("Sent fully read receipt to room {room_id}, event {event_id}")
-                        },
-                        Err(_e) => error!("Failed to send fully read receipt to room {room_id}, event {event_id}; error: {_e:?}"),
+                    let receipt_type = ReceiptType::FullyRead;
+                    match timeline.send_single_receipt(receipt_type, ReceiptThread::Unthreaded, event_id.clone()).await {
+                        Ok(sent) => log!("{} send fully read receipt to room {room_id} for event {event_id}", if sent { "Sent" } else { "Already sent" }),
+                        Err(_e) => error!("Failed to send fully read receipt to room {room_id} for event {event_id}; error: {_e:?}"),
                     }
                 });
             }    

From 1e7d4b2566fb40c13e0edcc645ddce7564e6956a Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Wed, 27 Nov 2024 14:13:29 +0800
Subject: [PATCH 31/40] change to get_fully_read_event

---
 src/home/room_screen.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 387f9b60..9a248a4b 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -27,7 +27,7 @@ use crate::{
         user_profile_cache,
     }, shared::{
         avatar::{AvatarRef, AvatarWidgetRefExt}, html_or_plaintext::{HtmlOrPlaintextRef, HtmlOrPlaintextWidgetRefExt}, jump_to_bottom_button::JumpToBottomButtonWidgetExt, text_or_image::{TextOrImageRef, TextOrImageWidgetRefExt}, typing_animation::TypingAnimationWidgetExt
-    }, sliding_sync::{get_client, submit_async_request, take_timeline_endpoints, BackwardsPaginateUntilEventRequest, MatrixRequest, PaginationDirection, TimelineRequestSender}, utils::{self, unix_time_millis_to_datetime, ImageFormat, MediaFormatConst}
+    }, sliding_sync::{get_client, get_fully_read_event, submit_async_request, take_timeline_endpoints, BackwardsPaginateUntilEventRequest, MatrixRequest, PaginationDirection, TimelineRequestSender}, utils::{self, unix_time_millis_to_datetime, ImageFormat, MediaFormatConst}
 };
 use rangemap::RangeSet;
 
@@ -2084,7 +2084,7 @@ impl RoomScreen {
                         // If true, set last_event_id to last_display_event
                         // If true, start the 5 seconds timer
                         let Some((_fully_read_event, fully_read_timestamp)) =
-                            take_fully_read_event(&room_id)
+                            get_fully_read_event(&room_id)
                         else {
                             *index = first_index;
                             return;

From ced53e54be0eefaf9421f9bbe770b31f8bbab326 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Thu, 28 Nov 2024 16:49:50 +0800
Subject: [PATCH 32/40] Move client num_of_unread to async

---
 src/home/room_screen.rs             | 27 ++++++-------------
 src/shared/jump_to_bottom_button.rs |  4 +--
 src/sliding_sync.rs                 | 40 ++++++++++++++++++++++++++---
 3 files changed, 46 insertions(+), 25 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 9a248a4b..2d11cc24 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -1519,7 +1519,7 @@ impl RoomScreen {
                     tl.items = initial_items;
                     done_loading = true;
                 }
-                TimelineUpdate::NewItems { new_items, changed_indices, is_append, clear_cache } => {
+                TimelineUpdate::NewItems { new_items, changed_indices, is_append, clear_cache, unread_messages_count } => {
                     if new_items.is_empty() {
                         if !tl.items.is_empty() {
                             log!("Timeline::handle_event(): timeline (had {} items) was cleared for room {}", tl.items.len(), tl.room_id);
@@ -1581,28 +1581,15 @@ impl RoomScreen {
 
                     // If new items were appended to the end of the timeline, show an unread messages badge on the jump to bottom button.
                     if is_append && !portal_list.is_at_end() {
-                        // Set the number of unread messages to unread_notification_badge
                         if let Some(room_id) = &self.room_id {
-                            if let Some(num_unread) = get_client()
-                                .and_then(|c| c.get_room(room_id))
-                                .map(|room| room.num_unread_messages())
-                            {
-                                jump_to_bottom.show_unread_message_badge(num_unread as usize);
-                            }
+                            // Set the number of unread messages to unread_notification_badge by async request to avoid locking in the Main UI thread
+                            submit_async_request(MatrixRequest::GetNumOfUnReadMessages{ room_id: room_id.clone() });
                         }
                     }
-                    // When new messages are added to the end of the timeline, 
-                    // we want to send the read receipt when the user sees them.
-                    if is_append && portal_list.is_at_end() {
-                        let last_displayed_event = new_items.last().and_then(|f| f.as_event()).and_then(|f| f.event_id());
-                        if let (Some(event_id), Some(room_id)) = (last_displayed_event, &self.room_id) {
-                            submit_async_request(MatrixRequest::ReadReceipt {
-                                room_id: room_id.clone(),
-                                event_id: event_id.to_owned(),
-                            });
-                        }
+                    if let Some(unread_messages_count) = unread_messages_count {
+                        jump_to_bottom.show_unread_message_badge(unread_messages_count);
+                        continue;
                     }
-
                     if clear_cache {
                         tl.content_drawn_since_last_update.clear();
                         tl.profile_drawn_since_last_update.clear();
@@ -2177,6 +2164,8 @@ pub enum TimelineUpdate {
         /// Whether to clear the entire cache of drawn items in the timeline.
         /// This supercedes `index_of_first_change` and is used when the entire timeline is being redrawn.
         clear_cache: bool,
+        /// The updated number of unread messages in the room.
+        unread_messages_count: Option<u64>
     },
     /// The target event ID was found at the given `index` in the timeline items vector.
     ///
diff --git a/src/shared/jump_to_bottom_button.rs b/src/shared/jump_to_bottom_button.rs
index 5f96f6a4..1cacea76 100644
--- a/src/shared/jump_to_bottom_button.rs
+++ b/src/shared/jump_to_bottom_button.rs
@@ -112,7 +112,7 @@ impl JumpToBottomButton {
     ///
     /// This does not automatically redraw any views.
     /// If unread_message_count is `0`, the unread message badge is hidden.
-    pub fn show_unread_message_badge(&mut self, unread_message_count: usize) {
+    pub fn show_unread_message_badge(&mut self, unread_message_count: u64) {
         if unread_message_count > 0 {
             self.visible = true;
             self.view(id!(unread_message_badge)).set_visible(true);
@@ -174,7 +174,7 @@ impl JumpToBottomButtonRef {
     }
 
     /// See [`JumpToBottomButton::show_unread_message_badge()`].
-    pub fn show_unread_message_badge(&self, unread_message_count: usize) {
+    pub fn show_unread_message_badge(&self, unread_message_count: u64) {
         if let Some(mut inner) = self.borrow_mut() {
             inner.show_unread_message_badge(unread_message_count);
         }
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index d77bac66..330cebab 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -280,7 +280,12 @@ pub enum MatrixRequest {
         /// * If `false` (recommended), details will be fetched from the server.
         local_only: bool,
     },
-    GetFullyReadEvent{
+    /// Request to fetch the fully read event in the given room's timeline.
+    GetFullyReadEvent {
+        room_id: OwnedRoomId,
+    },
+    /// Request to fetch the number of unread messages in the given room.
+    GetNumOfUnReadMessages {
         room_id: OwnedRoomId,
     },
     /// Request to ignore/block or unignore/unblock a user.
@@ -345,12 +350,12 @@ pub enum MatrixRequest {
         subscribe: bool,
     },
     /// Sends a read receipt for the given event in the given room.
-    ReadReceipt{
+    ReadReceipt {
         room_id: OwnedRoomId,
         event_id: OwnedEventId,
     },
     /// Sends a fully-read receipt for the given event in the given room.
-    FullyReadReceipt{
+    FullyReadReceipt {
         room_id: OwnedRoomId,
         event_id: OwnedEventId,
         timestamp: MilliSecondsSinceUnixEpoch
@@ -556,6 +561,7 @@ async fn async_worker(
                     }
                 });
             }
+            
             MatrixRequest::GetFullyReadEvent { room_id } => {
                 let Some(room) = CLIENT.get().and_then(|c| c.get_room(&room_id)) else {
                     error!("BUG: client/room not found for Get Fully Read Event {room_id}");
@@ -596,6 +602,31 @@ async fn async_worker(
                     }
                 });
             }
+            MatrixRequest::GetNumOfUnReadMessages { room_id } => {
+                let (_, sender) = {
+                    let mut all_room_info = ALL_ROOM_INFO.lock().unwrap();
+                    let Some(room_info) = all_room_info.get_mut(&room_id) else {
+                        log!("Skipping pagination request for not-yet-known room {room_id}");
+                        continue;
+                    };
+
+                    let timeline_ref = room_info.timeline.clone();
+                    let sender = room_info.timeline_update_sender.clone();
+                    (timeline_ref, sender)
+                };
+                let _fetch_task = Handle::current().spawn(async move {
+                    if let Some(unread_messages_count) = get_client()
+                        .and_then(|c| c.get_room(&room_id))
+                        .map(|room| Some(room.num_unread_messages()))
+                    {
+                        if let Err(e) = sender.send(TimelineUpdate::NewItems { new_items: Vec::new().into(), changed_indices: 0..1, is_append: false, clear_cache: false, unread_messages_count }) {
+                            log!("Failed to send timeline update: {e:?} for NumOfUnReadMessages request for room {room_id}");
+                        } else {
+                            SignalToUI::set_ui_signal();
+                        }
+                    }
+                });
+            }
             MatrixRequest::IgnoreUser { ignore, room_member, room_id } => {
                 let Some(client) = CLIENT.get() else { continue };
                 let _ignore_task = Handle::current().spawn(async move {
@@ -794,7 +825,7 @@ async fn async_worker(
                 });
             },
 
-            MatrixRequest::FullyReadReceipt { room_id, event_id, timestamp } => {
+            MatrixRequest::FullyReadReceipt { room_id, event_id, .. } => {
                 let timeline = {
                     let all_room_info = ALL_ROOM_INFO.lock().unwrap();
                     let Some(room_info) = all_room_info.get(&room_id) else {
@@ -1886,6 +1917,7 @@ async fn timeline_subscriber_handler(
                         changed_indices,
                         clear_cache,
                         is_append,
+                        unread_messages_count: None
                     }).expect("Error: timeline update sender couldn't send update with new items!");
 
                     // We must send this update *after* the actual NewItems update,

From 1caacc17dd302066b14d75c2e502748f7bc71552 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Thu, 28 Nov 2024 20:18:07 +0800
Subject: [PATCH 33/40] make oval for 99+

---
 src/home/room_screen.rs             |  2 +-
 src/shared/jump_to_bottom_button.rs | 48 +++++++++++++++++++++++------
 src/sliding_sync.rs                 |  4 +--
 3 files changed, 42 insertions(+), 12 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 2d11cc24..526a35e2 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -1587,7 +1587,7 @@ impl RoomScreen {
                         }
                     }
                     if let Some(unread_messages_count) = unread_messages_count {
-                        jump_to_bottom.show_unread_message_badge(unread_messages_count);
+                        jump_to_bottom.show_unread_message_badge(cx, unread_messages_count);
                         continue;
                     }
                     if clear_cache {
diff --git a/src/shared/jump_to_bottom_button.rs b/src/shared/jump_to_bottom_button.rs
index 1cacea76..6a24730a 100644
--- a/src/shared/jump_to_bottom_button.rs
+++ b/src/shared/jump_to_bottom_button.rs
@@ -40,8 +40,8 @@ live_design! {
 
         // A badge overlay on the jump to bottom button showing unread messages
         unread_message_badge = <View> {
-            width: 20, height: 20,
-            margin: {right: 28.0, bottom: 8.0},
+            width: 25, height: 20,
+            margin: {right: 22.0, bottom: 8.0},
             align: {
                 x: 0.5,
                 y: 0.5
@@ -51,11 +51,25 @@ live_design! {
             show_bg: true,
             draw_bg: {
                 color: (COLOR_UNREAD_MESSAGE_BADGE)
+                instance radius: 4.0
+                // Adjust this to width/height ratio will render a circle as the width becomes equal to height
+                // Adjust this to 1.0 will render a horizontal oval as it retains the original width which is longer than height
+                instance width_retention_ratio: 0.8
+                instance border_width: 0.0
+                instance border_color: #D0D5DD
                 fn pixel(self) -> vec4 {
-                    let sdf = Sdf2d::viewport(self.pos * self.rect_size);
-                    let c = self.rect_size * 0.5;
-                    sdf.circle(c.x, c.x, c.x);
-                    sdf.fill_keep(self.color);
+                    let sdf = Sdf2d::viewport(self.pos * self.rect_size)
+                    sdf.box(
+                        0.0,
+                        self.border_width,
+                        self.rect_size.x * self.width_retention_ratio - (self.border_width * 2.0),
+                        self.rect_size.y - (self.border_width * 2.0),
+                        max(1.0, self.radius)
+                    )
+                    sdf.fill_keep(self.color)
+                    if self.border_width > 0.0 {
+                        sdf.stroke(self.border_color, self.border_width)
+                    }
                     return sdf.result;
                 }
             }
@@ -64,7 +78,9 @@ live_design! {
             unread_messages_count = <Label> {
                 width: Fit,
                 height: Fit,
+                padding: { left: 0.0, right: 2.0 }
                 text: "",
+               
                 draw_text: {
                     color: #ffffff,
                     text_style: {font_size: 8.0},
@@ -112,7 +128,7 @@ impl JumpToBottomButton {
     ///
     /// This does not automatically redraw any views.
     /// If unread_message_count is `0`, the unread message badge is hidden.
-    pub fn show_unread_message_badge(&mut self, unread_message_count: u64) {
+    pub fn show_unread_message_badge(&mut self, cx: &mut Cx, unread_message_count: u64) {
         if unread_message_count > 0 {
             self.visible = true;
             self.view(id!(unread_message_badge)).set_visible(true);
@@ -121,6 +137,20 @@ impl JumpToBottomButton {
                 std::cmp::min(unread_message_count, 99),
                 if unread_message_count > 99 { "+" } else { "" }
             ));
+            if unread_message_count > 99 {
+                self.view(id!(unread_message_badge)).apply_over(cx, live!{
+                    draw_bg: {
+                        width_retention_ratio: 1.0
+                    }
+                });
+            } else {
+                self.view(id!(unread_message_badge)).apply_over(cx, live!{
+                    //margin: {right: 26.0},
+                    draw_bg: {
+                        width_retention_ratio: 0.8
+                    }
+                });
+            }
         } else {
             self.visible = false;
             self.view(id!(unread_message_badge)).set_visible(false);
@@ -174,9 +204,9 @@ impl JumpToBottomButtonRef {
     }
 
     /// See [`JumpToBottomButton::show_unread_message_badge()`].
-    pub fn show_unread_message_badge(&self, unread_message_count: u64) {
+    pub fn show_unread_message_badge(&self, cx: &mut Cx, unread_message_count: u64) {
         if let Some(mut inner) = self.borrow_mut() {
-            inner.show_unread_message_badge(unread_message_count);
+            inner.show_unread_message_badge(cx, unread_message_count);
         }
     }
 
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index 330cebab..97794698 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -6,8 +6,8 @@ use futures_util::{pin_mut, StreamExt};
 use imbl::Vector;
 use makepad_widgets::{error, log, warning, Cx, SignalToUI};
 use matrix_sdk::{
-    config::RequestConfig, deserialized_responses::TimelineEventKind, event_handler::EventHandlerDropGuard, media::MediaRequest, room::{Receipts, RoomMember}, ruma::{
-        api::{client::{receipt::create_receipt::v3::ReceiptType, session::get_login_types::v3::LoginType}}, events::{
+    config::RequestConfig, deserialized_responses::TimelineEventKind, event_handler::EventHandlerDropGuard, media::MediaRequest, room::RoomMember, ruma::{
+        api::client::{receipt::create_receipt::v3::ReceiptType, session::get_login_types::v3::LoginType}, events::{
             fully_read::FullyReadEventContent,
             receipt::ReceiptThread, room::{
                 message::{ForwardThread, RoomMessageEventContent}, MediaSource

From 35b8b02996ef5c65e078553a5bf5c9e6c969004c Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Thu, 28 Nov 2024 20:29:07 +0800
Subject: [PATCH 34/40] fix clippy warning

---
 src/home/room_screen.rs             | 2 +-
 src/shared/jump_to_bottom_button.rs | 2 +-
 src/sliding_sync.rs                 | 8 ++++----
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index be25eec4..780e7b55 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -2071,7 +2071,7 @@ impl RoomScreen {
                         // If true, set last_event_id to last_display_event
                         // If true, start the 5 seconds timer
                         let Some((_fully_read_event, fully_read_timestamp)) =
-                            get_fully_read_event(&room_id)
+                            get_fully_read_event(room_id)
                         else {
                             *index = first_index;
                             return;
diff --git a/src/shared/jump_to_bottom_button.rs b/src/shared/jump_to_bottom_button.rs
index 393f6da2..dbcf1675 100644
--- a/src/shared/jump_to_bottom_button.rs
+++ b/src/shared/jump_to_bottom_button.rs
@@ -155,7 +155,7 @@ impl JumpToBottomButton {
             self.visible = false;
             self.view(id!(unread_message_badge)).set_visible(false);
             self.label(id!(unread_messages_count))
-                .set_text(&format!("{}", ""));
+                .set_text("");
         }
     }
 
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index d4bd793c..ba698323 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -586,10 +586,10 @@ async fn async_worker(
                             let event = room.event(&event_id, None).await?;
                             match event.kind {
                                 TimelineEventKind::Decrypted(decrypted_room_event) => {
-                                    return decrypted_room_event.event.deserialize().map(|e| (event_id, e.origin_server_ts())).map_err(|e| e.into());
+                                    decrypted_room_event.event.deserialize().map(|e| (event_id, e.origin_server_ts())).map_err(|e| e.into())
                                 }
                                 TimelineEventKind::PlainText { event } => {
-                                    return event.deserialize().map(|e| (event_id, e.origin_server_ts())).map_err(|e| e.into());
+                                    event.deserialize().map(|e| (event_id, e.origin_server_ts())).map_err(|e| e.into())
                                 }
                                 _ => {
                                     bail!("Failed to fetch fully read event for room {room_id} because there is no TimelineEventKind::Decrypted");
@@ -1065,9 +1065,9 @@ fn set_fully_read_event(room_id: &OwnedRoomId, read_event: OwnedEventId, timesta
         if let Some(room_info) = guard
             .get_mut(room_id) {
                 room_info.fully_read_event = Some((read_event, timestamp));
-                return Ok(());
+                Ok(())
             } else {
-                return Err(anyhow::anyhow!("Cannot find room info for room {}", room_id));
+                Err(anyhow::anyhow!("Cannot find room info for room {}", room_id))
             }
     }).map_err(|e|{
         error!("Error updating fully read event: {e:?}");

From 906e53efe0d8d4f4561d0affce6a5889d692b5c1 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Thu, 28 Nov 2024 21:06:28 +0800
Subject: [PATCH 35/40] fix error handling for set_fully_read_event

---
 src/home/room_screen.rs |  2 +-
 src/sliding_sync.rs     | 28 +++++++++++++---------------
 2 files changed, 14 insertions(+), 16 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 780e7b55..9b60bb30 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -2297,7 +2297,7 @@ struct TimelineUiState {
     /// 
     /// Used to send fully read receipt after user scrolled pass the read marker
     /// Read marker is referred to Red marker in the UI or also known as latest fully read receipt 
-    /// Value is determined by comparing the fully read event with the event id of read receipt being sent out
+    /// Value is determined by comparing the fully read event's timestamp with the first and last timestamp of displayed events in the timeline
     /// When scrolling down, if scrolled_past_read_marker is true, a 5 seconds timer is started.
     /// Once the countdown ends, the app will send out last visible event's fully read receipt which will be stored as RoomInfo's fully_read_event
     /// In between, any scrolling or new message coming in will reset the timer
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index ba698323..97e3b86f 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -602,7 +602,9 @@ async fn async_worker(
                     match fetch_fully_read_event(&room, &room_id).await {
                         Ok((event_id, timestamp)) => {
                             log!("Successfully fetched fully read event for room {room_id} at {timestamp:?} for {event_id}");
-                            set_fully_read_event(&room_id, event_id, timestamp);
+                            if let Err(e) = set_fully_read_event(&room_id, event_id, timestamp) {
+                                error!("Failed to set fully read event for room {room_id}: {e:?}");
+                            }
                         }
                         Err(e) => {
                             log!("Failed to fetch fully read event for room {room_id} {e:?}");
@@ -1058,20 +1060,16 @@ pub fn get_fully_read_event(room_id: &OwnedRoomId) -> Option<(OwnedEventId, Mill
     result
 }
 /// Update fully read event inside Room Info after sending out read_receipt
-fn set_fully_read_event(room_id: &OwnedRoomId, read_event: OwnedEventId, timestamp: MilliSecondsSinceUnixEpoch) {
-    let _ = ALL_ROOM_INFO
-    .lock()
-    .map(|mut guard| {
-        if let Some(room_info) = guard
-            .get_mut(room_id) {
-                room_info.fully_read_event = Some((read_event, timestamp));
-                Ok(())
-            } else {
-                Err(anyhow::anyhow!("Cannot find room info for room {}", room_id))
-            }
-    }).map_err(|e|{
-        error!("Error updating fully read event: {e:?}");
-    });
+fn set_fully_read_event(room_id: &OwnedRoomId, read_event: OwnedEventId, timestamp: MilliSecondsSinceUnixEpoch) -> Result<(), anyhow::Error> {
+    ALL_ROOM_INFO
+        .lock()
+        .map_err(|e| anyhow::anyhow!("Failed to lock ALL_ROOM_INFO: {}", e))?
+        .get_mut(room_id)
+        .map(|room_info| {
+            room_info.fully_read_event = Some((read_event, timestamp));
+            Ok(())
+        })
+        .unwrap_or(Err(anyhow::anyhow!("Cannot find room info for room {}", room_id)))
 }
 const DEFAULT_HOMESERVER: &str = "matrix.org";
 

From fe9973b47e75e56a1714c5e13fea8ccb5ff4a5e2 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Mon, 2 Dec 2024 23:07:12 +0800
Subject: [PATCH 36/40] added subscribe to update read_receipt

---
 src/home/room_screen.rs |   2 +-
 src/sliding_sync.rs     | 125 ++++++++++++++++++++++++++++++++++------
 2 files changed, 109 insertions(+), 18 deletions(-)

diff --git a/src/home/room_screen.rs b/src/home/room_screen.rs
index 9b60bb30..8c9444cf 100644
--- a/src/home/room_screen.rs
+++ b/src/home/room_screen.rs
@@ -1894,7 +1894,7 @@ impl RoomScreen {
 
         // Query for User's fully read event
         submit_async_request(MatrixRequest::GetFullyReadEvent { room_id: room_id.clone() });
-
+        submit_async_request(MatrixRequest::SubscribeToUpdates { room_id: room_id.clone(), subscribe: true });
         // Kick off a back pagination request for this room. This is "urgent",
         // because we want to show the user some messages as soon as possible
         // when they first open the room, and there might not be any messages yet.
diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index 97e3b86f..30ee28bd 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -12,8 +12,8 @@ use matrix_sdk::{
             receipt::ReceiptThread, room::{
                 message::{ForwardThread, RoomMessageEventContent}, MediaSource
             }, FullStateEventContent
-        }, MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedMxcUri, OwnedRoomAliasId, OwnedRoomId, OwnedUserId, UserId
-    }, sliding_sync::VersionBuilder, Client, Error, Room
+        }, EventId, MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedMxcUri, OwnedRoomAliasId, OwnedRoomId, OwnedUserId, UserId
+    }, sliding_sync::VersionBuilder, sync::RoomUpdate, Client, Error, Room
 };
 use matrix_sdk_ui::{
     room_list_service::{self, RoomListLoadingState},
@@ -357,6 +357,14 @@ pub enum MatrixRequest {
         /// Whether to subscribe or unsubscribe from typing notices for this room.
         subscribe: bool,
     },
+    /// Subscribe to Updates for the given room.
+    ///
+    /// This request does not return a response or notify the UI thread.
+    SubscribeToUpdates {
+        room_id: OwnedRoomId,
+        /// Whether to subscribe or unsubscribe to Updates for this room.
+        subscribe: bool,
+    },
     /// Sends a read receipt for the given event in the given room.
     ReadReceipt {
         room_id: OwnedRoomId,
@@ -583,20 +591,9 @@ async fn async_worker(
                             .and_then(|f| f.deserialize().ok())
                             .map(|f| f.content.event_id);
                         if let Some(event_id) = fully_read_event {
-                            let event = room.event(&event_id, None).await?;
-                            match event.kind {
-                                TimelineEventKind::Decrypted(decrypted_room_event) => {
-                                    decrypted_room_event.event.deserialize().map(|e| (event_id, e.origin_server_ts())).map_err(|e| e.into())
-                                }
-                                TimelineEventKind::PlainText { event } => {
-                                    event.deserialize().map(|e| (event_id, e.origin_server_ts())).map_err(|e| e.into())
-                                }
-                                _ => {
-                                    bail!("Failed to fetch fully read event for room {room_id} because there is no TimelineEventKind::Decrypted");
-                                }
-                            }
+                            get_event_timestamp(room, room_id, event_id).await
                         } else {
-                            bail!("Failed to fetch fully read event for room {room_id} because there is no fully read event");
+                            bail!("There is no fully read event");
                         }
                     }
                     match fetch_fully_read_event(&room, &room_id).await {
@@ -752,6 +749,64 @@ async fn async_worker(
                     // log!("Note: typing notifications recv loop has ended for room {}", room_id);
                 });
             }
+            MatrixRequest::SubscribeToUpdates { room_id, subscribe } => {
+                let (_room, _timeline_update_sender, mut update_receiver) = {
+                    let mut all_room_info = ALL_ROOM_INFO.lock().unwrap();
+                    let Some(room_info) = all_room_info.get_mut(&room_id) else {
+                        log!("BUG: room info not found for subscribe to typing notices request, room {room_id}");
+                        continue;
+                    };
+                    let (room, recv) = if subscribe {
+                        if room_info.update_subscriber.is_some() {
+                            warning!("Note: room {room_id} is already subscribed to updates.");
+                            continue;
+                        } else {
+                            let Some(room) = CLIENT.get().and_then(|c| c.get_room(&room_id)) else {
+                                error!("BUG: client/room not found when subscribing to typing notices request, room: {room_id}");
+                                continue;
+                            };
+                            let recv = room.subscribe_to_updates();
+                            //room_info.update_subscriber = Some(recv);
+                            (room, recv)
+                        }
+                    } else {
+                        room_info.typing_notice_subscriber.take();
+                        continue;
+                    };
+                    // Here: we don't have an existing subscriber running, so we fall through and start one.
+                    (room, room_info.timeline_update_sender.clone(), recv)
+                };
+                
+                let _to_trump_task = Handle::current().spawn(async move {
+                    while let Ok(room_update) = update_receiver.recv().await {
+                        match room_update {
+                            RoomUpdate::Joined { room, .. } => {
+                                if let Some(latest_active) = serde_json::to_value(&room.read_receipts())
+                                    .unwrap_or_default()
+                                    .get("latest_active")
+                                    .unwrap_or(&serde_json::Value::Null)
+                                    .get("event_id") {
+                                    let updated_event_id = latest_active.to_string().replace("\"", "");
+                                    let fully_read_event = get_fully_read_event(&room.room_id().to_owned());
+                                    if let Some((event_id, _)) = fully_read_event {
+                                        let Ok(updated_event_id) = EventId::parse(updated_event_id.clone()).map_err(|e|{
+                                            error!("Error: couldn't parse event id {updated_event_id}: {e:?}");
+                                        }) else { continue };
+                                        if event_id != updated_event_id {
+                                            if let Err(e) = get_event_timestamp(&room, &room_id, event_id).await.map(|(read_event, timestamp)| {
+                                                set_fully_read_event(&room_id, read_event, timestamp)
+                                            }) {
+                                                error!("Error: couldn't set fully read event for room {room_id}: {e:?}");
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            _ => {}
+                        }
+                    }
+                });
+            }
             MatrixRequest::SpawnSSOServer { brand, homeserver_url, identity_provider_id} => {
                 spawn_sso_server(brand, homeserver_url, identity_provider_id, login_sender.clone()).await;
             }
@@ -961,6 +1016,8 @@ struct RoomInfo {
     timeline_subscriber_handler_task: JoinHandle<()>,
     /// A drop guard for the event handler that represents a subscription to typing notices for this room.
     typing_notice_subscriber: Option<EventHandlerDropGuard>,
+    /// A drop guard for the event handler that represents a subscription to typing notices for this room.
+    update_subscriber: Option<tokio::sync::broadcast::Receiver<RoomUpdate>>,
     /// The ID of the old tombstoned room that this room has replaced, if any.
     replaces_tombstoned_room: Option<OwnedRoomId>,
     /// Event_id and timestamp for read marker
@@ -1066,7 +1123,8 @@ fn set_fully_read_event(room_id: &OwnedRoomId, read_event: OwnedEventId, timesta
         .map_err(|e| anyhow::anyhow!("Failed to lock ALL_ROOM_INFO: {}", e))?
         .get_mut(room_id)
         .map(|room_info| {
-            room_info.fully_read_event = Some((read_event, timestamp));
+            room_info.fully_read_event = Some((read_event.clone(), timestamp));
+            log!("Set fully read event for room {:?} read_event {:?}", room_id, read_event);
             Ok(())
         })
         .unwrap_or(Err(anyhow::anyhow!("Cannot find room info for room {}", room_id)))
@@ -1404,7 +1462,39 @@ async fn update_room(
     }
 }
 
-
+/// Asynchronously retrieves the timestamp of a given event in a room.
+///
+/// This function fetches the specified event from the provided room and extracts
+/// its origin server timestamp. It handles both decrypted and plain text timeline
+/// event kinds. In the case of an unsupported event kind, or if the event cannot
+/// be fetched or deserialized, an error is returned.
+///
+/// # Arguments
+///
+/// * `room` - The room from which to retrieve the event.
+/// * `room_id` - The ID of the room.
+/// * `event_id` - The ID of the event whose timestamp is to be retrieved.
+///
+/// # Returns
+///
+/// * `Ok((OwnedEventId, MilliSecondsSinceUnixEpoch))` - A tuple containing the
+///   event ID and its origin server timestamp if successful.
+/// * `Err(anyhow::Error)` - An error if the event cannot be fetched or is of
+///   an unsupported timeline event kind.
+async fn get_event_timestamp(room: &Room, room_id: &OwnedRoomId, event_id: OwnedEventId) -> Result<(OwnedEventId, MilliSecondsSinceUnixEpoch),  anyhow::Error> {
+    let event = room.event(&event_id, None).await?;
+    match event.kind {
+        TimelineEventKind::Decrypted(decrypted_room_event) => {
+            decrypted_room_event.event.deserialize().map(|e| (event_id, e.origin_server_ts())).map_err(|e| e.into())
+        }
+        TimelineEventKind::PlainText { event } => {
+            event.deserialize().map(|e| (event_id, e.origin_server_ts())).map_err(|e| e.into())
+        }
+        _ => {
+           bail!("Failed to fetch fully read event for room {room_id} because there is no TimelineEventKind::Decrypted")
+        }
+    }
+}
 /// Invoked when the room list service has received an update to remove an existing room.
 fn remove_room(room: &room_list_service::Room) {
     ALL_ROOM_INFO.lock().unwrap().remove(room.room_id());
@@ -1504,6 +1594,7 @@ async fn add_new_room(room: &room_list_service::Room) -> Result<()> {
             timeline_update_sender,
             timeline_subscriber_handler_task,
             typing_notice_subscriber: None,
+            update_subscriber: None,
             replaces_tombstoned_room: tombstoned_room_replaced_by_this_room,
             fully_read_event: None
         },

From 3d090fb518528902b6eb3866f2d329bb3e16fd7a Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Mon, 2 Dec 2024 23:25:22 +0800
Subject: [PATCH 37/40] Added comments for subscribe to Updates

---
 src/sliding_sync.rs | 37 ++++++++++++++-----------------------
 1 file changed, 14 insertions(+), 23 deletions(-)

diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index 30ee28bd..f65a9f59 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -750,42 +750,36 @@ async fn async_worker(
                 });
             }
             MatrixRequest::SubscribeToUpdates { room_id, subscribe } => {
-                let (_room, _timeline_update_sender, mut update_receiver) = {
+                let mut update_receiver = {
                     let mut all_room_info = ALL_ROOM_INFO.lock().unwrap();
-                    let Some(room_info) = all_room_info.get_mut(&room_id) else {
-                        log!("BUG: room info not found for subscribe to typing notices request, room {room_id}");
+                    let Some(_room_info) = all_room_info.get_mut(&room_id) else {
+                        log!("BUG: room info not found for subscribe to updates, room {room_id}");
                         continue;
                     };
-                    let (room, recv) = if subscribe {
-                        if room_info.update_subscriber.is_some() {
-                            warning!("Note: room {room_id} is already subscribed to updates.");
+                    let recv = if subscribe {
+                        let Some(room) = CLIENT.get().and_then(|c| c.get_room(&room_id)) else {
+                            error!("BUG: client/room not found when subscribing to updates, room: {room_id}");
                             continue;
-                        } else {
-                            let Some(room) = CLIENT.get().and_then(|c| c.get_room(&room_id)) else {
-                                error!("BUG: client/room not found when subscribing to typing notices request, room: {room_id}");
-                                continue;
-                            };
-                            let recv = room.subscribe_to_updates();
-                            //room_info.update_subscriber = Some(recv);
-                            (room, recv)
-                        }
+                        };
+                        room.subscribe_to_updates()
                     } else {
-                        room_info.typing_notice_subscriber.take();
                         continue;
                     };
-                    // Here: we don't have an existing subscriber running, so we fall through and start one.
-                    (room, room_info.timeline_update_sender.clone(), recv)
+                    recv
                 };
-                
-                let _to_trump_task = Handle::current().spawn(async move {
+
+                let _to_updates_task = Handle::current().spawn(async move {
                     while let Ok(room_update) = update_receiver.recv().await {
                         match room_update {
                             RoomUpdate::Joined { room, .. } => {
+                                // Using Serde_json to obtain the latest_active event_id  
+                                // Room's read receipt's latest_active event is not public, but the ReadReceipts struct is serializable 
                                 if let Some(latest_active) = serde_json::to_value(&room.read_receipts())
                                     .unwrap_or_default()
                                     .get("latest_active")
                                     .unwrap_or(&serde_json::Value::Null)
                                     .get("event_id") {
+                                    // The event_id contains double quotes, hence there is a string replacement code to remove them 
                                     let updated_event_id = latest_active.to_string().replace("\"", "");
                                     let fully_read_event = get_fully_read_event(&room.room_id().to_owned());
                                     if let Some((event_id, _)) = fully_read_event {
@@ -1016,8 +1010,6 @@ struct RoomInfo {
     timeline_subscriber_handler_task: JoinHandle<()>,
     /// A drop guard for the event handler that represents a subscription to typing notices for this room.
     typing_notice_subscriber: Option<EventHandlerDropGuard>,
-    /// A drop guard for the event handler that represents a subscription to typing notices for this room.
-    update_subscriber: Option<tokio::sync::broadcast::Receiver<RoomUpdate>>,
     /// The ID of the old tombstoned room that this room has replaced, if any.
     replaces_tombstoned_room: Option<OwnedRoomId>,
     /// Event_id and timestamp for read marker
@@ -1594,7 +1586,6 @@ async fn add_new_room(room: &room_list_service::Room) -> Result<()> {
             timeline_update_sender,
             timeline_subscriber_handler_task,
             typing_notice_subscriber: None,
-            update_subscriber: None,
             replaces_tombstoned_room: tombstoned_room_replaced_by_this_room,
             fully_read_event: None
         },

From b12592ae98100184206b90c58b5af5725aa76342 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Tue, 3 Dec 2024 10:51:16 +0800
Subject: [PATCH 38/40] added new lines and fix clippy

---
 src/sliding_sync.rs | 60 +++++++++++++++++++++++----------------------
 1 file changed, 31 insertions(+), 29 deletions(-)

diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index f65a9f59..1686d220 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -585,7 +585,8 @@ async fn async_worker(
                 };
                 
                 let _get_fully_read_event_task = Handle::current().spawn(async move {
-                    async fn fetch_fully_read_event(room: &Room, room_id: &OwnedRoomId) -> Result<(OwnedEventId, MilliSecondsSinceUnixEpoch),  anyhow::Error> {
+                    async fn fetch_fully_read_event(room: &Room, room_id: &OwnedRoomId) -> 
+                        Result<(OwnedEventId, MilliSecondsSinceUnixEpoch),  anyhow::Error> {
                         let fully_read_event =  room
                             .account_data_static::<FullyReadEventContent>().await?
                             .and_then(|f| f.deserialize().ok())
@@ -626,7 +627,8 @@ async fn async_worker(
                         .and_then(|c| c.get_room(&room_id))
                         .map(|room| Some(room.num_unread_messages()))
                     {
-                        if let Err(e) = sender.send(TimelineUpdate::NewItems { new_items: Vec::new().into(), changed_indices: 0..1, is_append: false, clear_cache: false, unread_messages_count }) {
+                        if let Err(e) = sender.send(TimelineUpdate::NewItems { new_items: Vec::new().into(), changed_indices: 0..1, 
+                            is_append: false, clear_cache: false, unread_messages_count }) {
                             log!("Failed to send timeline update: {e:?} for NumOfUnReadMessages request for room {room_id}");
                         } else {
                             SignalToUI::set_ui_signal();
@@ -770,33 +772,32 @@ async fn async_worker(
 
                 let _to_updates_task = Handle::current().spawn(async move {
                     while let Ok(room_update) = update_receiver.recv().await {
-                        match room_update {
-                            RoomUpdate::Joined { room, .. } => {
-                                // Using Serde_json to obtain the latest_active event_id  
-                                // Room's read receipt's latest_active event is not public, but the ReadReceipts struct is serializable 
-                                if let Some(latest_active) = serde_json::to_value(&room.read_receipts())
-                                    .unwrap_or_default()
-                                    .get("latest_active")
-                                    .unwrap_or(&serde_json::Value::Null)
-                                    .get("event_id") {
-                                    // The event_id contains double quotes, hence there is a string replacement code to remove them 
-                                    let updated_event_id = latest_active.to_string().replace("\"", "");
-                                    let fully_read_event = get_fully_read_event(&room.room_id().to_owned());
-                                    if let Some((event_id, _)) = fully_read_event {
-                                        let Ok(updated_event_id) = EventId::parse(updated_event_id.clone()).map_err(|e|{
-                                            error!("Error: couldn't parse event id {updated_event_id}: {e:?}");
-                                        }) else { continue };
-                                        if event_id != updated_event_id {
-                                            if let Err(e) = get_event_timestamp(&room, &room_id, event_id).await.map(|(read_event, timestamp)| {
-                                                set_fully_read_event(&room_id, read_event, timestamp)
-                                            }) {
-                                                error!("Error: couldn't set fully read event for room {room_id}: {e:?}");
-                                            }
+                        if let RoomUpdate::Joined { room, updates: _ } = room_update {
+                            // Using Serde_json to obtain the latest_active event_id  
+                            // Room's read receipt's latest_active event is not public, but the ReadReceipt struct 
+                            // is serializable 
+                            if let Some(latest_active) = serde_json::to_value(room.read_receipts())
+                                .unwrap_or_default()
+                                .get("latest_active")
+                                .unwrap_or(&serde_json::Value::Null)
+                                .get("event_id") {
+                                // The event_id contains double quotes, hence there is a string replacement code to remove them 
+                                let updated_event_id = latest_active.to_string().replace("\"", "");
+                                let fully_read_event = get_fully_read_event(&room.room_id().to_owned());
+                                if let Some((event_id, _)) = fully_read_event {
+                                    let Ok(updated_event_id) = EventId::parse(updated_event_id.clone()).map_err(|e|{
+                                        error!("Error: couldn't parse event id {updated_event_id}: {e:?}");
+                                    }) else { continue };
+                                    if event_id != updated_event_id {
+                                        if let Err(e) = get_event_timestamp(&room, &room_id, event_id).await
+                                            .map(|(read_event, timestamp)| {
+                                            set_fully_read_event(&room_id, read_event, timestamp)
+                                        }) {
+                                            error!("Error: couldn't set fully read event for room {room_id}: {e:?}");
                                         }
                                     }
                                 }
                             }
-                            _ => {}
                         }
                     }
                 });
@@ -894,13 +895,14 @@ async fn async_worker(
                     room_info.timeline.clone()
                 };
                 let _send_frr_task = Handle::current().spawn(async move {
-                    let receipt_type = ReceiptType::FullyRead;
-                    match timeline.send_single_receipt(receipt_type, ReceiptThread::Unthreaded, event_id.clone()).await {
-                        Ok(sent) => log!("{} send fully read receipt to room {room_id} for event {event_id}", if sent { "Sent" } else { "Already sent" }),
+                    match timeline.send_single_receipt(ReceiptType::FullyRead, ReceiptThread::Unthreaded, event_id.clone()).await {
+                        Ok(sent) => log!("{} send fully read receipt to room {room_id} for event {event_id}", 
+                            if sent { "Sent" } else { "Already sent" }
+                        ),
                         Err(_e) => error!("Failed to send fully read receipt to room {room_id} for event {event_id}; error: {_e:?}"),
                     }
                 });
-            }    
+            }
         }
     }
 

From eb857c6c9c846c98d5bde81fffe84789a407ffaf Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Tue, 3 Dec 2024 14:42:12 +0800
Subject: [PATCH 39/40] added update_subscriber_initialised check

---
 src/sliding_sync.rs | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index 1686d220..8fd9ecb2 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -611,16 +611,15 @@ async fn async_worker(
                 });
             }
             MatrixRequest::GetNumOfUnReadMessages { room_id } => {
-                let (_, sender) = {
+                let sender = {
                     let mut all_room_info = ALL_ROOM_INFO.lock().unwrap();
                     let Some(room_info) = all_room_info.get_mut(&room_id) else {
                         log!("Skipping pagination request for not-yet-known room {room_id}");
                         continue;
                     };
 
-                    let timeline_ref = room_info.timeline.clone();
                     let sender = room_info.timeline_update_sender.clone();
-                    (timeline_ref, sender)
+                    sender
                 };
                 let _fetch_task = Handle::current().spawn(async move {
                     if let Some(unread_messages_count) = get_client()
@@ -754,15 +753,20 @@ async fn async_worker(
             MatrixRequest::SubscribeToUpdates { room_id, subscribe } => {
                 let mut update_receiver = {
                     let mut all_room_info = ALL_ROOM_INFO.lock().unwrap();
-                    let Some(_room_info) = all_room_info.get_mut(&room_id) else {
+                    let Some(room_info) = all_room_info.get_mut(&room_id) else {
                         log!("BUG: room info not found for subscribe to updates, room {room_id}");
                         continue;
                     };
                     let recv = if subscribe {
+                        if room_info.update_subscriber_initialised {
+                            warning!("Note: room {room_id} is already subscribed to updates.");
+                            continue
+                        }
                         let Some(room) = CLIENT.get().and_then(|c| c.get_room(&room_id)) else {
                             error!("BUG: client/room not found when subscribing to updates, room: {room_id}");
                             continue;
                         };
+                        room_info.update_subscriber_initialised = true;
                         room.subscribe_to_updates()
                     } else {
                         continue;
@@ -1012,6 +1016,8 @@ struct RoomInfo {
     timeline_subscriber_handler_task: JoinHandle<()>,
     /// A drop guard for the event handler that represents a subscription to typing notices for this room.
     typing_notice_subscriber: Option<EventHandlerDropGuard>,
+    /// A broadcast receiver for room updates.
+    update_subscriber_initialised: bool,
     /// The ID of the old tombstoned room that this room has replaced, if any.
     replaces_tombstoned_room: Option<OwnedRoomId>,
     /// Event_id and timestamp for read marker
@@ -1588,6 +1594,7 @@ async fn add_new_room(room: &room_list_service::Room) -> Result<()> {
             timeline_update_sender,
             timeline_subscriber_handler_task,
             typing_notice_subscriber: None,
+            update_subscriber_initialised: false,
             replaces_tombstoned_room: tombstoned_room_replaced_by_this_room,
             fully_read_event: None
         },

From 794cd0aecd5a7a3c9e7d519b94d9bd1350d5ab39 Mon Sep 17 00:00:00 2001
From: alanpoon <brightshadowx@gmail.com>
Date: Tue, 3 Dec 2024 15:02:22 +0800
Subject: [PATCH 40/40] fix clippy

---
 src/sliding_sync.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/sliding_sync.rs b/src/sliding_sync.rs
index 8fd9ecb2..01023b67 100644
--- a/src/sliding_sync.rs
+++ b/src/sliding_sync.rs
@@ -618,8 +618,7 @@ async fn async_worker(
                         continue;
                     };
 
-                    let sender = room_info.timeline_update_sender.clone();
-                    sender
+                    room_info.timeline_update_sender.clone()
                 };
                 let _fetch_task = Handle::current().spawn(async move {
                     if let Some(unread_messages_count) = get_client()