Threads - first iteration (#5165)

* Initial threads support: parse `ThreadSummary`.

Replace several `isThreaded` values with `EventThreadInfo`, which contains the info about the event either being the root of a thread or part of it.

* Add `Threaded` timeline mode

* Add a `liveTimeline` parameter to `TimelineController`'s  constructor. This way we can customise which timeline will be used as the 'live' one. Also add `@LiveTimeline` DI qualifier for the actual live timeline of the room.

* Create `ThreadedMessagesNode`. Allow opening a thread in a separate screen.

* Add the callbacks for the list menu actions - even if they're the wrong ones and will send the data to the room instead

* Send attachments and location in threads

* Fix polls in threads, add support for sending voice messages in threads

* Display thread summaries only when the feature flag is enabled

* Use 'Reply' instead of 'Reply in thread' when in threaded timeline mode

* Remove incorrect usage of `Timeline` in `MessageComposerPresenter`. This led to replies to threaded events not appearing as actual replies.

---------

Co-authored-by: ElementBot <android@element.io>

features/location/impl/src/main/kotlin/io/element/android/features/location/impl/send/DefaultSendLocationEntryPoint.kt

@@ -13,12 +13,21 @@ import com.squareup.anvil.annotations.ContributesBinding
 import io.element.android.features.location.api.SendLocationEntryPoint
 import io.element.android.libraries.architecture.createNode
 import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.matrix.api.timeline.Timeline
 import javax.inject.Inject
 
 @ContributesBinding(AppScope::class)
 class DefaultSendLocationEntryPoint @Inject constructor() : SendLocationEntryPoint {
-    override fun createNode(
-        parentNode: Node,
-        buildContext: BuildContext
-    ): SendLocationNode = parentNode.createNode(buildContext)
+    override fun builder(timelineMode: Timeline.Mode): SendLocationEntryPoint.Builder {
+        return Builder(timelineMode)
+    }
+
+    class Builder(private val timelineMode: Timeline.Mode) : SendLocationEntryPoint.Builder {
+        override fun build(parentNode: Node, buildContext: BuildContext): Node {
+            return parentNode.createNode<SendLocationNode>(
+                buildContext = buildContext,
+                plugins = listOf(SendLocationNode.Inputs(timelineMode))
+            )
+        }
+    }
 }

features/location/impl/src/main/kotlin/io/element/android/features/location/impl/send/SendLocationNode.kt

@@ -17,16 +17,25 @@ import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import im.vector.app.features.analytics.plan.MobileScreen
 import io.element.android.anvilannotations.ContributesNode
+import io.element.android.libraries.architecture.NodeInputs
+import io.element.android.libraries.architecture.inputs
 import io.element.android.libraries.di.RoomScope
+import io.element.android.libraries.matrix.api.timeline.Timeline
 import io.element.android.services.analytics.api.AnalyticsService
 
 @ContributesNode(RoomScope::class)
 class SendLocationNode @AssistedInject constructor(
     @Assisted buildContext: BuildContext,
     @Assisted plugins: List<Plugin>,
-    private val presenter: SendLocationPresenter,
+    presenterFactory: SendLocationPresenter.Factory,
     analyticsService: AnalyticsService,
 ) : Node(buildContext, plugins = plugins) {
+    data class Inputs(
+        val timelineMode: Timeline.Mode,
+    ) : NodeInputs
+
+    private val presenter = presenterFactory.create(inputs<Inputs>().timelineMode)
+
     init {
         lifecycle.subscribe(
             onResume = {

features/location/impl/src/main/kotlin/io/element/android/features/location/impl/send/SendLocationPresenter.kt

@@ -15,6 +15,9 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
 import im.vector.app.features.analytics.plan.Composer
 import io.element.android.features.location.impl.common.MapDefaults
 import io.element.android.features.location.impl.common.actions.LocationActions
@@ -23,22 +26,30 @@ import io.element.android.features.location.impl.common.permissions.PermissionsP
 import io.element.android.features.location.impl.common.permissions.PermissionsState
 import io.element.android.features.messages.api.MessageComposerContext
 import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.core.extensions.flatMap
 import io.element.android.libraries.core.meta.BuildMeta
+import io.element.android.libraries.matrix.api.room.CreateTimelineParams
 import io.element.android.libraries.matrix.api.room.JoinedRoom
 import io.element.android.libraries.matrix.api.room.location.AssetType
+import io.element.android.libraries.matrix.api.timeline.Timeline
 import io.element.android.libraries.textcomposer.model.MessageComposerMode
 import io.element.android.services.analytics.api.AnalyticsService
 import kotlinx.coroutines.launch
-import javax.inject.Inject
 
-class SendLocationPresenter @Inject constructor(
+class SendLocationPresenter @AssistedInject constructor(
     permissionsPresenterFactory: PermissionsPresenter.Factory,
     private val room: JoinedRoom,
+    @Assisted private val timelineMode: Timeline.Mode,
     private val analyticsService: AnalyticsService,
     private val messageComposerContext: MessageComposerContext,
     private val locationActions: LocationActions,
     private val buildMeta: BuildMeta,
 ) : Presenter<SendLocationState> {
+    @AssistedFactory
+    interface Factory {
+        fun create(timelineMode: Timeline.Mode): SendLocationPresenter
+    }
+
     private val permissionsPresenter = permissionsPresenterFactory.create(MapDefaults.permissions)
 
     @Composable
@@ -104,14 +115,16 @@ class SendLocationPresenter @Inject constructor(
         when (mode) {
             SendLocationState.Mode.PinLocation -> {
                 val geoUri = event.cameraPosition.toGeoUri()
-                room.liveTimeline.sendLocation(
-                    body = generateBody(geoUri),
-                    geoUri = geoUri,
-                    description = null,
-                    zoomLevel = MapDefaults.DEFAULT_ZOOM.toInt(),
-                    assetType = AssetType.PIN,
-                    inReplyToEventId = inReplyToEventId,
-                )
+                getTimeline().flatMap {
+                    it.sendLocation(
+                        body = generateBody(geoUri),
+                        geoUri = geoUri,
+                        description = null,
+                        zoomLevel = MapDefaults.DEFAULT_ZOOM.toInt(),
+                        assetType = AssetType.PIN,
+                        inReplyToEventId = inReplyToEventId,
+                    )
+                }
                 analyticsService.capture(
                     Composer(
                         inThread = messageComposerContext.composerMode.inThread,
@@ -123,14 +136,16 @@ class SendLocationPresenter @Inject constructor(
             }
             SendLocationState.Mode.SenderLocation -> {
                 val geoUri = event.toGeoUri()
-                room.liveTimeline.sendLocation(
-                    body = generateBody(geoUri),
-                    geoUri = geoUri,
-                    description = null,
-                    zoomLevel = MapDefaults.DEFAULT_ZOOM.toInt(),
-                    assetType = AssetType.SENDER,
-                    inReplyToEventId = inReplyToEventId,
-                )
+                getTimeline().flatMap {
+                    it.sendLocation(
+                        body = generateBody(geoUri),
+                        geoUri = geoUri,
+                        description = null,
+                        zoomLevel = MapDefaults.DEFAULT_ZOOM.toInt(),
+                        assetType = AssetType.SENDER,
+                        inReplyToEventId = inReplyToEventId,
+                    )
+                }
                 analyticsService.capture(
                     Composer(
                         inThread = messageComposerContext.composerMode.inThread,
@@ -142,6 +157,13 @@ class SendLocationPresenter @Inject constructor(
             }
         }
     }
+
+    private suspend fun getTimeline(): Result<Timeline> {
+        return when (timelineMode) {
+            is Timeline.Mode.Thread -> room.createTimeline(CreateTimelineParams.Threaded(timelineMode.threadRootId))
+            else -> Result.success(room.liveTimeline)
+        }
+    }
 }
 
 private fun SendLocationEvents.SendLocation.toGeoUri(): String = location?.toGeoUri() ?: cameraPosition.toGeoUri()

features/location/impl/src/test/kotlin/io/element/android/features/location/impl/send/SendLocationPresenterTest.kt

@@ -23,6 +23,7 @@ import io.element.android.features.messages.test.FakeMessageComposerContext
 import io.element.android.libraries.matrix.api.core.EventId
 import io.element.android.libraries.matrix.api.room.JoinedRoom
 import io.element.android.libraries.matrix.api.room.location.AssetType
+import io.element.android.libraries.matrix.api.timeline.Timeline
 import io.element.android.libraries.matrix.api.timeline.item.event.toEventOrTransactionId
 import io.element.android.libraries.matrix.test.AN_EVENT_ID
 import io.element.android.libraries.matrix.test.core.aBuildMeta
@@ -55,6 +56,7 @@ class SendLocationPresenterTest {
             override fun create(permissions: List<String>): PermissionsPresenter = fakePermissionsPresenter
         },
         room = joinedRoom,
+        timelineMode = Timeline.Mode.Live,
         analyticsService = fakeAnalyticsService,
         messageComposerContext = fakeMessageComposerContext,
         locationActions = fakeLocationActions,