Handle matrix.to room alias and room ID links.

src/home/room_screen.rs

@@ -19,14 +19,15 @@ use matrix_sdk_ui::timeline::{
 };
 
 use crate::{
-    app::RoomsPanelRestoreAction, avatar_cache, event_preview::{plaintext_body_of_timeline_item, text_preview_of_encrypted_message, text_preview_of_member_profile_change, text_preview_of_other_state, text_preview_of_redacted_message, text_preview_of_room_membership_change, text_preview_of_timeline_item}, home::{edited_indicator::EditedIndicatorWidgetRefExt, editing_pane::EditingPaneState, loading_pane::{LoadingPaneState, LoadingPaneWidgetExt}, rooms_list::RoomsListRef}, location::init_location_subscriber, media_cache::{MediaCache, MediaCacheEntry}, profile::{
+    app::{RoomsPanelRestoreAction, SelectedRoom}, avatar_cache, event_preview::{plaintext_body_of_timeline_item, text_preview_of_encrypted_message, text_preview_of_member_profile_change, text_preview_of_other_state, text_preview_of_redacted_message, text_preview_of_room_membership_change, text_preview_of_timeline_item}, home::{edited_indicator::EditedIndicatorWidgetRefExt, editing_pane::EditingPaneState, loading_pane::{LoadingPaneState, LoadingPaneWidgetExt}, rooms_list::{RoomsListAction, RoomsListRef}}, location::init_location_subscriber, media_cache::{MediaCache, MediaCacheEntry}, profile::{
         user_profile::{AvatarState, ShowUserProfileAction, UserProfile, UserProfileAndRoomId, UserProfilePaneInfo, UserProfileSlidingPaneRef, UserProfileSlidingPaneWidgetExt},
         user_profile_cache,
     }, shared::{
         avatar::AvatarWidgetRefExt, callout_tooltip::TooltipAction, html_or_plaintext::{HtmlOrPlaintextRef, HtmlOrPlaintextWidgetRefExt, RobrixHtmlLinkAction}, jump_to_bottom_button::{JumpToBottomButtonWidgetExt, UnreadMessageCount}, popup_list::{enqueue_popup_notification, PopupItem}, styles::COLOR_DANGER_RED, text_or_image::{TextOrImageRef, TextOrImageWidgetRefExt}, timestamp::TimestampWidgetRefExt, typing_animation::TypingAnimationWidgetExt
     }, sliding_sync::{get_client, submit_async_request, take_timeline_endpoints, BackwardsPaginateUntilEventRequest, MatrixRequest, PaginationDirection, TimelineRequestSender, UserPowerLevels}, utils::{self, room_name_or_id, unix_time_millis_to_datetime, ImageFormat, MEDIA_THUMBNAIL_FORMAT}
 };
 use crate::home::event_reaction_list::ReactionListWidgetRefExt;
+use crate::room::ResolveRoomAliasAction;
 use crate::home::room_read_receipt::AvatarRowWidgetRefExt;
 use crate::room::room_input_bar::RoomInputBarWidgetExt;
 use crate::shared::mentionable_text_input::MentionableTextInputWidgetRefExt;
@@ -995,6 +996,43 @@ impl Widget for RoomScreen {
                         );
                     }
                 }
+
+                // Handle resolved room alias actions - only for requests from this widget
+                if let Some(ResolveRoomAliasAction::Resolved { requester_uid, room_alias: _ , room_id, servers: _ }) = action.downcast_ref() {
+                    // Only handle this action if it was requested by this widget
+                    if *requester_uid == room_screen_widget_uid {
+                        if let Some(known_room) = get_client().and_then(|c| c.get_room(room_id)) {
+                            if known_room.is_space() {
+                                enqueue_popup_notification(PopupItem {
+                                    message: format!("Found space {} but it is a space, not a regular room.", room_id),
+                                    auto_dismissal_duration: Some(3.0)
+                                });
+                            } else {
+                                cx.widget_action(room_screen_widget_uid, &scope.path, RoomsListAction::Selected(
+                                    SelectedRoom::JoinedRoom {
+                                        room_id: room_id.clone().into(),
+                                        room_name: known_room.name()
+                                    }
+                                ));
+                            }
+                        } else {
+                            enqueue_popup_notification(PopupItem {
+                                message: format!("Found room {} but you are not joined to it yet.", room_id),
+                                auto_dismissal_duration: Some(3.0)
+                            });
+                        }
+                    }
+                }
+
+                if let Some(ResolveRoomAliasAction::Failed { requester_uid, room_alias, error }) = action.downcast_ref() {
+                    if *requester_uid == room_screen_widget_uid {
+                        error!("Failed to resolve room alias {}: {:?}", room_alias, error);
+                        enqueue_popup_notification(PopupItem {
+                            message: format!("Could not find room with alias: {}", room_alias),
+                            auto_dismissal_duration: None
+                        });
+                    }
+                }
             }
 
             /*
@@ -1731,6 +1769,7 @@ impl RoomScreen {
         action: &Action,
         pane: &UserProfileSlidingPaneRef,
     ) -> bool {
+        let uid = self.widget_uid();
         // A closure that handles both MatrixToUri and MatrixUri links,
         // and returns whether the link was handled.
         let mut handle_matrix_link = |id: &MatrixId, _via: &[OwnedServerName]| -> bool {
@@ -1763,26 +1802,59 @@ impl RoomScreen {
                 }
                 MatrixId::Room(room_id) => {
                     if self.room_id.as_ref() == Some(room_id) {
-                        enqueue_popup_notification(PopupItem { 
-                            message: "You are already viewing that room.".into(), 
-                            auto_dismissal_duration: None 
+                        enqueue_popup_notification(PopupItem {
+                            message: "You are already viewing that room.".into(),
+                            auto_dismissal_duration: Some(3.0)
                         });
                         return true;
                     }
-                    if let Some(_known_room) = get_client().and_then(|c| c.get_room(room_id)) {
-                        log!("TODO: jump to known room {}", room_id);
+                    if let Some(known_room) = get_client().and_then(|c| c.get_room(room_id)) {
+                        cx.widget_action(uid, &Scope::empty().path, RoomsListAction::Selected(
+                            SelectedRoom::JoinedRoom {
+                                room_id: room_id.clone().into(),
+                                room_name: known_room.name()
+                            }
+                        ));
                     } else {
-                        log!("TODO: fetch and display room preview for room {}", room_id);
+                        // TODO: fetch and display a room preview for the given room ID.
+                        enqueue_popup_notification(PopupItem {
+                            message: "You are not joined to this room yet.".into(),
+                            auto_dismissal_duration: Some(3.0)
+                        });
                     }
-                    false
+                    true
                 }
                 MatrixId::RoomAlias(room_alias) => {
-                    log!("TODO: open room alias {}", room_alias);
-                    // TODO: open a room loading screen that shows a spinner
-                    //       while our background async task calls Client::resolve_room_alias()
-                    //       and then either jumps to the room if known, or fetches and displays
-                    //       a room preview for that room.
-                    false
+                    // Check if we already have this room alias in the client
+                    if let Some(known_room) = get_client().and_then(|c| {
+                        c.rooms().into_iter().find(|room| {
+                            room.canonical_alias().as_ref() == Some(room_alias) ||
+                            room.alt_aliases().contains(room_alias)
+                        })
+                    }) {
+                        let room_id = known_room.room_id();
+                        if self.room_id.as_ref() == Some(&room_id.to_owned()) {
+                            enqueue_popup_notification(PopupItem {
+                                message: "You are already viewing that room.".into(),
+                                auto_dismissal_duration: Some(3.0)
+                            });
+                        } else {
+                            cx.widget_action(uid, &Scope::empty().path, RoomsListAction::Selected(
+                                SelectedRoom::JoinedRoom {
+                                    room_id: room_id.to_owned().into(),
+                                    room_name: known_room.name()
+                                }
+                            ));
+                        }
+                        return true;
+                    }
+                    // TODO: open a room loading screen that shows a spinner.
+                    // Submit async request to resolve the room alias
+                    submit_async_request(MatrixRequest::ResolveRoomAlias {
+                        room_alias: room_alias.clone(),
+                        requester_uid: uid,
+                    });
+                    true
                 }
                 MatrixId::Event(room_id, event_id) => {
                     log!("TODO: open event {} in room {}", event_id, room_id);
@@ -1795,15 +1867,10 @@ impl RoomScreen {
             }
         };
 
-        if let HtmlLinkAction::Clicked { url, .. } = action.as_widget_action().cast() {
-            let mut link_was_handled = false;
-            if let Ok(matrix_to_uri) = MatrixToUri::parse(&url) {
-                link_was_handled |= handle_matrix_link(matrix_to_uri.id(), matrix_to_uri.via());
-            }
-            else if let Ok(matrix_uri) = MatrixUri::parse(&url) {
-                link_was_handled |= handle_matrix_link(matrix_uri.id(), matrix_uri.via());
-            }
-
+        // Prioritize handling RobrixHtmlLinkAction::ClickedMatrixLink over HtmlLinkAction::Clicked
+        // to avoid duplicate processing of the same Matrix link
+        if let RobrixHtmlLinkAction::ClickedMatrixLink { url, matrix_id, via, .. } = action.as_widget_action().cast() {
+            let link_was_handled = handle_matrix_link(&matrix_id, &via);
             if !link_was_handled {
                 log!("Opening URL \"{}\"", url);
                 if let Err(e) = robius_open::Uri::new(&url).open() {
@@ -1816,8 +1883,15 @@ impl RoomScreen {
             }
             true
         }
-        else if let RobrixHtmlLinkAction::ClickedMatrixLink { url, matrix_id, via, .. } = action.as_widget_action().cast() {
-            let link_was_handled = handle_matrix_link(&matrix_id, &via);
+        else if let HtmlLinkAction::Clicked { url, .. } = action.as_widget_action().cast() {
+            let mut link_was_handled = false;
+            if let Ok(matrix_to_uri) = MatrixToUri::parse(&url) {
+                link_was_handled |= handle_matrix_link(matrix_to_uri.id(), matrix_to_uri.via());
+            }
+            else if let Ok(matrix_uri) = MatrixUri::parse(&url) {
+                link_was_handled |= handle_matrix_link(matrix_uri.id(), matrix_uri.via());
+            }
+
             if !link_was_handled {
                 log!("Opening URL \"{}\"", url);
                 if let Err(e) = robius_open::Uri::new(&url).open() {

src/room/mod.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
-use makepad_widgets::Cx;
-use matrix_sdk::ruma::OwnedRoomId;
+use makepad_widgets::{Cx, WidgetUid};
+use matrix_sdk::{ruma::{OwnedRoomAliasId, OwnedRoomId}, OwnedServerName};
 
 pub mod room_input_bar;
 pub mod room_member_manager;
@@ -10,6 +10,22 @@ pub fn live_design(cx: &mut Cx) {
     room_input_bar::live_design(cx)
 }
 
+/// Actions sent from the backend task as a result of a [`MatrixRequest::ResolveRoomAlias`].
+#[derive(Debug)]
+pub enum ResolveRoomAliasAction {
+    Resolved {
+        requester_uid: WidgetUid,
+        room_alias: OwnedRoomAliasId,
+        room_id: OwnedRoomId,
+        servers: Vec<OwnedServerName>,
+    },
+    Failed {
+        requester_uid: WidgetUid,
+        room_alias: OwnedRoomAliasId,
+        error: matrix_sdk::Error,
+    }
+}
+
 /// Basic details about a room, used for displaying a preview of it.
 #[derive(Clone, Debug)]
 pub struct BasicRoomDetails {

src/sliding_sync.rs

@@ -5,7 +5,7 @@ use eyeball::Subscriber;
 use eyeball_im::VectorDiff;
 use futures_util::{pin_mut, StreamExt};
 use imbl::Vector;
-use makepad_widgets::{error, log, warning, Cx, SignalToUI};
+use makepad_widgets::{error, log, warning, Cx, SignalToUI, WidgetUid};
 use matrix_sdk::{
     config::RequestConfig, encryption::EncryptionSettings, event_handler::EventHandlerDropGuard, media::MediaRequestParameters, room::{edit::EditedContent, reply::Reply, RoomMember}, ruma::{
         api::client::receipt::create_receipt::v3::ReceiptType, events::{
@@ -33,7 +33,7 @@ use crate::{
     }, login::login_screen::LoginAction, media_cache::{MediaCacheEntry, MediaCacheEntryRef}, persistent_state::{self, load_rooms_panel_state, ClientSessionPersisted}, profile::{
         user_profile::{AvatarState, UserProfile},
         user_profile_cache::{enqueue_user_profile_update, UserProfileUpdate},
-    }, room::RoomPreviewAvatar, shared::{html_or_plaintext::MatrixLinkPillState, jump_to_bottom_button::UnreadMessageCount, popup_list::{enqueue_popup_notification, PopupItem}}, utils::{self, AVATAR_THUMBNAIL_FORMAT}, verification::add_verification_event_handlers_and_sync_client
+    }, room::{ResolveRoomAliasAction, RoomPreviewAvatar}, shared::{html_or_plaintext::MatrixLinkPillState, jump_to_bottom_button::UnreadMessageCount, popup_list::{enqueue_popup_notification, PopupItem}}, utils::{self, AVATAR_THUMBNAIL_FORMAT}, verification::add_verification_event_handlers_and_sync_client
 };
 
 #[derive(Parser, Debug, Default)]
@@ -295,7 +295,10 @@ pub enum MatrixRequest {
         room_id: OwnedRoomId,
     },
     /// Request to resolve a room alias into a room ID and the servers that know about that room.
-    ResolveRoomAlias(OwnedRoomAliasId),
+    ResolveRoomAlias {
+        requester_uid: WidgetUid,
+        room_alias: OwnedRoomAliasId,
+    },
     /// Request to fetch an Avatar image from the server.
     /// Upon completion of the async media request, the `on_fetched` function
     /// will be invoked with the content of an `AvatarUpdate`.
@@ -898,13 +901,28 @@ async fn async_worker(
             MatrixRequest::SpawnSSOServer { brand, homeserver_url, identity_provider_id} => {
                 spawn_sso_server(brand, homeserver_url, identity_provider_id, login_sender.clone()).await;
             }
-            MatrixRequest::ResolveRoomAlias(room_alias) => {
+            MatrixRequest::ResolveRoomAlias { room_alias, requester_uid } => {
                 let Some(client) = CLIENT.get() else { continue };
                 let _resolve_task = Handle::current().spawn(async move {
                     log!("Sending resolve room alias request for {room_alias}...");
-                    let res = client.resolve_room_alias(&room_alias).await;
-                    log!("Resolved room alias {room_alias} to: {res:?}");
-                    todo!("Send the resolved room alias back to the UI thread somehow.");
+                    let result_action = match client.resolve_room_alias(&room_alias).await {
+                        Ok(response) => {
+                            ResolveRoomAliasAction::Resolved {
+                                requester_uid,
+                                room_alias,
+                                room_id: response.room_id,
+                                servers: response.servers
+                            }
+                        }
+                        Err(e) => {
+                            ResolveRoomAliasAction::Failed {
+                                requester_uid,
+                                room_alias,
+                                error: e.into()
+                            }
+                        }
+                    };
+                    Cx::post_action(result_action);
                 });
             }
             MatrixRequest::FetchAvatar { mxc_uri, on_fetched } => {