matrix-rust-sdk

// Copyright 2025 The Matrix.org Foundation C.I.C.

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//     http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for that specific language governing permissions and

// limitations under the License.

use std::{

    collections::HashMap,

    fmt::Debug,

    path::PathBuf,

    sync::{Arc, OnceLock},

    time::Duration,

};

use anyhow::{Context as _, anyhow};

use futures_util::pin_mut;

#[cfg(feature = "sqlite")]

use matrix_sdk::STATE_STORE_DATABASE_NAME;

#[cfg(not(target_family = "wasm"))]

use matrix_sdk::media::MediaFileHandle as SdkMediaFileHandle;

use matrix_sdk::{

    Account, AuthApi, AuthSession, Client as MatrixClient, Error, SessionChange, SessionTokens,

    authentication::oauth::{

        ClientId, OAuthAuthorizationData, OAuthError as SdkOAuthError, OAuthSession,

    },

    deserialized_responses::RawAnySyncOrStrippedTimelineEvent,

    executor::AbortOnDrop,

    media::{MediaFormat, MediaRequestParameters, MediaRetentionPolicy, MediaThumbnailSettings},

    ruma::{

        EventEncryptionAlgorithm, RoomId, TransactionId, UInt, UserId,

        api::client::{

            account::request_openid_token,

            discovery::get_authorization_server_metadata::v1::Prompt as RumaOAuthPrompt,

            push::{EmailPusherData, PusherIds, PusherInit, PusherKind as RumaPusherKind},

            room::{Visibility, create_room},

            rtc::RtcTransport,

            session::get_login_types,

            user_directory::search_users,

        },

        events::{

            AnyInitialStateEvent, InitialStateEvent,

            room::{

                avatar::RoomAvatarEventContent, encryption::RoomEncryptionEventContent,

                message::MessageType,

            },

        },

        serde::Raw,

    },

    sliding_sync::Version as SdkSlidingSyncVersion,

    store::RoomLoadSettings as SdkRoomLoadSettings,

    sync::Notification,

    task_monitor::BackgroundTaskFailureReason,

};

use matrix_sdk_common::{

    SendOutsideWasm, SyncOutsideWasm, cross_process_lock::CrossProcessLockConfig, stream::StreamExt,

};

use matrix_sdk_ui::{

    notification_client::{

        NotificationClient as MatrixNotificationClient,

        NotificationProcessSetup as MatrixNotificationProcessSetup,

    },

    spaces::SpaceService as UISpaceService,

    unable_to_decrypt_hook::UtdHookManager,

};

use mime::Mime;

use oauth2::Scope;

use ruma::{

    OwnedDeviceId, OwnedMxcUri, OwnedServerName, RoomAliasId, RoomOrAliasId, ServerName,

    api::{

        client::{

            alias::get_alias,

            discovery::get_authorization_server_metadata::v1::{

                AccountManagementActionData, DeviceDeleteData, DeviceViewData,

            },

            profile::{AvatarUrl, DisplayName},

            room::create_room::{RoomPowerLevelsContentOverride, v3::CreationContent},

            uiaa::{EmailUserIdentifier, UserIdentifier},

        },

        error::ErrorKind,

    },

    events::{

        AnyMessageLikeEventContent, AnySyncTimelineEvent,

        GlobalAccountDataEvent as RumaGlobalAccountDataEvent,

        RoomAccountDataEvent as RumaRoomAccountDataEvent,

        direct::DirectEventContent,

        fully_read::FullyReadEventContent,

        identity_server::IdentityServerEventContent,

        ignored_user_list::IgnoredUserListEventContent,

        key::verification::request::ToDeviceKeyVerificationRequestEvent,

        marked_unread::{MarkedUnreadEventContent, UnstableMarkedUnreadEventContent},

        push_rules::PushRulesEventContent,

        room::{

            history_visibility::RoomHistoryVisibilityEventContent,

            join_rules::{

                AllowRule as RumaAllowRule, JoinRule as RumaJoinRule, RoomJoinRulesEventContent,

            },

            message::{OriginalSyncRoomMessageEvent, Relation},

        },

        secret_storage::{

            default_key::SecretStorageDefaultKeyEventContent, key::SecretStorageKeyEventContent,

        },

        tag::TagEventContent,

    },

    push::{HttpPusherData as RumaHttpPusherData, PushFormat as RumaPushFormat},

    room::RoomType,

};

use serde::{Deserialize, Serialize};

use serde_json::{Value, json};

use tokio::sync::broadcast::error::RecvError;

use tracing::{debug, error, warn};

use url::Url;

use super::{

    room::{Room, room_info::RoomInfo},

    session_verification::SessionVerificationController,

};

use crate::{

    ClientError,

    authentication::{

        HomeserverLoginDetails, OAuthConfiguration, OAuthError, SsoError, SsoHandler,

    },

    client,

    encryption::Encryption,

    live_locations_observer::BeaconInfoUpdate,

    notification::{

        NotificationClient, NotificationEvent, NotificationItem, NotificationRoomInfo,

        NotificationSenderInfo,

    },

    notification_settings::NotificationSettings,

    qr_code::{GrantLoginWithQrCodeHandler, LoginWithQrCodeHandler},

    room::{RoomHistoryVisibility, RoomInfoListener, RoomSendQueueUpdate},

    room_directory_search::RoomDirectorySearch,

    room_preview::RoomPreview,

    ruma::{

        AccountDataEvent, AccountDataEventType, AuthData, InviteAvatars, MediaPreviewConfig,

        MediaPreviews, MediaSource, RoomAccountDataEvent, RoomAccountDataEventType,

    },

    runtime::get_runtime_handle,

    spaces::SpaceService,

    sync_service::{SyncService, SyncServiceBuilder},

    sync_v2::{SyncListenerV2, SyncResponseV2, SyncSettingsV2},

    task_handle::TaskHandle,

    utd::{UnableToDecryptDelegate, UtdHook},

    utils::AsyncRuntimeDropped,

};

#[derive(Clone, uniffi::Record)]

pub struct PusherIdentifiers {

    pub pushkey: String,

    pub app_id: String,

}

impl From<PusherIdentifiers> for PusherIds {

    fn from(value: PusherIdentifiers) -> Self {

        Self::new(value.pushkey, value.app_id)

    }

}

#[derive(Clone, uniffi::Record)]

pub struct HttpPusherData {

    pub url: String,

    pub format: Option<PushFormat>,

    pub default_payload: Option<String>,

}

#[derive(Clone, uniffi::Enum)]

pub enum PusherKind {

    Http { data: HttpPusherData },

    Email,

}

impl TryFrom<PusherKind> for RumaPusherKind {

    type Error = anyhow::Error;

    fn try_from(value: PusherKind) -> anyhow::Result<Self> {

        match value {

            PusherKind::Http { data } => {

                let mut ruma_data = RumaHttpPusherData::new(data.url);

                if let Some(payload) = data.default_payload {

                    let json: Value = serde_json::from_str(&payload)?;

                    ruma_data.data.insert("default_payload".to_owned(), json);

                }

                ruma_data.format = data.format.map(Into::into);

                Ok(Self::Http(ruma_data))

            }

            PusherKind::Email => {

                let ruma_data = EmailPusherData::new();

                Ok(Self::Email(ruma_data))

            }

        }

    }

}

#[derive(Clone, uniffi::Enum)]

pub enum PushFormat {

    EventIdOnly,

}

impl From<PushFormat> for RumaPushFormat {

    fn from(value: PushFormat) -> Self {

        match value {

            client::PushFormat::EventIdOnly => Self::EventIdOnly,

        }

    }

}

#[matrix_sdk_ffi_macros::export(callback_interface)]

pub trait ClientDelegate: SyncOutsideWasm + SendOutsideWasm {

    /// A callback invoked whenever the SDK runs into an unknown token error.

    fn did_receive_auth_error(&self, is_soft_logout: bool);

    /// A callback invoked when a background task registered with the client's

    /// task monitor encounters an error.

    ///

    /// Can default to an empty implementation, if the embedder doesn't care

    /// about handling background jobs errors.

    fn on_background_task_error_report(

        &self,

        task_name: String,

        error: BackgroundTaskFailureReason,

    );

}

#[matrix_sdk_ffi_macros::export(callback_interface)]

pub trait ClientSessionDelegate: SyncOutsideWasm + SendOutsideWasm {

    fn retrieve_session_from_keychain(&self, user_id: String) -> Result<Session, ClientError>;

    fn save_session_in_keychain(&self, session: Session);

}

#[matrix_sdk_ffi_macros::export(callback_interface)]

pub trait ProgressWatcher: SyncOutsideWasm + SendOutsideWasm {

    fn transmission_progress(&self, progress: TransmissionProgress);

}

/// A listener to the global (client-wide) update reporter of the send queue.

#[matrix_sdk_ffi_macros::export(callback_interface)]

pub trait SendQueueRoomUpdateListener: SyncOutsideWasm + SendOutsideWasm {

    /// Called every time the send queue emits an update for a given room.

    fn on_update(&self, room_id: String, update: RoomSendQueueUpdate);

}

/// A listener to the global (client-wide) error reporter of the send queue.

#[matrix_sdk_ffi_macros::export(callback_interface)]

pub trait SendQueueRoomErrorListener: SyncOutsideWasm + SendOutsideWasm {

    /// Called every time the send queue has ran into an error for a given room,

    /// which will disable the send queue for that particular room.

    fn on_error(&self, room_id: String, error: ClientError);

}

/// A listener for changes of global account data events.

#[matrix_sdk_ffi_macros::export(callback_interface)]

pub trait AccountDataListener: SyncOutsideWasm + SendOutsideWasm {

    /// Called when a global account data event has changed.

    fn on_change(&self, event: AccountDataEvent);

}

/// A listener for duplicate key upload errors triggered by requests to

/// /keys/upload.

#[matrix_sdk_ffi_macros::export(callback_interface)]

pub trait DuplicateKeyUploadErrorListener: SyncOutsideWasm + SendOutsideWasm {

    /// Called once when uploading keys fails.

    fn on_duplicate_key_upload_error(&self, message: Option<DuplicateOneTimeKeyErrorMessage>);

}

/// A listener for the current user's client-wide beacon_info updates.

#[matrix_sdk_ffi_macros::export(callback_interface)]

pub trait BeaconInfoListener: SyncOutsideWasm + SendOutsideWasm {

    /// Called whenever the current user's beacon_info changes in any room.

    fn on_update(&self, update: BeaconInfoUpdate);

}

/// Information about the old and new key that caused a duplicate key upload

/// error in /keys/upload.

#[derive(uniffi::Record)]

pub struct DuplicateOneTimeKeyErrorMessage {

    /// The previously uploaded one-time key, encoded as unpadded base64.

    pub old_key: String,

    /// The one-time key we attempted to upload, encoded as unpadded base64

    pub new_key: String,

}

impl From<matrix_sdk::encryption::DuplicateOneTimeKeyErrorMessage>

    for DuplicateOneTimeKeyErrorMessage

{

    fn from(value: matrix_sdk::encryption::DuplicateOneTimeKeyErrorMessage) -> Self {

        Self { old_key: value.old_key.to_base64(), new_key: value.new_key.to_base64() }

    }

}

/// A listener for changes of room account data events.

#[matrix_sdk_ffi_macros::export(callback_interface)]

pub trait RoomAccountDataListener: SyncOutsideWasm + SendOutsideWasm {

    /// Called when a room account data event was changed.

    fn on_change(&self, event: RoomAccountDataEvent, room_id: String);

}

/// A listener for notifications generated from sync responses.

///

/// This is called during sync for each event that triggers a notification

/// based on the user's push rules.

#[matrix_sdk_ffi_macros::export(callback_interface)]

pub trait SyncNotificationListener: SyncOutsideWasm + SendOutsideWasm {

    /// Called when a notifying event is received during sync.

    fn on_notification(&self, notification: NotificationItem, room_id: String);

}

#[derive(Clone, Copy, uniffi::Record)]

pub struct TransmissionProgress {

    pub current: u64,

    pub total: u64,

}

impl From<matrix_sdk::TransmissionProgress> for TransmissionProgress {

    fn from(value: matrix_sdk::TransmissionProgress) -> Self {

        Self {

            current: value.current.try_into().unwrap_or(u64::MAX),

            total: value.total.try_into().unwrap_or(u64::MAX),

        }

    }

}

#[derive(Clone, uniffi::Record)]

pub struct OpenIdToken {

    pub access_token: String,

    pub token_type: String,

    pub matrix_server_name: String,

    pub expires_in_seconds: u64,

}

impl From<request_openid_token::v3::Response> for OpenIdToken {

    fn from(value: request_openid_token::v3::Response) -> Self {

        Self {

            access_token: value.access_token,

            token_type: serde_json::to_value(&value.token_type)

                .ok()

                .and_then(|value| value.as_str().map(ToOwned::to_owned))

                .unwrap_or_else(|| format!("{:?}", value.token_type)),

            matrix_server_name: value.matrix_server_name.to_string(),

            expires_in_seconds: value.expires_in.as_secs(),

        }

    }

}

struct ClientDelegateData {

    /// The delegate itself, that will receive the callbacks.

    delegate: Arc<dyn ClientDelegate>,

    // The background task error listener task, that will forward errors occurring in background

    // jobs to the delegate.

    _background_error_listener_task: Arc<AbortOnDrop<()>>,

}

#[derive(uniffi::Object)]

pub struct Client {

    pub(crate) inner: AsyncRuntimeDropped<MatrixClient>,

    delegate_data: OnceLock<ClientDelegateData>,

    pub(crate) utd_hook_manager: OnceLock<Arc<UtdHookManager>>,

    session_verification_controller:

        Arc<tokio::sync::RwLock<Option<SessionVerificationController>>>,

    /// The path to the directory where the state store and the crypto store are

    /// located, if the `Client` instance has been built with a store (either

    /// SQLite or IndexedDB).

    #[cfg_attr(not(feature = "sqlite"), allow(unused))]

    store_path: Option<PathBuf>,

}

impl Client {

    pub async fn new(

        sdk_client: MatrixClient,

        session_delegate: Option<Arc<dyn ClientSessionDelegate>>,

        store_path: Option<PathBuf>,

    ) -> Result<Self, ClientError> {

        let session_verification_controller: Arc<

            tokio::sync::RwLock<Option<SessionVerificationController>>,

        > = Default::default();

        let controller = session_verification_controller.clone();

        sdk_client.add_event_handler(

            move |event: ToDeviceKeyVerificationRequestEvent| async move {

                if let Some(session_verification_controller) = &*controller.clone().read().await {

                    session_verification_controller

                        .process_incoming_verification_request(

                            &event.sender,

                            event.content.transaction_id,

                        )

                        .await;

                }

            },

        );

        let controller = session_verification_controller.clone();

        sdk_client.add_event_handler(move |event: OriginalSyncRoomMessageEvent| async move {

            if let MessageType::VerificationRequest(_) = &event.content.msgtype

                && let Some(session_verification_controller) = &*controller.clone().read().await

            {

                session_verification_controller

                    .process_incoming_verification_request(&event.sender, event.event_id)

                    .await;

            }

        });

        let store_mode = sdk_client.cross_process_lock_config();

        let client = Client {

            inner: AsyncRuntimeDropped::new(sdk_client.clone()),

            delegate_data: OnceLock::new(),

            utd_hook_manager: OnceLock::new(),

            session_verification_controller,

            store_path,

        };

        match store_mode {

            CrossProcessLockConfig::MultiProcess { holder_name } => {

                if session_delegate.is_none() {

                    return Err(anyhow::anyhow!(

                        "missing session delegates with multi-process lock configuration"

                    ))?;

                }

                client.inner.oauth().enable_cross_process_refresh_lock(holder_name.clone()).await?;

            }

            CrossProcessLockConfig::SingleProcess => {}

        }

        if let Some(session_delegate) = session_delegate {

            client.inner.set_session_callbacks(

                {

                    let session_delegate = session_delegate.clone();

                    Box::new(move |client| {

                        let session_delegate = session_delegate.clone();

                        let user_id = client.user_id().context("user isn't logged in")?;

                        Ok(Self::retrieve_session(session_delegate, user_id)?)

                    })

                },

                {

                    let session_delegate = session_delegate.clone();

                    Box::new(move |client| {

                        let session_delegate = session_delegate.clone();

                        Ok(Self::save_session(session_delegate, client)?)

                    })

                },

            )?;

        }

        Ok(client)

    }

}

#[matrix_sdk_ffi_macros::export]

impl Client {

    /// Perform database optimizations if any are available, i.e. vacuuming in

    /// SQLite.

    pub async fn optimize_stores(&self) -> Result<(), ClientError> {

        Ok(self.inner.optimize_stores().await?)

    }

    /// Pause the client for background suspension.

    ///

    /// This method:

    /// 1. Disables all send queues (prevents new message sends).

    /// 2. Pauses all database stores, waiting for in-flight operations and

    ///    releasing all connections and file locks.

    ///

    /// Call [`Client::resume()`] when the app returns to the foreground.

    ///

    /// # iOS

    ///

    /// Call this before the app is suspended to avoid `0xdead10cc` kills.

    /// Typically called from

    /// [`applicationDidEnterBackground`](https://developer.apple.com/documentation/uikit/uiapplicationdelegate/applicationdidenterbackground(_:))

    /// or an equivalent SwiftUI lifecycle event, *after* stopping the

    /// `matrix_sdk_ui::sync_service::SyncService`.

    pub async fn pause(&self) -> Result<(), ClientError> {

        Ok(self.inner.pause().await?)

    }

    /// Resume the client after a [`Client::pause()`].

    ///

    /// Re-acquires store resources and re-enables send queues.

    ///

    /// If your app stopped the `matrix_sdk_ui::sync_service::SyncService`

    /// before pausing, restart it separately as appropriate for your app

    /// lifecycle.

    pub async fn resume(&self) -> Result<(), ClientError> {

        Ok(self.inner.resume().await?)

    }

    /// Returns the sizes of the existing stores, if known.

    pub async fn get_store_sizes(&self) -> Result<StoreSizes, ClientError> {

        Ok(self.inner.get_store_sizes().await?.into())

    }