Struct SyncService

pub struct SyncService { /* private fields */ }

A high level manager for your Matrix syncing needs.

The SyncService is responsible for managing real-time synchronization with a Matrix server. It can initiate and maintain the necessary synchronization tasks for you.

Note: The SyncService requires a server with support for MSC4186, otherwise it will fail with an 404 M_UNRECOGNIZED request error.

Example

use matrix_sdk::Client;
use matrix_sdk_ui::sync_service::{State, SyncService};
let homeserver = Url::parse("http://example.com")?;
let client = Client::new(homeserver).await?;

client
    .matrix_auth()
    .login_username("example", "wordpass")
    .initial_device_display_name("My bot")
    .await?;

let sync_service = SyncService::builder(client).build().await?;
let mut state = sync_service.state();

while let Some(state) = state.next().await {
    match state {
        State::Idle => eprintln!("The sync service is idle."),
        State::Running => eprintln!("The sync has started to run."),
        State::Offline => eprintln!(
            "We have entered the offline mode, the server seems to be
             unavailable"
        ),
        State::Terminated => {
            eprintln!("The sync service has been gracefully terminated");
            break;
        }
        State::Error(_) => {
            eprintln!("The sync service has run into an error");
            break;
        }
    }
}

Implementations

impl SyncService

pub fn builder(client: Client) -> SyncServiceBuilder

Create a new builder for configuring an SyncService.

pub fn room_list_service(&self) -> Arc<RoomListService>

Get the underlying RoomListService instance for easier access to its methods.

pub fn state(&self) -> Subscriber<State>

Returns the state of the sync service.

pub async fn start(&self)

Start (or restart) the underlying sliding syncs.

This can be called multiple times safely:

• if the stream is still properly running, it won’t be restarted.
• if the SyncService is in the offline mode we will exit the offline mode and immediately attempt to sync again.
• if the stream has been aborted before, it will be properly cleaned up and restarted.

pub async fn stop(&self)

Stop the underlying sliding syncs.

This must be called when the app goes into the background. It’s better to call this API when the application exits, although not strictly necessary.

pub async fn expire_sessions(&self)

Force expiring both sessions.

This ensures that the sync service is stopped before expiring both sessions. It should be used sparingly, as it will cause a restart of the sessions on the server as well.

pub fn try_get_encryption_sync_permit( &self, ) -> Option<OwnedMutexGuard<EncryptionSyncPermit>>

Attempt to get a permit to use an EncryptionSyncService at a given time.

This ensures there is at most one EncryptionSyncService active at any time, per application.