chore: Upgrade matrix-sdk and other cargo dependencies

Cargo.toml

@@ -26,10 +26,10 @@ ashpd = { version = "0.4", default-features = false, features = [
     "tracing",
     "tokio",
 ] }
-async-stream = "0.3"
 djb_hash = "0.1"
 eyeball-im = "0.2"
-futures = "0.3"
+futures-channel = "0.3"
+futures-util = "0.3"
 geo-uri = "0.2"
 gettext-rs = { version = "0.7", features = ["gettext-system"] }
 gst = { version = "0.20", package = "gstreamer" }
@@ -78,7 +78,7 @@ features = ["v4_10"]
 
 [dependencies.matrix-sdk]
 git = "https://github.com/matrix-org/matrix-rust-sdk.git"
-rev = "1dea482e4399aaca5e96611e732ed06c3de2d4a6"
+rev = "4643bae28445e058080896a280083b32fd403146"
 features = [
     "socks",
     "sso-login",
@@ -89,14 +89,14 @@ features = [
 
 [dependencies.matrix-sdk-ui]
 git = "https://github.com/matrix-org/matrix-rust-sdk.git"
-rev = "1dea482e4399aaca5e96611e732ed06c3de2d4a6"
+rev = "4643bae28445e058080896a280083b32fd403146"
 default-features = false
 features = ["e2e-encryption", "native-tls"]
 
 [dependencies.ruma]
 # version = "0.8.2"
 git = "https://github.com/ruma/ruma.git"
-rev = "a641adb4287267ba9c4778ac1ee83b4ecab11e26"
+rev = "f1772ae5bc1d849655498f51b0fec7b0ef10e339"
 features = [
     "unstable-unspecified",
     "client-api-c",
@@ -117,8 +117,3 @@ version = "0.3"
 [dependencies.sourceview]
 package = "sourceview5"
 version = "0.6"
-
-# FIXME: Remove when matrix-sdk dependencies don't pin zeroize (conflict with oo7)
-[patch.crates-io.x25519-dalek]
-git = "https://github.com/A6GibKm/x25519-dalek"
-rev = "9f19028c34107eea87d37bcee2eb2b350ec34cfe"

src/components/auth_dialog.rs

@@ -308,7 +308,7 @@ impl AuthDialog {
 
     /// Lets the user complete the current stage.
     async fn show_and_wait_for_response(&self) -> Result<(), AuthError> {
-        let (sender, receiver) = futures::channel::oneshot::channel();
+        let (sender, receiver) = futures_channel::oneshot::channel();
         let sender = Cell::new(Some(sender));
 
         let handler_id = self.connect_response(move |_, response| {

src/contrib/qr_code_scanner/camera_paintable.rs

@@ -207,7 +207,7 @@ impl CameraPaintable {
         let paintable = sink.property::<gdk::Paintable>("paintable");
 
         // Workaround: we wait for the first frame so that we don't show a black frame
-        let (sender, receiver) = futures::channel::oneshot::channel();
+        let (sender, receiver) = futures_channel::oneshot::channel();
         let sender = Cell::new(Some(sender));
 
         paintable.connect_invalidate_contents(move |_| {

src/login/advanced_dialog.rs

@@ -96,7 +96,7 @@ impl LoginAdvancedDialog {
     }
 
     pub async fn run_future(&self) {
-        let (sender, receiver) = futures::channel::oneshot::channel();
+        let (sender, receiver) = futures_channel::oneshot::channel();
         let sender = Cell::new(Some(sender));
 
         self.connect_close_request(move |_| {

src/session/model/room/mod.rs

@@ -368,12 +368,7 @@ impl Room {
 
         let matrix_room = self.matrix_room();
 
-        let handle = spawn_tokio!(async move {
-            match matrix_room {
-                MatrixRoom::Left(room) => room.forget().await,
-                _ => unimplemented!(),
-            }
-        });
+        let handle = spawn_tokio!(async move { matrix_room.forget().await });
 
         match handle.await.unwrap() {
             Ok(_) => {
@@ -453,170 +448,182 @@ impl Room {
         self.set_category_internal(category);
 
         let handle = spawn_tokio!(async move {
-            match matrix_room {
-                MatrixRoom::Invited(room) => match category {
+            match matrix_room.state() {
+                RoomState::Invited => match category {
                     RoomType::Invited => {}
                     RoomType::Favorite => {
-                        if let Some(tags) = room.tags().await? {
+                        if let Some(tags) = matrix_room.tags().await? {
                             if !tags.contains_key(&TagName::Favorite) {
-                                room.set_tag(TagName::Favorite, TagInfo::new()).await?;
+                                matrix_room
+                                    .set_tag(TagName::Favorite, TagInfo::new())
+                                    .await?;
                             }
                             if tags.contains_key(&TagName::LowPriority) {
-                                room.remove_tag(TagName::LowPriority).await?;
+                                matrix_room.remove_tag(TagName::LowPriority).await?;
                             }
                         }
-                        room.accept_invitation().await?;
+                        matrix_room.join().await?;
                     }
                     RoomType::Normal => {
-                        if let Some(tags) = room.tags().await? {
+                        if let Some(tags) = matrix_room.tags().await? {
                             if tags.contains_key(&TagName::Favorite) {
-                                room.remove_tag(TagName::Favorite).await?;
+                                matrix_room.remove_tag(TagName::Favorite).await?;
                             }
                             if tags.contains_key(&TagName::LowPriority) {
-                                room.remove_tag(TagName::LowPriority).await?;
+                                matrix_room.remove_tag(TagName::LowPriority).await?;
                             }
                         }
 
-                        if room.is_direct().await.unwrap_or_default() {
-                            room.set_is_direct(false).await?;
+                        if matrix_room.is_direct().await.unwrap_or_default() {
+                            matrix_room.set_is_direct(false).await?;
                         }
 
-                        room.accept_invitation().await?;
+                        matrix_room.join().await?;
                     }
                     RoomType::LowPriority => {
-                        if let Some(tags) = room.tags().await? {
+                        if let Some(tags) = matrix_room.tags().await? {
                             if tags.contains_key(&TagName::Favorite) {
-                                room.remove_tag(TagName::Favorite).await?;
+                                matrix_room.remove_tag(TagName::Favorite).await?;
                             }
                             if !tags.contains_key(&TagName::LowPriority) {
-                                room.set_tag(TagName::LowPriority, TagInfo::new()).await?;
+                                matrix_room
+                                    .set_tag(TagName::LowPriority, TagInfo::new())
+                                    .await?;
                             }
                         }
-                        room.accept_invitation().await?;
+                        matrix_room.join().await?;
                     }
                     RoomType::Left => {
-                        room.reject_invitation().await?;
+                        matrix_room.leave().await?;
                     }
                     RoomType::Outdated => unimplemented!(),
                     RoomType::Space => unimplemented!(),
                     RoomType::Direct => {
-                        if !room.is_direct().await.unwrap_or_default() {
-                            room.set_is_direct(true).await?;
+                        if !matrix_room.is_direct().await.unwrap_or_default() {
+                            matrix_room.set_is_direct(true).await?;
                         }
 
-                        if let Some(tags) = room.tags().await? {
+                        if let Some(tags) = matrix_room.tags().await? {
                             if tags.contains_key(&TagName::Favorite) {
-                                room.remove_tag(TagName::Favorite).await?;
+                                matrix_room.remove_tag(TagName::Favorite).await?;
                             }
                             if tags.contains_key(&TagName::LowPriority) {
-                                room.remove_tag(TagName::LowPriority).await?;
+                                matrix_room.remove_tag(TagName::LowPriority).await?;
                             }
                         }
 
-                        room.accept_invitation().await?;
+                        matrix_room.join().await?;
                     }
                 },
-                MatrixRoom::Joined(room) => match category {
+                RoomState::Joined => match category {
                     RoomType::Invited => {}
                     RoomType::Favorite => {
-                        room.set_tag(TagName::Favorite, TagInfo::new()).await?;
+                        matrix_room
+                            .set_tag(TagName::Favorite, TagInfo::new())
+                            .await?;
                         if previous_category == RoomType::LowPriority {
-                            room.remove_tag(TagName::LowPriority).await?;
+                            matrix_room.remove_tag(TagName::LowPriority).await?;
                         }
                     }
                     RoomType::Normal => {
-                        if room.is_direct().await.unwrap_or_default() {
-                            room.set_is_direct(false).await?;
+                        if matrix_room.is_direct().await.unwrap_or_default() {
+                            matrix_room.set_is_direct(false).await?;
                         }
                         match previous_category {
                             RoomType::Favorite => {
-                                room.remove_tag(TagName::Favorite).await?;
+                                matrix_room.remove_tag(TagName::Favorite).await?;
                             }
                             RoomType::LowPriority => {
-                                room.remove_tag(TagName::LowPriority).await?;
+                                matrix_room.remove_tag(TagName::LowPriority).await?;
                             }
                             _ => {}
                         }
                     }
                     RoomType::LowPriority => {
-                        room.set_tag(TagName::LowPriority, TagInfo::new()).await?;
+                        matrix_room
+                            .set_tag(TagName::LowPriority, TagInfo::new())
+                            .await?;
                         if previous_category == RoomType::Favorite {
-                            room.remove_tag(TagName::Favorite).await?;
+                            matrix_room.remove_tag(TagName::Favorite).await?;
                         }
                     }
                     RoomType::Left => {
-                        room.leave().await?;
+                        matrix_room.leave().await?;
                     }
                     RoomType::Outdated => unimplemented!(),
                     RoomType::Space => unimplemented!(),
                     RoomType::Direct => {
-                        if !room.is_direct().await.unwrap_or_default() {
-                            room.set_is_direct(true).await?;
+                        if !matrix_room.is_direct().await.unwrap_or_default() {
+                            matrix_room.set_is_direct(true).await?;
                         }
 
-                        if let Some(tags) = room.tags().await? {
+                        if let Some(tags) = matrix_room.tags().await? {
                             if tags.contains_key(&TagName::LowPriority) {
-                                room.remove_tag(TagName::LowPriority).await?;
+                                matrix_room.remove_tag(TagName::LowPriority).await?;
                             }
                             if tags.contains_key(&TagName::Favorite) {
-                                room.remove_tag(TagName::Favorite).await?;
+                                matrix_room.remove_tag(TagName::Favorite).await?;
                             }
                         }
                     }
                 },
-                MatrixRoom::Left(room) => match category {
+                RoomState::Left => match category {
                     RoomType::Invited => {}
                     RoomType::Favorite => {
-                        if let Some(tags) = room.tags().await? {
+                        if let Some(tags) = matrix_room.tags().await? {
                             if !tags.contains_key(&TagName::Favorite) {
-                                room.set_tag(TagName::Favorite, TagInfo::new()).await?;
+                                matrix_room
+                                    .set_tag(TagName::Favorite, TagInfo::new())
+                                    .await?;
                             }
                             if tags.contains_key(&TagName::LowPriority) {
-                                room.remove_tag(TagName::LowPriority).await?;
+                                matrix_room.remove_tag(TagName::LowPriority).await?;
                             }
                         }
-                        room.join().await?;
+                        matrix_room.join().await?;
                     }
                     RoomType::Normal => {
-                        if let Some(tags) = room.tags().await? {
+                        if let Some(tags) = matrix_room.tags().await? {
                             if tags.contains_key(&TagName::Favorite) {
-                                room.remove_tag(TagName::Favorite).await?;
+                                matrix_room.remove_tag(TagName::Favorite).await?;
                             }
                             if tags.contains_key(&TagName::LowPriority) {
-                                room.remove_tag(TagName::LowPriority).await?;
+                                matrix_room.remove_tag(TagName::LowPriority).await?;
                             }
                         }
-                        room.join().await?;
+                        matrix_room.join().await?;
                     }
                     RoomType::LowPriority => {
-                        if let Some(tags) = room.tags().await? {
+                        if let Some(tags) = matrix_room.tags().await? {
                             if tags.contains_key(&TagName::Favorite) {
-                                room.remove_tag(TagName::Favorite).await?;
+                                matrix_room.remove_tag(TagName::Favorite).await?;
                             }
                             if !tags.contains_key(&TagName::LowPriority) {
-                                room.set_tag(TagName::LowPriority, TagInfo::new()).await?;
+                                matrix_room
+                                    .set_tag(TagName::LowPriority, TagInfo::new())
+                                    .await?;
                             }
                         }
-                        room.join().await?;
+                        matrix_room.join().await?;
                     }
                     RoomType::Left => {}
                     RoomType::Outdated => unimplemented!(),
                     RoomType::Space => unimplemented!(),
                     RoomType::Direct => {
-                        if !room.is_direct().await.unwrap_or_default() {
-                            room.set_is_direct(true).await?;
+                        if !matrix_room.is_direct().await.unwrap_or_default() {
+                            matrix_room.set_is_direct(true).await?;
                         }
 
-                        if let Some(tags) = room.tags().await? {
+                        if let Some(tags) = matrix_room.tags().await? {
                             if tags.contains_key(&TagName::LowPriority) {
-                                room.remove_tag(TagName::LowPriority).await?;
+                                matrix_room.remove_tag(TagName::LowPriority).await?;
                             }
                             if tags.contains_key(&TagName::Favorite) {
-                                room.remove_tag(TagName::Favorite).await?;
+                                matrix_room.remove_tag(TagName::Favorite).await?;
                             }
                         }
 
-                        room.join().await?;
+                        matrix_room.join().await?;
                     }
                 },
             }
@@ -645,8 +652,8 @@ impl Room {
 
         let matrix_room = self.matrix_room();
 
-        match matrix_room {
-            MatrixRoom::Joined(_) => {
+        match matrix_room.state() {
+            RoomState::Joined => {
                 if matrix_room.is_space() {
                     self.set_category_internal(RoomType::Space);
                 } else {
@@ -678,8 +685,8 @@ impl Room {
                     );
                 }
             }
-            MatrixRoom::Invited(_) => self.set_category_internal(RoomType::Invited),
-            MatrixRoom::Left(_) => self.set_category_internal(RoomType::Left),
+            RoomState::Invited => self.set_category_internal(RoomType::Invited),
+            RoomState::Left => self.set_category_internal(RoomType::Left),
         };
     }
 
@@ -688,7 +695,8 @@ impl Room {
     }
 
     fn setup_typing(&self) {
-        let MatrixRoom::Joined(matrix_room) = self.matrix_room() else {
+        let matrix_room = self.matrix_room();
+        if matrix_room.state() != RoomState::Joined {
             return;
         };
 
@@ -1258,7 +1266,8 @@ impl Room {
 
     /// Redact `redacted_event_id` in this room because of `reason`.
     pub fn redact(&self, redacted_event_id: OwnedEventId, reason: Option<String>) {
-        let MatrixRoom::Joined(matrix_room) = self.matrix_room() else {
+        let matrix_room = self.matrix_room();
+        if matrix_room.state() != RoomState::Joined {
             return;
         };
 
@@ -1281,7 +1290,8 @@ impl Room {
     }
 
     pub fn send_typing_notification(&self, is_typing: bool) {
-        let MatrixRoom::Joined(matrix_room) = self.matrix_room() else {
+        let matrix_room = self.matrix_room();
+        if matrix_room.state() != RoomState::Joined {
             return;
         };
 
@@ -1313,12 +1323,12 @@ impl Room {
     pub async fn accept_invite(&self) -> MatrixResult<()> {
         let matrix_room = self.matrix_room();
 
-        let MatrixRoom::Invited(matrix_room) = matrix_room else {
+        if matrix_room.state() != RoomState::Invited {
             error!("Can’t accept invite, because this room isn’t an invited room");
             return Ok(());
-        };
+        }
 
-        let handle = spawn_tokio!(async move { matrix_room.accept_invitation().await });
+        let handle = spawn_tokio!(async move { matrix_room.join().await });
         match handle.await.unwrap() {
             Ok(_) => Ok(()),
             Err(error) => {
@@ -1331,12 +1341,12 @@ impl Room {
     pub async fn reject_invite(&self) -> MatrixResult<()> {
         let matrix_room = self.matrix_room();
 
-        let MatrixRoom::Invited(matrix_room) = matrix_room else {
+        if matrix_room.state() != RoomState::Invited {
             error!("Can’t reject invite, because this room isn’t an invited room");
             return Ok(());
-        };
+        }
 
-        let handle = spawn_tokio!(async move { matrix_room.reject_invitation().await });
+        let handle = spawn_tokio!(async move { matrix_room.leave().await });
         match handle.await.unwrap() {
             Ok(_) => Ok(()),
             Err(error) => {
@@ -1500,7 +1510,8 @@ impl Room {
         body: &str,
         info: AttachmentInfo,
     ) {
-        let MatrixRoom::Joined(matrix_room) = self.matrix_room() else {
+        let matrix_room = self.matrix_room();
+        if matrix_room.state() != RoomState::Joined {
             return;
         };
 
@@ -1544,17 +1555,18 @@ impl Room {
     /// Returns `Ok(())` if all the invites are sent successfully, otherwise
     /// returns the list of users who could not be invited.
     pub async fn invite<'a>(&self, users: &'a [User]) -> Result<(), Vec<&'a User>> {
-        let MatrixRoom::Joined(matrix_room) = self.matrix_room() else {
+        let matrix_room = self.matrix_room();
+        if matrix_room.state() != RoomState::Joined {
             error!("Can’t invite users, because this room isn’t a joined room");
             return Ok(());
-        };
+        }
         let user_ids: Vec<OwnedUserId> = users.iter().map(|user| user.user_id()).collect();
 
         let handle = spawn_tokio!(async move {
             let invitations = user_ids
                 .iter()
                 .map(|user_id| matrix_room.invite_user_by_id(user_id));
-            futures::future::join_all(invitations).await
+            futures_util::future::join_all(invitations).await
         });
 
         let mut failed_invites = Vec::new();

src/session/model/room/timeline/mod.rs

@@ -4,7 +4,7 @@ mod virtual_item;
 use std::{collections::HashMap, sync::Arc};
 
 use eyeball_im::VectorDiff;
-use futures::StreamExt;
+use futures_util::StreamExt;
 use gtk::{gio, glib, glib::clone, prelude::*, subclass::prelude::*};
 use log::{error, warn};
 use matrix_sdk::Error as MatrixError;
@@ -515,7 +515,7 @@ impl Timeline {
 
         self.imp().timeline.set(matrix_timeline.clone()).unwrap();
 
-        let (mut sender, mut receiver) = futures::channel::mpsc::channel(100);
+        let (mut sender, mut receiver) = futures_channel::mpsc::channel(100);
         let (values, timeline_stream) = matrix_timeline.subscribe().await;
 
         if !values.is_empty() {
@@ -548,7 +548,7 @@ impl Timeline {
         let room_id = self.room().room_id().to_owned();
         let matrix_timeline = self.matrix_timeline();
 
-        let (mut sender, mut receiver) = futures::channel::mpsc::channel(8);
+        let (mut sender, mut receiver) = futures_channel::mpsc::channel(8);
         let stream = matrix_timeline.back_pagination_status();
 
         let fut = stream.for_each(move |status| {

src/session/model/room_list.rs

@@ -161,7 +161,7 @@ impl RoomList {
         if let Some(room) = self.get(room_id) {
             Some(room)
         } else {
-            let (sender, receiver) = futures::channel::oneshot::channel();
+            let (sender, receiver) = futures_channel::oneshot::channel();
 
             let room_id = room_id.to_owned();
             let sender = Cell::new(Some(sender));

src/session/model/session.rs

@@ -1,7 +1,7 @@
 use std::{collections::HashSet, time::Duration};
 
 use adw::{prelude::*, subclass::prelude::*};
-use futures::StreamExt;
+use futures_util::StreamExt;
 use gettextrs::gettext;
 use gtk::{
     self, gio, glib,

src/session/view/content/room_details/general_page/mod.rs

@@ -8,7 +8,7 @@ use gtk::{
     CompositeTemplate,
 };
 use log::error;
-use matrix_sdk::room::Room as MatrixRoom;
+use matrix_sdk::RoomState;
 use ruma::{
     assign,
     events::{
@@ -238,10 +238,11 @@ impl GeneralPage {
 
     async fn change_avatar(&self, file: gio::File) {
         let room = self.room();
-        let MatrixRoom::Joined(matrix_room) = room.matrix_room() else {
+        let matrix_room = room.matrix_room();
+        if matrix_room.state() != RoomState::Joined {
             error!("Cannot change avatar of room not joined");
             return;
-        };
+        }
 
         let imp = self.imp();
         let avatar = &imp.avatar;
@@ -300,10 +301,11 @@ impl GeneralPage {
 
     async fn remove_avatar(&self) {
         let room = self.room();
-        let MatrixRoom::Joined(matrix_room) = room.matrix_room() else {
+        let matrix_room = room.matrix_room();
+        if matrix_room.state() != RoomState::Joined {
             error!("Cannot remove avatar of room not joined");
             return;
-        };
+        }
 
         let imp = self.imp();
         let avatar = &*imp.avatar;
@@ -488,10 +490,11 @@ impl GeneralPage {
             return;
         }
 
-        let MatrixRoom::Joined(matrix_room) = room.matrix_room() else {
+        let matrix_room = room.matrix_room();
+        if matrix_room.state() != RoomState::Joined {
             error!("Cannot change name or topic of room not joined");
             return;
-        };
+        }
 
         if name_changed {
             let matrix_room = matrix_room.clone();

src/session/view/content/room_details/history_viewer/timeline.rs

@@ -31,7 +31,7 @@ mod imp {
         sync::Arc,
     };
 
-    use futures::lock::Mutex;
+    use futures_util::lock::Mutex;
     use once_cell::{sync::Lazy, unsync::OnceCell};
 
     use super::*;

src/session/view/content/room_details/invite_subpage/invitee_list.rs

@@ -34,7 +34,7 @@ mod imp {
         collections::HashMap,
     };
 
-    use futures::future::AbortHandle;
+    use futures_util::future::AbortHandle;
     use glib::subclass::Signal;
     use once_cell::{sync::Lazy, unsync::OnceCell};
 
@@ -330,7 +330,7 @@ impl InviteeList {
             client.send(request, None).await
         });
 
-        let (future, handle) = futures::future::abortable(handle);
+        let (future, handle) = futures_util::future::abortable(handle);
 
         if let Some(abort_handle) = self.imp().abort_handle.replace(Some(handle)) {
             abort_handle.abort();

src/session/view/content/room_history/attachment_dialog.rs

@@ -97,7 +97,7 @@ impl AttachmentDialog {
     /// Returns `gtk::ResponseType::Ok` if the user clicked on send, otherwise
     /// returns `gtk::ResponseType::Cancel`.
     pub async fn run_future(&self) -> gtk::ResponseType {
-        let (sender, receiver) = futures::channel::oneshot::channel();
+        let (sender, receiver) = futures_channel::oneshot::channel();
         let sender = Cell::new(Some(sender));
 
         let handler_id = self.connect_close_request(

src/session/view/content/room_history/message_row/content.rs

@@ -140,7 +140,7 @@ impl MessageContent {
                         reply.set_related_content_sender(sender.upcast_ref());
                         build_content(
                             reply.related_content(),
-                            TimelineItemContent::Message(related_content.message().clone()),
+                            related_content.content().clone(),
                             ContentFormat::Compact,
                             sender,
                             &room,

src/session/view/content/room_history/mod.rs

@@ -16,7 +16,7 @@ use ashpd::{
     desktop::location::{Accuracy, LocationProxy},
     WindowIdentifier,
 };
-use futures::TryFutureExt;
+use futures_util::TryFutureExt;
 use geo_uri::GeoUri;
 use gettextrs::gettext;
 use gtk::{
@@ -1036,7 +1036,7 @@ impl RoomHistory {
             // We want to be listening for new locations whenever the session is up
             // otherwise we might lose the first response and will have to wait for a future
             // update by geoclue
-            let (_, location) = futures::try_join!(
+            let (_, location) = futures_util::try_join!(
                 proxy.start(&session, &identifier).into_future(),
                 proxy.receive_location_updated().into_future()
             )?;

src/session/view/create_dm_dialog/dm_user.rs

@@ -150,7 +150,7 @@ impl DmUser {
 async fn create_dm(
     client: matrix_sdk::Client,
     other_user: ruma::OwnedUserId,
-) -> Result<matrix_sdk::room::Joined, matrix_sdk::Error> {
+) -> Result<matrix_sdk::Room, matrix_sdk::Error> {
     let request = assign!(create_room::v3::Request::new(),
     {
         is_direct: true,

src/session/view/create_dm_dialog/dm_user_list.rs

@@ -27,7 +27,7 @@ mod imp {
         collections::HashMap,
     };
 
-    use futures::future::AbortHandle;
+    use futures_util::future::AbortHandle;
     use once_cell::sync::Lazy;
 
     use super::*;
@@ -187,7 +187,7 @@ impl DmUserList {
         let search_term_clone = search_term.clone();
         let handle = spawn_tokio!(async move { client.search_users(&search_term_clone, 20).await });
 
-        let (future, handle) = futures::future::abortable(handle);
+        let (future, handle) = futures_util::future::abortable(handle);
 
         if let Some(abort_handle) = self.imp().abort_handle.replace(Some(handle)) {
             abort_handle.abort();

src/utils/media.rs

@@ -125,7 +125,7 @@ async fn get_gstreamer_media_info(file: &gio::File) -> Option<gst_pbutils::Disco
     let timeout = gst::ClockTime::from_seconds(15);
     let discoverer = gst_pbutils::Discoverer::new(timeout).ok()?;
 
-    let (sender, receiver) = futures::channel::oneshot::channel();
+    let (sender, receiver) = futures_channel::oneshot::channel();
     let sender = Mutex::new(Cell::new(Some(sender)));
     discoverer.connect_discovered(move |_, info, _| {
         if let Some(sender) = sender.lock().unwrap().take() {

src/utils/mod.rs

@@ -13,7 +13,7 @@ use std::{
     rc::{Rc, Weak},
 };
 
-use futures::{
+use futures_util::{
     future::{self, Either, Future},
     pin_mut,
 };