feat: log out facilities

Merge pull request #1013 from matrix-org/ismail/logout

Add logout facilities to `client` and helpers to ffi for tracking the soft-logout issued by a server. Further more this adapts the `sync_with_callback` by adding a new `sync_with_result_callback` that hands the entire `Result` to the callback.

Author: gnunicorn

bindings/matrix-sdk-ffi/src/api.udl

@@ -7,6 +7,8 @@ interface ClientError {
 
 callback interface ClientDelegate {
     void did_receive_sync_update();
+    void did_receive_auth_error(boolean is_soft_logout);
+    void did_update_restore_token();
 };
 
 interface ClientBuilder {
@@ -29,7 +31,7 @@ interface Client {
     void set_delegate(ClientDelegate? delegate);
 
     [Throws=ClientError]
-    void login(string username, string password);
+    void login(string username, string password, string? initial_device_name, string? device_id);
 
     [Throws=ClientError]
     void restore_login(string restore_token);
@@ -62,6 +64,9 @@ interface Client {
 
     [Throws=ClientError]
     SessionVerificationController get_session_verification_controller();
+
+    [Throws=ClientError]
+    void logout();
 };
 
 callback interface RoomDelegate {
@@ -182,7 +187,7 @@ interface AuthenticationService {
     void configure_homeserver(string server_name);
 
     [Throws=AuthenticationError]
-    Client login(string username, string password);
+    Client login(string username, string password, string? initial_device_name, string? device_id);
 
     [Throws=AuthenticationError]
     Client restore_with_access_token(string token, string device_id);

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

@@ -96,6 +96,8 @@ impl AuthenticationService {
         &self,
         username: String,
         password: String,
+        initial_device_name: Option<String>,
+        device_id: Option<String>,
     ) -> Result<Arc<Client>, AuthenticationError> {
         let client = match &*self.client.read().unwrap() {
             Some(client) => client.clone(),
@@ -104,7 +106,9 @@ impl AuthenticationService {
 
         // Login and ask the server for the full user ID as this could be different from
         // the username that was entered.
-        client.login(username, password).map_err(AuthenticationError::from)?;
+        client
+            .login(username, password, initial_device_name, device_id)
+            .map_err(AuthenticationError::from)?;
         let whoami = client.whoami()?;
 
         // Create a new client to setup the store path now the user ID is known.

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

@@ -5,17 +5,21 @@ use matrix_sdk::{
     config::SyncSettings,
     media::{MediaFormat, MediaRequest},
     ruma::{
-        api::client::{
-            account::whoami,
-            filter::{FilterDefinition, LazyLoadOptions, RoomEventFilter, RoomFilter},
-            session::get_login_types,
-            sync::sync_events::v3::Filter,
+        api::{
+            client::{
+                account::whoami,
+                error::ErrorKind,
+                filter::{FilterDefinition, LazyLoadOptions, RoomEventFilter, RoomFilter},
+                session::get_login_types,
+                sync::sync_events::v3::Filter,
+            },
+            error::{FromHttpResponseError, ServerError},
         },
         events::room::MediaSource,
         serde::Raw,
         TransactionId,
     },
-    Client as MatrixClient, LoopCtrl, Session,
+    Client as MatrixClient, Error, HttpError, LoopCtrl, RumaApiError, Session,
 };
 
 use super::{
@@ -32,6 +36,8 @@ impl std::ops::Deref for Client {
 
 pub trait ClientDelegate: Sync + Send {
     fn did_receive_sync_update(&self);
+    fn did_receive_auth_error(&self, is_soft_logout: bool);
+    fn did_update_restore_token(&self);
 }
 
 #[derive(Clone)]
@@ -54,18 +60,34 @@ impl Client {
     }
 
     /// Login using a username and password.
-    pub fn login(&self, username: String, password: String) -> anyhow::Result<()> {
+    pub fn login(
+        &self,
+        username: String,
+        password: String,
+        initial_device_name: Option<String>,
+        device_id: Option<String>,
+    ) -> anyhow::Result<()> {
         RUNTIME.block_on(async move {
-            self.client.login_username(&username, &password).send().await?;
+            let mut builder = self.client.login_username(&username, &password);
+            if let Some(initial_device_name) = initial_device_name.as_ref() {
+                builder = builder.initial_device_display_name(initial_device_name);
+            }
+            if let Some(device_id) = device_id.as_ref() {
+                builder = builder.device_id(device_id);
+            }
+            builder.send().await?;
             Ok(())
         })
     }
 
     /// Restores the client from a `RestoreToken`.
     pub fn restore_login(&self, restore_token: String) -> anyhow::Result<()> {
-        let RestoreToken { session, homeurl: _, is_guest: _ } =
+        let RestoreToken { session, homeurl: _, is_guest: _, is_soft_logout } =
             serde_json::from_str(&restore_token)?;
 
+        // update soft logout state
+        self.state.write().unwrap().is_soft_logout = is_soft_logout;
+
         self.restore_session(session)
     }
 
@@ -112,6 +134,7 @@ impl Client {
         let state = self.state.clone();
         let delegate = self.delegate.clone();
         let session_verification_controller = self.session_verification_controller.clone();
+        let local_self = self.clone();
         RUNTIME.spawn(async move {
             let mut filter = FilterDefinition::default();
             let mut room_filter = RoomFilter::default();
@@ -131,31 +154,35 @@ impl Client {
             let sync_settings = SyncSettings::new().filter(Filter::FilterId(&filter_id));
 
             client
-                .sync_with_callback(sync_settings, |sync_response| async {
-                    if !state.read().unwrap().has_first_synced {
-                        state.write().unwrap().has_first_synced = true;
-                    }
-
-                    if state.read().unwrap().should_stop_syncing {
-                        state.write().unwrap().is_syncing = false;
-                        return LoopCtrl::Break;
-                    } else if !state.read().unwrap().is_syncing {
-                        state.write().unwrap().is_syncing = true;
+                .sync_with_result_callback(sync_settings, |result| async {
+                    if let Ok(sync_response) = result {
+                        if !state.read().unwrap().has_first_synced {
+                            state.write().unwrap().has_first_synced = true;
+                        }
+
+                        if state.read().unwrap().should_stop_syncing {
+                            state.write().unwrap().is_syncing = false;
+                            return LoopCtrl::Break;
+                        } else if !state.read().unwrap().is_syncing {
+                            state.write().unwrap().is_syncing = true;
+                        }
+
+                        if let Some(delegate) = &*delegate.read().unwrap() {
+                            delegate.did_receive_sync_update()
+                        }
+
+                        if let Some(session_verification_controller) =
+                            &*session_verification_controller.read().await
+                        {
+                            session_verification_controller
+                                .process_to_device_messages(sync_response.to_device)
+                                .await;
+                        }
+
+                        LoopCtrl::Continue
+                    } else {
+                        local_self.process_sync_error(result.err().unwrap())
                     }
-
-                    if let Some(delegate) = &*delegate.read().unwrap() {
-                        delegate.did_receive_sync_update()
-                    }
-
-                    if let Some(session_verification_controller) =
-                        &*session_verification_controller.read().await
-                    {
-                        session_verification_controller
-                            .process_to_device_messages(sync_response.to_device)
-                            .await;
-                    }
-
-                    LoopCtrl::Continue
                 })
                 .await;
         });
@@ -169,6 +196,7 @@ impl Client {
                 session,
                 homeurl,
                 is_guest: self.state.read().unwrap().is_guest,
+                is_soft_logout: self.state.read().unwrap().is_soft_logout,
             })?)
         })
     }
@@ -258,6 +286,35 @@ impl Client {
             Ok(Arc::new(session_verification_controller))
         })
     }
+
+    /// Log out the current user
+    pub fn logout(&self) -> anyhow::Result<()> {
+        RUNTIME.block_on(async move {
+            match self.client.logout().await {
+                Ok(_) => Ok(()),
+                Err(error) => Err(anyhow!(error.to_string())),
+            }
+        })
+    }
+
+    /// Process a sync error and return loop control accordingly
+    fn process_sync_error(&self, sync_error: Error) -> LoopCtrl {
+        let mut control = LoopCtrl::Continue;
+        if let Error::Http(HttpError::Api(FromHttpResponseError::Server(ServerError::Known(
+            RumaApiError::ClientApi(error),
+        )))) = sync_error
+        {
+            if let ErrorKind::UnknownToken { soft_logout } = error.kind {
+                self.state.write().unwrap().is_soft_logout = soft_logout;
+                if let Some(delegate) = &*self.delegate.read().unwrap() {
+                    delegate.did_update_restore_token();
+                    delegate.did_receive_auth_error(soft_logout);
+                }
+                control = LoopCtrl::Break
+            }
+        }
+        control
+    }
 }
 
 #[uniffi::export]
@@ -283,6 +340,11 @@ impl Client {
         self.state.read().unwrap().is_guest
     }
 
+    /// Flag indicating whether the session is in soft logout mode
+    pub fn is_soft_logout(&self) -> bool {
+        self.state.read().unwrap().is_soft_logout
+    }
+
     pub fn rooms(&self) -> Vec<Arc<Room>> {
         self.client.rooms().into_iter().map(|room| Arc::new(Room::new(room))).collect()
     }

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

@@ -36,13 +36,16 @@ pub struct ClientState {
     has_first_synced: bool,
     is_syncing: bool,
     should_stop_syncing: bool,
+    is_soft_logout: bool,
 }
 
 #[derive(Serialize, Deserialize)]
 struct RestoreToken {
     is_guest: bool,
     homeurl: String,
     session: Session,
+    #[serde(default)]
+    is_soft_logout: bool,
 }
 
 #[derive(thiserror::Error, Debug)]