feat: Use sliding_sync::Version everywhere.

This patch replaces all the API using simplified sliding sync, or
sliding sync proxy, by a unified `sliding_sync::Version` type!

This patch disables auto-discovery for the moment. It will be re-enable
with the next patches.

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

@@ -19,12 +19,12 @@ use matrix_sdk::{
 };
 use url::Url;
 
-use crate::client::Client;
+use crate::client::{Client, SlidingSyncVersion};
 
 #[derive(uniffi::Object)]
 pub struct HomeserverLoginDetails {
     pub(crate) url: String,
-    pub(crate) sliding_sync_proxy: Option<String>,
+    pub(crate) sliding_sync_version: SlidingSyncVersion,
     pub(crate) supports_oidc_login: bool,
     pub(crate) supports_password_login: bool,
 }
@@ -36,10 +36,9 @@ impl HomeserverLoginDetails {
         self.url.clone()
     }
 
-    /// The URL of the discovered or manually set sliding sync proxy,
-    /// if any.
-    pub fn sliding_sync_proxy(&self) -> Option<String> {
-        self.sliding_sync_proxy.clone()
+    /// The sliding sync version.
+    pub fn sliding_sync_version(&self) -> SlidingSyncVersion {
+        self.sliding_sync_version.clone()
     }
 
     /// Whether the current homeserver supports login using OIDC.

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

@@ -39,6 +39,7 @@ use matrix_sdk::{
         serde::Raw,
         EventEncryptionAlgorithm, RoomId, TransactionId, UInt, UserId,
     },
+    sliding_sync::Version as SdkSlidingSyncVersion,
     AuthApi, AuthSession, Client as MatrixClient, SessionChange, SessionTokens,
 };
 use matrix_sdk_ui::notification_client::{
@@ -261,11 +262,11 @@ impl Client {
     pub async fn homeserver_login_details(&self) -> Arc<HomeserverLoginDetails> {
         let supports_oidc_login = self.inner.oidc().fetch_authentication_issuer().await.is_ok();
         let supports_password_login = self.supports_password_login().await.ok().unwrap_or(false);
-        let sliding_sync_proxy = self.sliding_sync_proxy().map(|proxy_url| proxy_url.to_string());
+        let sliding_sync_version = self.sliding_sync_version();
 
         Arc::new(HomeserverLoginDetails {
             url: self.homeserver(),
-            sliding_sync_proxy,
+            sliding_sync_version,
             supports_oidc_login,
             supports_password_login,
         })
@@ -383,19 +384,11 @@ impl Client {
 
     /// Restores the client from a `Session`.
     pub async fn restore_session(&self, session: Session) -> Result<(), ClientError> {
-        let sliding_sync_proxy = session.sliding_sync_proxy.clone();
+        let sliding_sync_version = session.sliding_sync_version.clone();
         let auth_session: AuthSession = session.try_into()?;
 
         self.restore_session_inner(auth_session).await?;
-
-        if !self.inner.is_simplified_sliding_sync_enabled() {
-            if let Some(sliding_sync_proxy) = sliding_sync_proxy {
-                let sliding_sync_proxy = Url::parse(&sliding_sync_proxy)
-                    .map_err(|error| ClientError::Generic { msg: error.to_string() })?;
-
-                self.inner.set_sliding_sync_proxy(Some(sliding_sync_proxy));
-            }
-        }
+        self.inner.set_sliding_sync_version(sliding_sync_version.try_into()?);
 
         Ok(())
     }
@@ -467,11 +460,9 @@ impl Client {
         Ok(())
     }
 
-    /// The sliding sync proxy of the homeserver. It is either set automatically
-    /// during discovery or manually via `set_sliding_sync_proxy` or `None`
-    /// when not configured.
-    pub fn sliding_sync_proxy(&self) -> Option<Url> {
-        self.inner.sliding_sync_proxy()
+    /// The sliding sync version.
+    pub fn sliding_sync_version(&self) -> SlidingSyncVersion {
+        self.inner.sliding_sync_version().into()
     }
 
     /// Whether or not the client's homeserver supports the password login flow.
@@ -1083,9 +1074,9 @@ impl Client {
         let auth_api = client.auth_api().context("Missing authentication API")?;
 
         let homeserver_url = client.homeserver().into();
-        let sliding_sync_proxy = client.sliding_sync_proxy().map(|url| url.to_string());
+        let sliding_sync_version = client.sliding_sync_version();
 
-        Session::new(auth_api, homeserver_url, sliding_sync_proxy)
+        Session::new(auth_api, homeserver_url, sliding_sync_version.into())
     }
 
     fn save_session(
@@ -1312,15 +1303,15 @@ pub struct Session {
     /// Additional data for this session if OpenID Connect was used for
     /// authentication.
     pub oidc_data: Option<String>,
-    /// The URL for the sliding sync proxy used for this session.
-    pub sliding_sync_proxy: Option<String>,
+    /// The sliding sync version used for this session.
+    pub sliding_sync_version: SlidingSyncVersion,
 }
 
 impl Session {
     fn new(
         auth_api: AuthApi,
         homeserver_url: String,
-        sliding_sync_proxy: Option<String>,
+        sliding_sync_version: SlidingSyncVersion,
     ) -> Result<Session, ClientError> {
         match auth_api {
             // Build the session from the regular Matrix Auth Session.
@@ -1338,7 +1329,7 @@ impl Session {
                     device_id: device_id.to_string(),
                     homeserver_url,
                     oidc_data: None,
-                    sliding_sync_proxy,
+                    sliding_sync_version,
                 })
             }
             // Build the session from the OIDC UserSession.
@@ -1375,7 +1366,7 @@ impl Session {
                     device_id: device_id.to_string(),
                     homeserver_url,
                     oidc_data,
-                    sliding_sync_proxy,
+                    sliding_sync_version,
                 })
             }
             _ => Err(anyhow!("Unknown authentication API").into()),
@@ -1393,7 +1384,7 @@ impl TryFrom<Session> for AuthSession {
             device_id,
             homeserver_url: _,
             oidc_data,
-            sliding_sync_proxy: _,
+            sliding_sync_version: _,
         } = value;
 
         if let Some(oidc_data) = oidc_data {
@@ -1581,3 +1572,34 @@ impl MediaFileHandle {
         )
     }
 }
+
+#[derive(Clone, uniffi::Enum)]
+pub enum SlidingSyncVersion {
+    None,
+    Proxy { url: String },
+    Native,
+}
+
+impl From<SdkSlidingSyncVersion> for SlidingSyncVersion {
+    fn from(value: SdkSlidingSyncVersion) -> Self {
+        match value {
+            SdkSlidingSyncVersion::None => Self::None,
+            SdkSlidingSyncVersion::Proxy { url } => Self::Proxy { url: url.to_string() },
+            SdkSlidingSyncVersion::Native => Self::Native,
+        }
+    }
+}
+
+impl TryFrom<SlidingSyncVersion> for SdkSlidingSyncVersion {
+    type Error = ClientError;
+
+    fn try_from(value: SlidingSyncVersion) -> Result<Self, Self::Error> {
+        Ok(match value {
+            SlidingSyncVersion::None => Self::None,
+            SlidingSyncVersion::Proxy { url } => Self::Proxy {
+                url: Url::parse(&url).map_err(|e| ClientError::Generic { msg: e.to_string() })?,
+            },
+            SlidingSyncVersion::Native => Self::Native,
+        })
+    }
+}

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

@@ -15,12 +15,16 @@ use matrix_sdk::{
 };
 use ruma::api::error::{DeserializationError, FromHttpResponseError};
 use tracing::{debug, error};
+use url::Url;
 use zeroize::Zeroizing;
 
 use super::{client::Client, RUNTIME};
 use crate::{
-    authentication::OidcConfiguration, client::ClientSessionDelegate, error::ClientError,
-    helpers::unwrap_or_clone_arc, task_handle::TaskHandle,
+    authentication::OidcConfiguration,
+    client::{ClientSessionDelegate, SlidingSyncVersion},
+    error::ClientError,
+    helpers::unwrap_or_clone_arc,
+    task_handle::TaskHandle,
 };
 
 /// A list of bytes containing a certificate in DER or PEM form.
@@ -251,9 +255,7 @@ pub struct ClientBuilder {
     homeserver_cfg: Option<HomeserverConfig>,
     passphrase: Zeroizing<Option<String>>,
     user_agent: Option<String>,
-    requires_sliding_sync: bool,
-    sliding_sync_proxy: Option<String>,
-    is_simplified_sliding_sync_enabled: bool,
+    sliding_sync_version: SlidingSyncVersion,
     proxy: Option<String>,
     disable_ssl_verification: bool,
     disable_automatic_token_refresh: bool,
@@ -276,10 +278,7 @@ impl ClientBuilder {
             homeserver_cfg: None,
             passphrase: Zeroizing::new(None),
             user_agent: None,
-            requires_sliding_sync: false,
-            sliding_sync_proxy: None,
-            // By default, Simplified MSC3575 is turned off.
-            is_simplified_sliding_sync_enabled: false,
+            sliding_sync_version: SlidingSyncVersion::None,
             proxy: None,
             disable_ssl_verification: false,
             disable_automatic_token_refresh: false,
@@ -365,21 +364,9 @@ impl ClientBuilder {
         Arc::new(builder)
     }
 
-    pub fn requires_sliding_sync(self: Arc<Self>) -> Arc<Self> {
+    pub fn sliding_sync_version(self: Arc<Self>, version: SlidingSyncVersion) -> Arc<Self> {
         let mut builder = unwrap_or_clone_arc(self);
-        builder.requires_sliding_sync = true;
-        Arc::new(builder)
-    }
-
-    pub fn sliding_sync_proxy(self: Arc<Self>, sliding_sync_proxy: Option<String>) -> Arc<Self> {
-        let mut builder = unwrap_or_clone_arc(self);
-        builder.sliding_sync_proxy = sliding_sync_proxy;
-        Arc::new(builder)
-    }
-
-    pub fn simplified_sliding_sync(self: Arc<Self>, enable: bool) -> Arc<Self> {
-        let mut builder = unwrap_or_clone_arc(self);
-        builder.is_simplified_sliding_sync_enabled = enable;
+        builder.sliding_sync_version = version;
         Arc::new(builder)
     }
 
@@ -550,15 +537,15 @@ impl ClientBuilder {
             .with_encryption_settings(builder.encryption_settings)
             .with_room_key_recipient_strategy(builder.room_key_recipient_strategy);
 
-        if let Some(sliding_sync_proxy) = builder.sliding_sync_proxy {
-            inner_builder = inner_builder.sliding_sync_proxy(sliding_sync_proxy);
-        }
-
-        inner_builder =
-            inner_builder.simplified_sliding_sync(builder.is_simplified_sliding_sync_enabled);
-
-        if builder.requires_sliding_sync {
-            inner_builder = inner_builder.requires_sliding_sync();
+        match builder.sliding_sync_version {
+            SlidingSyncVersion::None => {}
+            SlidingSyncVersion::Proxy { url } => {
+                inner_builder = inner_builder.sliding_sync_proxy(
+                    Url::parse(&url)
+                        .map_err(|e| ClientBuildError::Generic { message: e.to_string() })?,
+                )
+            }
+            SlidingSyncVersion::Native => inner_builder = inner_builder.sliding_sync_native(),
         }
 
         if let Some(config) = builder.request_config {

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

@@ -455,11 +455,13 @@ pub enum SyncIndicator {
 mod tests {
     use std::future::ready;
 
+    use assert_matches::assert_matches;
     use futures_util::{pin_mut, StreamExt};
     use matrix_sdk::{
         config::RequestConfig,
         matrix_auth::{MatrixSession, MatrixSessionTokens},
         reqwest::Url,
+        sliding_sync::Version as SlidingSyncVersion,
         Client, SlidingSyncMode,
     };
     use matrix_sdk_base::SessionMeta;
@@ -513,17 +515,20 @@ mod tests {
 
         {
             let room_list = RoomListService::new(client.clone()).await?;
-
-            assert!(room_list.sliding_sync().sliding_sync_proxy().is_none());
+            assert_matches!(room_list.sliding_sync().version(), SlidingSyncVersion::Native);
         }
 
         {
             let url = Url::parse("https://foo.matrix/").unwrap();
-            client.set_sliding_sync_proxy(Some(url.clone()));
+            client.set_sliding_sync_version(SlidingSyncVersion::Proxy { url: url.clone() });
 
             let room_list = RoomListService::new(client.clone()).await?;
-
-            assert_eq!(room_list.sliding_sync().sliding_sync_proxy(), Some(url));
+            assert_matches!(
+                room_list.sliding_sync().version(),
+                SlidingSyncVersion::Proxy { url: given_url } => {
+                    assert_eq!(&url, given_url);
+                }
+            );
         }
 
         Ok(())