Use awaitRoom on Timeline screen

vector/src/main/java/im/vector/app/features/home/room/detail/TimelineFragment.kt

@@ -213,6 +213,7 @@ import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withContext
 import org.billcarsonfr.jsonviewer.JSonViewerDialog
 import org.commonmark.parser.Parser
@@ -381,18 +382,20 @@ class TimelineFragment @Inject constructor(
         )
         keyboardStateUtils = KeyboardStateUtils(requireActivity())
         lazyLoadedViews.bind(views)
-        setupToolbar(views.roomToolbar)
+        viewLifecycleOwner.lifecycleScope.launch {
-                .allowBack()
+            setupToolbar(views.roomToolbar)
-        setupRecyclerView()
+                    .allowBack()
-        setupComposer()
+            setupRecyclerView()
-        setupNotificationView()
+            setupComposer()
-        setupJumpToReadMarkerView()
+            setupNotificationView()
-        setupActiveCallView()
+            setupJumpToReadMarkerView()
-        setupJumpToBottomView()
+            setupActiveCallView()
-        setupEmojiButton()
+            setupJumpToBottomView()
-        setupRemoveJitsiWidgetView()
+            setupEmojiButton()
-        setupVoiceMessageView()
+            setupRemoveJitsiWidgetView()
-        setupLiveLocationIndicator()
+            setupVoiceMessageView()
+            setupLiveLocationIndicator()
+        }
 
         views.includeRoomToolbar.roomToolbarContentView.debouncedClicks {
             navigator.openRoomProfile(requireActivity(), timelineArgs.roomId)
@@ -979,16 +982,17 @@ class TimelineFragment @Inject constructor(
     private fun setupJumpToBottomView() {
         views.jumpToBottomView.visibility = View.INVISIBLE
         views.jumpToBottomView.debouncedClicks {
-            timelineViewModel.handle(RoomDetailAction.ExitTrackingUnreadMessagesState)
+            viewLifecycleOwner.lifecycleScope.launch {
-            views.jumpToBottomView.visibility = View.INVISIBLE
+                timelineViewModel.handle(RoomDetailAction.ExitTrackingUnreadMessagesState)
-            if (!timelineViewModel.timeline.isLive) {
+                views.jumpToBottomView.visibility = View.INVISIBLE
-                scrollOnNewMessageCallback.forceScrollOnNextUpdate()
+                if (!timelineViewModel.timeline.await().isLive) {
-                timelineViewModel.timeline.restartWithEventId(null)
+                    scrollOnNewMessageCallback.forceScrollOnNextUpdate()
-            } else {
+                    timelineViewModel.timeline.await().restartWithEventId(null)
-                layoutManager.scrollToPosition(0)
+                } else {
+                    layoutManager.scrollToPosition(0)
+                }
             }
         }
-
         jumpToBottomViewVisibilityManager = JumpToBottomViewVisibilityManager(
                 views.jumpToBottomView,
                 debouncer,
@@ -1216,12 +1220,14 @@ class TimelineFragment @Inject constructor(
     }
 
     private fun handleSearchAction() {
-        navigator.openSearch(
+        viewLifecycleOwner.lifecycleScope.launch {
-                context = requireContext(),
+            navigator.openSearch(
-                roomId = timelineArgs.roomId,
+                    context = requireContext(),
-                roomDisplayName = timelineViewModel.getRoomSummary()?.displayName,
+                    roomId = timelineArgs.roomId,
-                roomAvatarUrl = timelineViewModel.getRoomSummary()?.avatarUrl
+                    roomDisplayName = timelineViewModel.getRoomSummary()?.displayName,
-        )
+                    roomAvatarUrl = timelineViewModel.getRoomSummary()?.avatarUrl
+            )
+        }
     }
 
     private fun displayDisabledIntegrationDialog() {
@@ -1416,9 +1422,9 @@ class TimelineFragment @Inject constructor(
 
 // PRIVATE METHODS *****************************************************************************
 
-    private fun setupRecyclerView() {
+    private suspend fun setupRecyclerView() {
         timelineEventController.callback = this
-        timelineEventController.timeline = timelineViewModel.timeline
+        timelineEventController.timeline = timelineViewModel.timeline.await()
 
         views.timelineRecyclerView.trackItemsVisibilityChange()
         layoutManager = object : LinearLayoutManager(context, RecyclerView.VERTICAL, true) {
@@ -2421,7 +2427,9 @@ class TimelineFragment @Inject constructor(
             views.composerLayout.views.composerEditText.setText(Command.EMOTE.command + " ")
             views.composerLayout.views.composerEditText.setSelection(Command.EMOTE.command.length + 1)
         } else {
-            val roomMember = timelineViewModel.getMember(userId)
+            val roomMember = runBlocking {
+                timelineViewModel.getMember(userId)
+            }
             // TODO move logic outside of fragment
             (roomMember?.displayName ?: userId)
                     .let { sanitizeDisplayName(it) }
@@ -2491,18 +2499,21 @@ class TimelineFragment @Inject constructor(
      * using the ThreadsActivity.
      */
     private fun navigateToThreadTimeline(rootThreadEventId: String, startsThread: Boolean = false, showKeyboard: Boolean = false) {
-        analyticsTracker.capture(Interaction.Name.MobileRoomThreadSummaryItem.toAnalyticsInteraction())
+        viewLifecycleOwner.lifecycleScope.launch {
-        context?.let {
+            analyticsTracker.capture(Interaction.Name.MobileRoomThreadSummaryItem.toAnalyticsInteraction())
-            val roomThreadDetailArgs = ThreadTimelineArgs(
+            context?.let {
-                    startsThread = startsThread,
+                val roomSummary = timelineViewModel.awaitState().asyncRoomSummary()
-                    roomId = timelineArgs.roomId,
+                val roomThreadDetailArgs = ThreadTimelineArgs(
-                    displayName = timelineViewModel.getRoomSummary()?.displayName,
+                        startsThread = startsThread,
-                    avatarUrl = timelineViewModel.getRoomSummary()?.avatarUrl,
+                        roomId = timelineArgs.roomId,
-                    roomEncryptionTrustLevel = timelineViewModel.getRoomSummary()?.roomEncryptionTrustLevel,
+                        displayName = roomSummary?.displayName,
-                    rootThreadEventId = rootThreadEventId,
+                        avatarUrl = roomSummary?.avatarUrl,
-                    showKeyboard = showKeyboard
+                        roomEncryptionTrustLevel = roomSummary?.roomEncryptionTrustLevel,
-            )
+                        rootThreadEventId = rootThreadEventId,
-            navigator.openThread(it, roomThreadDetailArgs)
+                        showKeyboard = showKeyboard
+                )
+                navigator.openThread(it, roomThreadDetailArgs)
+            }
         }
     }
 
@@ -2530,15 +2541,18 @@ class TimelineFragment @Inject constructor(
      * using the ThreadsActivity.
      */
     private fun navigateToThreadList() {
-        analyticsTracker.capture(Interaction.Name.MobileRoomThreadListButton.toAnalyticsInteraction())
+        viewLifecycleOwner.lifecycleScope.launch {
-        context?.let {
+            analyticsTracker.capture(Interaction.Name.MobileRoomThreadListButton.toAnalyticsInteraction())
-            val roomThreadDetailArgs = ThreadTimelineArgs(
+            context?.let {
-                    roomId = timelineArgs.roomId,
+                val roomSummary = timelineViewModel.awaitState().asyncRoomSummary()
-                    displayName = timelineViewModel.getRoomSummary()?.displayName,
+                val roomThreadDetailArgs = ThreadTimelineArgs(
-                    roomEncryptionTrustLevel = timelineViewModel.getRoomSummary()?.roomEncryptionTrustLevel,
+                        roomId = timelineArgs.roomId,
-                    avatarUrl = timelineViewModel.getRoomSummary()?.avatarUrl
+                        displayName = roomSummary?.displayName,
-            )
+                        roomEncryptionTrustLevel = roomSummary?.roomEncryptionTrustLevel,
-            navigator.openThreadList(it, roomThreadDetailArgs)
+                        avatarUrl = roomSummary?.avatarUrl
+                )
+                navigator.openThreadList(it, roomThreadDetailArgs)
+            }
         }
     }
 

vector/src/main/java/im/vector/app/features/home/room/detail/timeline/factory/TimelineFactory.kt

@@ -20,6 +20,7 @@ import im.vector.app.features.call.vectorCallService
 import im.vector.app.features.home.room.detail.timeline.helper.TimelineSettingsFactory
 import im.vector.app.features.home.room.detail.timeline.merged.MergedTimelines
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Deferred
 import org.matrix.android.sdk.api.session.Session
 import org.matrix.android.sdk.api.session.events.model.EventType
 import org.matrix.android.sdk.api.session.getRoom
@@ -36,14 +37,14 @@ private val secondaryTimelineAllowedTypes = listOf(
 
 class TimelineFactory @Inject constructor(private val session: Session, private val timelineSettingsFactory: TimelineSettingsFactory) {
 
-    fun createTimeline(
+    suspend fun createTimeline(
             coroutineScope: CoroutineScope,
-            mainRoom: Room,
+            room: Deferred<Room>,
             eventId: String?,
             rootThreadEventId: String?
     ): Timeline {
         val settings = timelineSettingsFactory.create(rootThreadEventId)
-
+        val mainRoom = room.await()
         if (!session.vectorCallService.protocolChecker.supportVirtualRooms) {
             return mainRoom.timelineService().createTimeline(eventId, settings)
         }

vector/src/main/java/im/vector/app/features/raw/wellknown/ElementWellKnownExt.kt

@@ -47,7 +47,7 @@ fun ElementWellKnown?.getOutboundSessionKeySharingStrategyOrDefault(): OutboundS
 fun RawService.withElementWellKnown(
         coroutineScope: CoroutineScope,
         sessionParams: SessionParams,
-        block: ((ElementWellKnown?) -> Unit)
+        block: suspend ((ElementWellKnown?) -> Unit)
 ) = with(coroutineScope) {
     launch(Dispatchers.IO) {
         block(getElementWellknown(sessionParams))