Merge branch 'main' into rework_matrix_sdk_ffi_with_features

Author: Daniel Salinas

.github/workflows/ci.yml

@@ -246,7 +246,7 @@ jobs:
           components: clippy
 
       - name: Install wasm-pack
-        uses: qmaru/wasm-pack-action@v0.5.0
+        uses: qmaru/wasm-pack-action@v0.5.1
         if: '!matrix.check_only'
         with:
           version: v0.10.3

.github/workflows/detect-long-path.yml

@@ -20,7 +20,7 @@ jobs:
       - uses: actions/checkout@v4
       - name: Check for changed files
         id: changed-files
-        uses: tj-actions/changed-files@115870536a85eaf050e369291c7895748ff12aea
+        uses: tj-actions/changed-files@v46.0.5
       - name: Detect long path
         env:
           ALL_CHANGED_FILES: ${{ steps.changed-files.outputs.all_changed_files }} # ignore the deleted files

bindings/matrix-sdk-crypto-ffi/src/dehydrated_devices.rs

@@ -1,5 +1,6 @@
 use std::{mem::ManuallyDrop, sync::Arc};
 
+use matrix_sdk_common::executor::Handle;
 use matrix_sdk_crypto::{
     dehydrated_devices::{
         DehydratedDevice as InnerDehydratedDevice, DehydratedDevices as InnerDehydratedDevices,
@@ -9,7 +10,6 @@ use matrix_sdk_crypto::{
 };
 use ruma::{api::client::dehydrated_device, events::AnyToDeviceEvent, serde::Raw, OwnedDeviceId};
 use serde_json::json;
-use tokio::runtime::Handle;
 
 use crate::{CryptoStoreError, DehydratedDeviceKey};
 

bindings/matrix-sdk-crypto-ffi/src/verification.rs

@@ -1,14 +1,14 @@
 use std::sync::Arc;
 
 use futures_util::{Stream, StreamExt};
+use matrix_sdk_common::executor::Handle;
 use matrix_sdk_crypto::{
     matrix_sdk_qrcode::QrVerificationData, CancelInfo as RustCancelInfo, QrVerification as InnerQr,
     QrVerificationState, Sas as InnerSas, SasState as RustSasState,
     Verification as InnerVerification, VerificationRequest as InnerVerificationRequest,
     VerificationRequestState as RustVerificationRequestState,
 };
 use ruma::events::key::verification::VerificationMethod;
-use tokio::runtime::Handle;
 use vodozemac::{base64_decode, base64_encode};
 
 use crate::{CryptoStoreError, OutgoingVerificationRequest, SignatureUploadRequest};

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

@@ -1,13 +1,20 @@
-use std::{collections::HashMap, error::Error, fmt, fmt::Display, time::SystemTime};
+use std::{collections::HashMap, error::Error, fmt, fmt::Display};
 
 use matrix_sdk::{
-    authentication::oauth::OAuthError, encryption::CryptoStoreError, event_cache::EventCacheError,
-    reqwest, room::edit::EditError, send_queue::RoomSendQueueError, HttpError, IdParseError,
-    NotificationSettingsError as SdkNotificationSettingsError,
+    authentication::oauth::OAuthError,
+    encryption::{identities::RequestVerificationError, CryptoStoreError},
+    event_cache::EventCacheError,
+    reqwest,
+    room::edit::EditError,
+    send_queue::RoomSendQueueError,
+    HttpError, IdParseError, NotificationSettingsError as SdkNotificationSettingsError,
     QueueWedgeError as SdkQueueWedgeError, StoreError,
 };
 use matrix_sdk_ui::{encryption_sync_service, notification_client, sync_service, timeline};
-use ruma::api::client::error::{ErrorBody, ErrorKind as RumaApiErrorKind, RetryAfter};
+use ruma::{
+    api::client::error::{ErrorBody, ErrorKind as RumaApiErrorKind, RetryAfter},
+    MilliSecondsSinceUnixEpoch,
+};
 use tracing::warn;
 use uniffi::UnexpectedUniFFICallbackError;
 
@@ -198,6 +205,12 @@ impl From<FocusEventError> for ClientError {
     }
 }
 
+impl From<RequestVerificationError> for ClientError {
+    fn from(e: RequestVerificationError) -> Self {
+        Self::from_err(e)
+    }
+}
+
 /// Bindings version of the sdk type replacing OwnedUserId/DeviceIds with simple
 /// String.
 ///
@@ -749,7 +762,9 @@ impl TryFrom<RumaApiErrorKind> for ErrorKind {
                 let retry_after_ms = match retry_after {
                     Some(RetryAfter::Delay(duration)) => Some(duration.as_millis() as u64),
                     Some(RetryAfter::DateTime(system_time)) => {
-                        let duration = system_time.duration_since(SystemTime::now()).ok();
+                        let duration = MilliSecondsSinceUnixEpoch::now()
+                            .to_system_time()
+                            .and_then(|now| system_time.duration_since(now).ok());
                         duration.map(|duration| duration.as_millis() as u64)
                     }
                     None => None,

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

@@ -410,6 +410,7 @@ impl TracingConfiguration {
                         sentry::ClientOptions {
                             traces_sample_rate: 0.0,
                             attach_stacktrace: true,
+                            release: Some(env!("VERGEN_GIT_SHA").into()),
                             ..sentry::ClientOptions::default()
                         },
                     ));

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

@@ -828,18 +828,31 @@ impl Room {
 
     /// Store the given `ComposerDraft` in the state store using the current
     /// room id, as identifier.
-    pub async fn save_composer_draft(&self, draft: ComposerDraft) -> Result<(), ClientError> {
-        Ok(self.inner.save_composer_draft(draft.try_into()?).await?)
+    pub async fn save_composer_draft(
+        &self,
+        draft: ComposerDraft,
+        thread_root: Option<String>,
+    ) -> Result<(), ClientError> {
+        let thread_root = thread_root.map(EventId::parse).transpose()?;
+        Ok(self.inner.save_composer_draft(draft.try_into()?, thread_root.as_deref()).await?)
     }
 
     /// Retrieve the `ComposerDraft` stored in the state store for this room.
-    pub async fn load_composer_draft(&self) -> Result<Option<ComposerDraft>, ClientError> {
-        Ok(self.inner.load_composer_draft().await?.map(Into::into))
+    pub async fn load_composer_draft(
+        &self,
+        thread_root: Option<String>,
+    ) -> Result<Option<ComposerDraft>, ClientError> {
+        let thread_root = thread_root.map(EventId::parse).transpose()?;
+        Ok(self.inner.load_composer_draft(thread_root.as_deref()).await?.map(Into::into))
     }
 
     /// Remove the `ComposerDraft` stored in the state store for this room.
-    pub async fn clear_composer_draft(&self) -> Result<(), ClientError> {
-        Ok(self.inner.clear_composer_draft().await?)
+    pub async fn clear_composer_draft(
+        &self,
+        thread_root: Option<String>,
+    ) -> Result<(), ClientError> {
+        let thread_root = thread_root.map(EventId::parse).transpose()?;
+        Ok(self.inner.clear_composer_draft(thread_root.as_deref()).await?)
     }
 
     /// Edit an event given its event id.

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

@@ -39,7 +39,7 @@ mod sys {
 mod sys {
     use std::future::Future;
 
-    use crate::executor::{spawn, JoinHandle};
+    use matrix_sdk_common::executor::{spawn, JoinHandle};
 
     /// A dummy guard that does nothing when dropped.
     /// This is used for the Wasm implementation to match

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

@@ -116,11 +116,8 @@ impl SessionVerificationController {
     /// Request verification for the current device
     pub async fn request_device_verification(&self) -> Result<(), ClientError> {
         let methods = vec![VerificationMethod::SasV1];
-        let verification_request = self
-            .user_identity
-            .request_verification_with_methods(methods)
-            .await
-            .map_err(anyhow::Error::from)?;
+        let verification_request =
+            self.user_identity.request_verification_with_methods(methods).await?;
 
         self.set_ongoing_verification_request(verification_request)
     }
@@ -141,10 +138,7 @@ impl SessionVerificationController {
 
         let methods = vec![VerificationMethod::SasV1];
 
-        let verification_request = user_identity
-            .request_verification_with_methods(methods)
-            .await
-            .map_err(anyhow::Error::from)?;
+        let verification_request = user_identity.request_verification_with_methods(methods).await?;
 
         self.set_ongoing_verification_request(verification_request)
     }

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

@@ -1,4 +1,4 @@
-use tokio::task::JoinHandle;
+use matrix_sdk_common::executor::JoinHandle;
 use tracing::debug;
 
 /// A task handle is a way to keep the handle a task running by itself in