Get back to Recovering syncing when we haven't sync for a while

Cargo.toml

@@ -43,6 +43,7 @@ growable-bloom-filter = "2.1.0"
 http = "1.1.0"
 imbl = "3.0.0"
 itertools = "0.12.0"
+mock_instant = "0.5.1"
 once_cell = "1.16.0"
 pin-project-lite = "0.2.9"
 rand = "0.8.5"

bindings/matrix-sdk-ffi/src/room_list.rs

@@ -356,7 +356,7 @@ impl From<matrix_sdk_ui::room_list_service::State> for RoomListServiceState {
             S::Init => Self::Initial,
             S::SettingUp => Self::SettingUp,
             S::Recovering => Self::Recovering,
-            S::Running => Self::Running,
+            S::Running { .. } => Self::Running,
             S::Error { .. } => Self::Error,
             S::Terminated { .. } => Self::Terminated,
         }

crates/matrix-sdk-ui/Cargo.toml

@@ -15,6 +15,8 @@ rustls-tls = ["matrix-sdk/rustls-tls"]
 
 uniffi = ["dep:uniffi", "matrix-sdk/uniffi", "matrix-sdk-base/uniffi"]
 
+testing = ["dep:mock_instant", "matrix-sdk/testing", "matrix-sdk-base/testing"]
+
 # Add support for encrypted extensible events.
 unstable-msc3956 = ["ruma/unstable-msc3956"]
 
@@ -38,6 +40,7 @@ itertools = { workspace = true }
 matrix-sdk = { workspace = true, features = ["experimental-sliding-sync", "e2e-encryption"] }
 matrix-sdk-base = { workspace = true }
 mime = "0.3.16"
+mock_instant = { workspace = true, optional = true }
 once_cell = { workspace = true }
 pin-project-lite = { workspace = true }
 ruma = { workspace = true, features = ["html", "unstable-msc3381"] }
@@ -57,9 +60,14 @@ assert_matches2 = { workspace = true }
 eyeball-im-util = { workspace = true }
 matrix-sdk = { workspace = true, features = ["testing"] }
 matrix-sdk-test = { workspace = true }
+mock_instant = { workspace = true }
 stream_assert = { workspace = true }
 tempfile = "3.3.0"
 wiremock = { workspace = true }
 
+[[test]]
+name = "integration"
+required-features = ["testing"]
+
 [lints]
 workspace = true

crates/matrix-sdk-ui/src/room_list_service/mod.rs

@@ -315,7 +315,7 @@ impl RoomListService {
                         (SyncIndicator::Show, delay_before_showing)
                     }
 
-                    State::SettingUp | State::Recovering | State::Running | State::Terminated { .. } => {
+                    State::SettingUp | State::Recovering | State::Running {..} | State::Terminated { .. } => {
                         (SyncIndicator::Hide, delay_before_hiding)
                     }
                 };
@@ -610,13 +610,17 @@ mod tests {
         let _ = sync.next().await;
 
         // State is `Terminated`, as expected!
-        assert_eq!(room_list.state.get(), State::Terminated { from: Box::new(State::Running) });
+        assert_matches!(room_list.state.get(), State::Terminated { from } => {
+            assert_matches!(from.as_ref(), State::Running { .. });
+        });
 
         // Now, let's make the sliding sync session to expire.
         room_list.expire_sync_session().await;
 
         // State is `Error`, as a regular session expiration would generate!
-        assert_eq!(room_list.state.get(), State::Error { from: Box::new(State::Running) });
+        assert_matches!(room_list.state.get(), State::Error { from } => {
+            assert_matches!(from.as_ref(), State::Running { .. });
+        });
 
         Ok(())
     }

crates/matrix-sdk-ui/src/room_list_service/room_list.rs

@@ -88,7 +88,7 @@ impl RoomList {
 
                     match state {
                         Terminated { .. } | Error { .. } | Init => (),
-                        SettingUp | Recovering | Running => break,
+                        SettingUp | Recovering | Running { .. } => break,
                     }
                 }
 

crates/matrix-sdk-ui/src/room_list_service/state.rs

@@ -15,8 +15,12 @@
 //! States and actions for the `RoomList` state machine.
 
 use std::future::ready;
+#[cfg(not(any(test, feature = "testing")))]
+use std::time::Instant;
 
 use matrix_sdk::{sliding_sync::Range, SlidingSync, SlidingSyncMode};
+#[cfg(any(test, feature = "testing"))]
+use mock_instant::global::Instant;
 
 use super::Error;
 
@@ -37,7 +41,7 @@ pub enum State {
     Recovering,
 
     /// At this state, all rooms are syncing.
-    Running,
+    Running { last_time: Instant },
 
     /// At this state, the sync has been stopped because an error happened.
     Error { from: Box<State> },
@@ -57,10 +61,18 @@ impl State {
 
             SettingUp | Recovering => {
                 set_all_rooms_to_growing_sync_mode(sliding_sync).await?;
-                Running
+                Running { last_time: Instant::now() }
             }
 
-            Running => Running,
+            Running { last_time } => {
+                // We haven't sync for a while so we should go back to recovering
+                if last_time.elapsed().as_secs() > 1800 {
+                    set_all_rooms_to_selective_sync_mode(sliding_sync).await?;
+                    Recovering
+                } else {
+                    Running { last_time: Instant::now() }
+                }
+            }
 
             Error { from: previous_state } | Terminated { from: previous_state } => {
                 match previous_state.as_ref() {
@@ -72,7 +84,7 @@ impl State {
                     }
 
                     // If the previous state was `Running`, we enter the `Recovering` state.
-                    Running => {
+                    Running { .. } => {
                         set_all_rooms_to_selective_sync_mode(sliding_sync).await?;
                         Recovering
                     }
@@ -121,6 +133,7 @@ pub const ALL_ROOMS_DEFAULT_GROWING_BATCH_SIZE: u32 = 100;
 
 #[cfg(test)]
 mod tests {
+    use assert_matches::assert_matches;
     use matrix_sdk_test::async_test;
 
     use super::{super::tests::new_room_list, *};
@@ -173,7 +186,7 @@ mod tests {
 
         // Next state.
         let state = state.next(sliding_sync).await?;
-        assert_eq!(state, State::Running);
+        assert_matches!(state, State::Running { .. });
 
         // Hypothetical error.
         {
@@ -185,7 +198,7 @@ mod tests {
             let state = state.next(sliding_sync).await?;
 
             // Now, back to the previous state.
-            assert_eq!(state, State::Running);
+            assert_matches!(state, State::Running { .. });
         }
 
         // Hypothetical termination.
@@ -199,7 +212,7 @@ mod tests {
             let state = state.next(sliding_sync).await?;
 
             // Now, back to the previous state.
-            assert_eq!(state, State::Running);
+            assert_matches!(state, State::Running { .. });
         }
 
         // Hypothetical error when recovering.