Format and cleanup files

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/forward/ForwardMessagesPresenter.kt

@@ -29,7 +29,6 @@ import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.matrix.api.core.EventId
 import io.element.android.libraries.matrix.api.core.RoomId
-import io.element.android.libraries.matrix.api.room.MatrixRoom
 import io.element.android.libraries.matrix.api.timeline.TimelineProvider
 import io.element.android.libraries.matrix.api.timeline.getActiveTimeline
 import kotlinx.collections.immutable.ImmutableList

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/TimelineController.kt

@@ -53,7 +53,6 @@ import kotlin.coroutines.cancellation.CancellationException
 class TimelineController @Inject constructor(
     private val room: MatrixRoom,
 ) : Closeable, TimelineProvider {
-
     private val coroutineScope = CoroutineScope(SupervisorJob())
 
     private val liveTimeline = MutableStateFlow(room.liveTimeline)

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/TimelineItemIndexer.kt

@@ -25,7 +25,6 @@ import javax.inject.Inject
 
 @SingleIn(RoomScope::class)
 class TimelineItemIndexer @Inject constructor() {
-
     private val timelineEventsIndexes = mutableMapOf<EventId, Int>()
 
     fun isKnown(eventId: EventId): Boolean {

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/TimelineStateProvider.kt

@@ -71,7 +71,6 @@ fun aPaginationStatus(
     )
 }
 
-
 internal fun aTimelineItemList(content: TimelineItemEventContent): ImmutableList<TimelineItem> {
     return persistentListOf(
         // 3 items (First Middle Last) with isMine = false

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/TimelineView.kt

@@ -93,7 +93,6 @@ fun TimelineView(
     modifier: Modifier = Modifier,
     forceJumpToBottomVisibility: Boolean = false
 ) {
-
     fun clearFocusRequestState() {
         state.eventSink(TimelineEvents.ClearFocusRequestState)
     }
@@ -124,7 +123,6 @@ fun TimelineView(
                 reverseLayout = useReverseLayout,
                 contentPadding = PaddingValues(vertical = 8.dp),
             ) {
-
                 if (state.isLive) {
                     item {
                         TypingNotificationView(state = typingNotificationState)

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/TimelineItemRow.kt

@@ -57,7 +57,6 @@ internal fun TimelineItemRow(
     eventSink: (TimelineEvents.EventFromTimelineItem) -> Unit,
     modifier: Modifier = Modifier
 ) {
-
     val backgroundModifier = if (timelineItem.isEvent(focusedEventId)) {
         Modifier.focusedEvent()
     } else {

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/virtual/TimelineLoadingMoreIndicator.kt

@@ -56,7 +56,6 @@ internal fun TimelineLoadingMoreIndicator(
                 )
             }
         }
-
     }
 }
 

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/TimelineItemsFactory.kt

@@ -34,7 +34,6 @@ import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.persistentListOf
 import kotlinx.collections.immutable.toPersistentList
 import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext

features/messages/impl/src/test/kotlin/io/element/android/features/messages/impl/textcomposer/MessageComposerPresenterTest.kt

@@ -940,7 +940,6 @@ class MessageComposerPresenterTest {
                 .isCalledOnce()
                 .with(any(), any(), any(), any(), value(listOf(Mention.User(A_USER_ID_3))))
 
-
             skipItems(1)
         }
     }

features/messages/impl/src/test/kotlin/io/element/android/features/messages/impl/timeline/TimelinePresenterTest.kt

@@ -33,7 +33,6 @@ import io.element.android.features.poll.api.actions.EndPollAction
 import io.element.android.features.poll.api.actions.SendPollResponseAction
 import io.element.android.features.poll.test.actions.FakeEndPollAction
 import io.element.android.features.poll.test.actions.FakeSendPollResponseAction
-import io.element.android.libraries.featureflag.api.FeatureFlags
 import io.element.android.libraries.featureflag.test.InMemorySessionPreferencesStore
 import io.element.android.libraries.matrix.api.core.EventId
 import io.element.android.libraries.matrix.api.room.MatrixRoomMembersState
@@ -69,7 +68,6 @@ import kotlinx.coroutines.flow.flowOf
 import kotlinx.coroutines.flow.getAndUpdate
 import kotlinx.coroutines.test.StandardTestDispatcher
 import kotlinx.coroutines.test.TestScope
-import kotlinx.coroutines.test.advanceTimeBy
 import kotlinx.coroutines.test.advanceUntilIdle
 import kotlinx.coroutines.test.runCurrent
 import kotlinx.coroutines.test.runTest

features/poll/impl/src/main/kotlin/io/element/android/features/poll/impl/history/PollHistoryPresenter.kt

@@ -32,11 +32,9 @@ import io.element.android.features.poll.impl.history.model.PollHistoryFilter
 import io.element.android.features.poll.impl.history.model.PollHistoryItems
 import io.element.android.features.poll.impl.history.model.PollHistoryItemsFactory
 import io.element.android.libraries.architecture.Presenter
-import io.element.android.libraries.matrix.api.room.MatrixRoom
 import io.element.android.libraries.matrix.api.timeline.Timeline
 import io.element.android.libraries.matrix.api.timeline.TimelineProvider
 import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.flow.flatMapConcat
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.launch
 import javax.inject.Inject

features/poll/impl/src/test/kotlin/io/element/android/features/poll/impl/history/PollHistoryPresenterTest.kt

@@ -63,7 +63,8 @@ class PollHistoryPresenterTest {
             mapOf(
                 AN_EVENT_ID to anOngoingPollContent(),
                 AN_EVENT_ID_2 to anEndedPollContent()
-        )),
+            )
+        ),
         backwardPaginationStatus = backwardPaginationStatus
     )
     private val room = FakeMatrixRoom(

libraries/designsystem/src/main/kotlin/io/element/android/libraries/designsystem/theme/ColorAliases.kt

@@ -153,7 +153,6 @@ val SemanticColors.bigCheckmarkBorderColor
 val SemanticColors.highlightedMessageBackgroundColor
     get() = if (isLight) LightColorTokens.colorGreen300 else DarkColorTokens.colorGreen300
 
-
 @PreviewsDayNight
 @Composable
 internal fun ColorAliasesPreview() = ElementPreview {

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/room/MatrixRoom.kt

@@ -32,9 +32,8 @@ import io.element.android.libraries.matrix.api.poll.PollKind
 import io.element.android.libraries.matrix.api.room.location.AssetType
 import io.element.android.libraries.matrix.api.room.powerlevels.MatrixRoomPowerLevels
 import io.element.android.libraries.matrix.api.room.powerlevels.UserRoleChange
-import io.element.android.libraries.matrix.api.timeline.TimelineProvider
-import io.element.android.libraries.matrix.api.timeline.Timeline
 import io.element.android.libraries.matrix.api.timeline.ReceiptType
+import io.element.android.libraries.matrix.api.timeline.Timeline
 import io.element.android.libraries.matrix.api.widget.MatrixWidgetDriver
 import io.element.android.libraries.matrix.api.widget.MatrixWidgetSettings
 import kotlinx.coroutines.flow.Flow

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/timeline/Timeline.kt

@@ -33,7 +33,6 @@ import kotlinx.coroutines.flow.StateFlow
 import java.io.File
 
 interface Timeline : AutoCloseable {
-
     data class PaginationStatus(
         val isPaginating: Boolean,
         val hasMoreToLoad: Boolean,
@@ -52,7 +51,6 @@ interface Timeline : AutoCloseable {
     fun paginationStatus(direction: PaginationDirection): StateFlow<PaginationStatus>
     val timelineItems: Flow<List<MatrixTimelineItem>>
 
-
     suspend fun sendMessage(body: String, htmlBody: String?, mentions: List<Mention>): Result<Unit>
 
     suspend fun editMessage(originalEventId: EventId?, transactionId: TransactionId?, body: String, htmlBody: String?, mentions: List<Mention>): Result<Unit>
@@ -164,6 +162,4 @@ interface Timeline : AutoCloseable {
         waveform: List<Float>,
         progressCallback: ProgressCallback?
     ): Result<MediaUploadHandler>
-
-
 }

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/timeline/TimelineProvider.kt

@@ -19,11 +19,9 @@ package io.element.android.libraries.matrix.api.timeline
 import com.squareup.anvil.annotations.ContributesBinding
 import io.element.android.libraries.di.RoomScope
 import io.element.android.libraries.matrix.api.room.MatrixRoom
-import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.flow.flowOf
 import javax.inject.Inject
 
 /**
@@ -45,4 +43,3 @@ class LiveTimelineProvider @Inject constructor(
 ) : TimelineProvider {
     override fun activeTimelineFlow(): StateFlow<Timeline> = MutableStateFlow(room.liveTimeline)
 }
-

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/room/RustMatrixRoom.kt

@@ -47,7 +47,6 @@ import io.element.android.libraries.matrix.api.timeline.ReceiptType
 import io.element.android.libraries.matrix.api.timeline.Timeline
 import io.element.android.libraries.matrix.api.widget.MatrixWidgetDriver
 import io.element.android.libraries.matrix.api.widget.MatrixWidgetSettings
-import io.element.android.libraries.matrix.impl.media.MediaUploadHandlerImpl
 import io.element.android.libraries.matrix.impl.notificationsettings.RustNotificationSettingsService
 import io.element.android.libraries.matrix.impl.room.member.RoomMemberListFetcher
 import io.element.android.libraries.matrix.impl.room.member.RoomMemberMapper
@@ -78,14 +77,10 @@ import kotlinx.coroutines.withContext
 import org.matrix.rustcomponents.sdk.RoomInfo
 import org.matrix.rustcomponents.sdk.RoomInfoListener
 import org.matrix.rustcomponents.sdk.RoomListItem
-import org.matrix.rustcomponents.sdk.RoomMessageEventContentWithoutRelation
-import org.matrix.rustcomponents.sdk.SendAttachmentJoinHandle
 import org.matrix.rustcomponents.sdk.TypingNotificationsListener
 import org.matrix.rustcomponents.sdk.UserPowerLevelUpdate
 import org.matrix.rustcomponents.sdk.WidgetCapabilities
 import org.matrix.rustcomponents.sdk.WidgetCapabilitiesProvider
-import org.matrix.rustcomponents.sdk.messageEventContentFromHtml
-import org.matrix.rustcomponents.sdk.messageEventContentFromMarkdown
 import org.matrix.rustcomponents.sdk.use
 import uniffi.matrix_sdk.RoomPowerLevelChanges
 import java.io.File
@@ -634,5 +629,4 @@ class RustMatrixRoom(
             inner = timeline,
         )
     }
-
 }

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/timeline/RustTimeline.kt

@@ -89,17 +89,16 @@ private const val PAGINATION_SIZE = 50
 
 class RustTimeline(
     private val inner: InnerTimeline,
-    private val isLive: Boolean,
+    isLive: Boolean,
-    private val systemClock: SystemClock,
+    systemClock: SystemClock,
-    private val roomCoroutineScope: CoroutineScope,
+    roomCoroutineScope: CoroutineScope,
-    private val isKeyBackupEnabled: Boolean,
+    isKeyBackupEnabled: Boolean,
     private val matrixRoom: MatrixRoom,
     private val dispatcher: CoroutineDispatcher,
-    private val lastLoginTimestamp: Date?,
+    lastLoginTimestamp: Date?,
     private val roomContentForwarder: RoomContentForwarder,
     private val onNewSyncedEvent: () -> Unit,
 ) : Timeline {
-
     private val initLatch = CompletableDeferred<Unit>()
     private val isInit = AtomicBoolean(false)
 
@@ -226,7 +225,6 @@ class RustTimeline(
             }.let { items -> loadingIndicatorsPostProcessor.process(items, hasMoreToLoadBackward, hasMoreToLoadForward) }
             // Keep lastForwardIndicatorsPostProcessor last
             .let { items -> lastForwardIndicatorsPostProcessor.process(items) }
-
     }
 
     override fun close() {

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/timeline/postprocessor/LastForwardIndicatorsPostProcessor.kt

@@ -25,7 +25,6 @@ import io.element.android.libraries.matrix.api.timeline.item.virtual.VirtualTime
 class LastForwardIndicatorsPostProcessor(
     private val isTimelineLive: Boolean,
 ) {
-
     private val lastForwardIdentifiers = LinkedHashSet<String>()
 
     fun process(

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/timeline/postprocessor/LoadingIndicatorsPostProcessor.kt

@@ -22,7 +22,6 @@ import io.element.android.libraries.matrix.api.timeline.item.virtual.VirtualTime
 import io.element.android.services.toolbox.api.systemclock.SystemClock
 
 class LoadingIndicatorsPostProcessor(private val systemClock: SystemClock) {
-
     fun process(
         items: List<MatrixTimelineItem>,
         hasMoreToLoadBackward: Boolean,

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/timeline/postprocessor/RoomBeginningPostProcessor.kt

@@ -29,7 +29,6 @@ import io.element.android.libraries.matrix.api.timeline.item.virtual.VirtualTime
  * or add the RoomBeginning item for non DM room.
  */
 class RoomBeginningPostProcessor {
-
     fun process(
         items: List<MatrixTimelineItem>,
         isDm: Boolean,
@@ -49,7 +48,6 @@ class RoomBeginningPostProcessor {
     }
 
     private fun processForDM(items: List<MatrixTimelineItem>): List<MatrixTimelineItem> {
-
         // Find room creation event. This is usually index 0
         val roomCreationEventIndex = items.indexOfFirst {
             val stateEventContent = (it as? MatrixTimelineItem.Event)?.event?.content as? StateContent
@@ -83,5 +81,4 @@ class RoomBeginningPostProcessor {
             virtual = VirtualTimelineItem.RoomBeginning
         )
     }
-
 }

libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/timeline/FakeTimeline.kt

@@ -32,7 +32,6 @@ import io.element.android.libraries.matrix.api.timeline.MatrixTimelineItem
 import io.element.android.libraries.matrix.api.timeline.ReceiptType
 import io.element.android.libraries.matrix.api.timeline.Timeline
 import io.element.android.libraries.matrix.test.media.FakeMediaUploadHandler
-import io.element.android.tests.testutils.simulateLongTask
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -55,14 +54,37 @@ class FakeTimeline(
     ),
     override val membershipChangeEventReceived: Flow<Unit> = MutableSharedFlow(),
 ) : Timeline {
+    var sendMessageLambda: (
+        body: String,
+        htmlBody: String?,
+        mentions: List<Mention>,
+    ) -> Result<Unit> = { _, _, _ ->
+        Result.success(Unit)
+    }
 
-    var sendMessageLambda: (body: String, htmlBody: String?, mentions: List<Mention>) -> Result<Unit> = { _, _, _ -> Result.success(Unit) }
+    override suspend fun sendMessage(
-    override suspend fun sendMessage(body: String, htmlBody: String?, mentions: List<Mention>): Result<Unit> = sendMessageLambda(body, htmlBody, mentions)
+        body: String,
+        htmlBody: String?,
+        mentions: List<Mention>,
+    ): Result<Unit> = sendMessageLambda(body, htmlBody, mentions)
 
-    var editMessageLambda: (originalEventId: EventId?, transactionId: TransactionId?, body: String, htmlBody: String?, mentions: List<Mention>) -> Result<Unit> =
+    var editMessageLambda: (
-        { _, _, _, _, _ -> Result.success(Unit) }
+        originalEventId: EventId?,
+        transactionId: TransactionId?,
+        body: String,
+        htmlBody: String?,
+        mentions: List<Mention>,
+    ) -> Result<Unit> = { _, _, _, _, _ ->
+        Result.success(Unit)
+    }
 
-    override suspend fun editMessage(originalEventId: EventId?, transactionId: TransactionId?, body: String, htmlBody: String?, mentions: List<Mention>): Result<Unit> = editMessageLambda(
+    override suspend fun editMessage(
+        originalEventId: EventId?,
+        transactionId: TransactionId?,
+        body: String,
+        htmlBody: String?,
+        mentions: List<Mention>,
+    ): Result<Unit> = editMessageLambda(
         originalEventId,
         transactionId,
         body,
@@ -70,23 +92,52 @@ class FakeTimeline(
         mentions
     )
 
-    var enterSpecialModeLambda: (eventId: EventId?) -> Result<Unit> = { Result.success(Unit) }
+    var enterSpecialModeLambda: (eventId: EventId?) -> Result<Unit> = {
+        Result.success(Unit)
+    }
+
     override suspend fun enterSpecialMode(eventId: EventId?): Result<Unit> = enterSpecialModeLambda(eventId)
 
-    var replyMessageLambda: (eventId: EventId, body: String, htmlBody: String?, mentions: List<Mention>) -> Result<Unit> =
+    var replyMessageLambda: (
-        { _, _, _, _ -> Result.success(Unit) }
+        eventId: EventId,
+        body: String,
+        htmlBody: String?,
+        mentions: List<Mention>,
+    ) -> Result<Unit> = { _, _, _, _ ->
+        Result.success(Unit)
+    }
 
-    override suspend fun replyMessage(eventId: EventId, body: String, htmlBody: String?, mentions: List<Mention>): Result<Unit> = replyMessageLambda(
+    override suspend fun replyMessage(
+        eventId: EventId,
+        body: String,
+        htmlBody: String?,
+        mentions: List<Mention>,
+    ): Result<Unit> = replyMessageLambda(
         eventId,
         body,
         htmlBody,
         mentions
     )
 
-    var sendImageLambda: (file: File, thumbnailFile: File?, imageInfo: ImageInfo, body: String?, formattedBody: String?, progressCallback: ProgressCallback?) -> Result<MediaUploadHandler> =
+    var sendImageLambda: (
-        { _, _, _, _, _, _ -> Result.success(FakeMediaUploadHandler()) }
+        file: File,
+        thumbnailFile: File?,
+        imageInfo: ImageInfo,
+        body: String?,
+        formattedBody: String?,
+        progressCallback: ProgressCallback?,
+    ) -> Result<MediaUploadHandler> = { _, _, _, _, _, _ ->
+        Result.success(FakeMediaUploadHandler())
+    }
 
-    override suspend fun sendImage(file: File, thumbnailFile: File?, imageInfo: ImageInfo, body: String?, formattedBody: String?, progressCallback: ProgressCallback?): Result<MediaUploadHandler> = sendImageLambda(
+    override suspend fun sendImage(
+        file: File,
+        thumbnailFile: File?,
+        imageInfo: ImageInfo,
+        body: String?,
+        formattedBody: String?,
+        progressCallback: ProgressCallback?,
+    ): Result<MediaUploadHandler> = sendImageLambda(
         file,
         thumbnailFile,
         imageInfo,
@@ -95,10 +146,25 @@ class FakeTimeline(
         progressCallback
     )
 
-    var sendVideoLambda: (file: File, thumbnailFile: File?, videoInfo: VideoInfo, body: String?, formattedBody: String?, progressCallback: ProgressCallback?) -> Result<MediaUploadHandler> =
+    var sendVideoLambda: (
-        { _, _, _, _, _, _ -> Result.success(FakeMediaUploadHandler()) }
+        file: File,
+        thumbnailFile: File?,
+        videoInfo: VideoInfo,
+        body: String?,
+        formattedBody: String?,
+        progressCallback: ProgressCallback?,
+    ) -> Result<MediaUploadHandler> = { _, _, _, _, _, _ ->
+        Result.success(FakeMediaUploadHandler())
+    }
 
-    override suspend fun sendVideo(file: File, thumbnailFile: File?, videoInfo: VideoInfo, body: String?, formattedBody: String?, progressCallback: ProgressCallback?): Result<MediaUploadHandler> = sendVideoLambda(
+    override suspend fun sendVideo(
+        file: File,
+        thumbnailFile: File?,
+        videoInfo: VideoInfo,
+        body: String?,
+        formattedBody: String?,
+        progressCallback: ProgressCallback?,
+    ): Result<MediaUploadHandler> = sendVideoLambda(
         file,
         thumbnailFile,
         videoInfo,
@@ -107,19 +173,37 @@ class FakeTimeline(
         progressCallback
     )
 
-    var sendAudioLambda: (file: File, audioInfo: AudioInfo, progressCallback: ProgressCallback?) -> Result<MediaUploadHandler> =
+    var sendAudioLambda: (
-        { _, _, _ -> Result.success(FakeMediaUploadHandler()) }
+        file: File,
+        audioInfo: AudioInfo,
+        progressCallback: ProgressCallback?,
+    ) -> Result<MediaUploadHandler> = { _, _, _ ->
+        Result.success(FakeMediaUploadHandler())
+    }
 
-    override suspend fun sendAudio(file: File, audioInfo: AudioInfo, progressCallback: ProgressCallback?): Result<MediaUploadHandler> = sendAudioLambda(
+    override suspend fun sendAudio(
+        file: File,
+        audioInfo: AudioInfo,
+        progressCallback: ProgressCallback?,
+    ): Result<MediaUploadHandler> = sendAudioLambda(
         file,
         audioInfo,
         progressCallback
     )
 
-    var sendFileLambda: (file: File, fileInfo: FileInfo, progressCallback: ProgressCallback?) -> Result<MediaUploadHandler> =
+    var sendFileLambda: (
-        { _, _, _ -> Result.success(FakeMediaUploadHandler()) }
+        file: File,
+        fileInfo: FileInfo,
+        progressCallback: ProgressCallback?,
+    ) -> Result<MediaUploadHandler> = { _, _, _ ->
+        Result.success(FakeMediaUploadHandler())
+    }
 
-    override suspend fun sendFile(file: File, fileInfo: FileInfo, progressCallback: ProgressCallback?): Result<MediaUploadHandler> = sendFileLambda(
+    override suspend fun sendFile(
+        file: File,
+        fileInfo: FileInfo,
+        progressCallback: ProgressCallback?,
+    ): Result<MediaUploadHandler> = sendFileLambda(
         file,
         fileInfo,
         progressCallback
@@ -137,10 +221,23 @@ class FakeTimeline(
     var cancelSendLambda: (transactionId: TransactionId) -> Result<Unit> = { Result.success(Unit) }
     override suspend fun cancelSend(transactionId: TransactionId): Result<Unit> = cancelSendLambda(transactionId)
 
-    var sendLocationLambda: (body: String, geoUri: String, description: String?, zoomLevel: Int?, assetType: AssetType?) -> Result<Unit> =
+    var sendLocationLambda: (
-        { _, _, _, _, _ -> Result.success(Unit) }
+        body: String,
+        geoUri: String,
+        description: String?,
+        zoomLevel: Int?,
+        assetType: AssetType?,
+    ) -> Result<Unit> = { _, _, _, _, _ ->
+        Result.success(Unit)
+    }
 
-    override suspend fun sendLocation(body: String, geoUri: String, description: String?, zoomLevel: Int?, assetType: AssetType?): Result<Unit> = sendLocationLambda(
+    override suspend fun sendLocation(
+        body: String,
+        geoUri: String,
+        description: String?,
+        zoomLevel: Int?,
+        assetType: AssetType?,
+    ): Result<Unit> = sendLocationLambda(
         body,
         geoUri,
         description,
@@ -148,20 +245,44 @@ class FakeTimeline(
         assetType
     )
 
-    var createPollLambda: (question: String, answers: List<String>, maxSelections: Int, pollKind: PollKind) -> Result<Unit> =
+    var createPollLambda: (
-        { _, _, _, _ -> Result.success(Unit) }
+        question: String,
+        answers: List<String>,
+        maxSelections: Int,
+        pollKind: PollKind,
+    ) -> Result<Unit> = { _, _, _, _ ->
+        Result.success(Unit)
+    }
 
-    override suspend fun createPoll(question: String, answers: List<String>, maxSelections: Int, pollKind: PollKind): Result<Unit> = createPollLambda(
+    override suspend fun createPoll(
+        question: String,
+        answers: List<String>,
+        maxSelections: Int,
+        pollKind: PollKind,
+    ): Result<Unit> = createPollLambda(
         question,
         answers,
         maxSelections,
         pollKind
     )
 
-    var editPollLambda: (pollStartId: EventId, question: String, answers: List<String>, maxSelections: Int, pollKind: PollKind) -> Result<Unit> =
+    var editPollLambda: (
-        { _, _, _, _, _ -> Result.success(Unit) }
+        pollStartId: EventId,
+        question: String,
+        answers: List<String>,
+        maxSelections: Int,
+        pollKind: PollKind,
+    ) -> Result<Unit> = { _, _, _, _, _ ->
+        Result.success(Unit)
+    }
 
-    override suspend fun editPoll(pollStartId: EventId, question: String, answers: List<String>, maxSelections: Int, pollKind: PollKind): Result<Unit> = editPollLambda(
+    override suspend fun editPoll(
+        pollStartId: EventId,
+        question: String,
+        answers: List<String>,
+        maxSelections: Int,
+        pollKind: PollKind,
+    ): Result<Unit> = editPollLambda(
         pollStartId,
         question,
         answers,
@@ -169,29 +290,67 @@ class FakeTimeline(
         pollKind
     )
 
-    var sendPollResponseLambda: (pollStartId: EventId, answers: List<String>) -> Result<Unit> = { _, _ -> Result.success(Unit) }
+    var sendPollResponseLambda: (
-    override suspend fun sendPollResponse(pollStartId: EventId, answers: List<String>): Result<Unit> = sendPollResponseLambda(pollStartId, answers)
+        pollStartId: EventId,
+        answers: List<String>,
+    ) -> Result<Unit> = { _, _ ->
+        Result.success(Unit)
+    }
 
-    var endPollLambda: (pollStartId: EventId, text: String) -> Result<Unit> = { _, _ -> Result.success(Unit) }
+    override suspend fun sendPollResponse(
-    override suspend fun endPoll(pollStartId: EventId, text: String): Result<Unit> = endPollLambda(pollStartId, text)
+        pollStartId: EventId,
+        answers: List<String>,
+    ): Result<Unit> = sendPollResponseLambda(pollStartId, answers)
 
-    var sendVoiceMessageLambda: (file: File, audioInfo: AudioInfo, waveform: List<Float>, progressCallback: ProgressCallback?) -> Result<MediaUploadHandler> =
+    var endPollLambda: (
-        { _, _, _, _ -> Result.success(FakeMediaUploadHandler()) }
+        pollStartId: EventId,
+        text: String,
+    ) -> Result<Unit> = { _, _ ->
+        Result.success(Unit)
+    }
 
-    override suspend fun sendVoiceMessage(file: File, audioInfo: AudioInfo, waveform: List<Float>, progressCallback: ProgressCallback?): Result<MediaUploadHandler> = sendVoiceMessageLambda(
+    override suspend fun endPoll(
+        pollStartId: EventId,
+        text: String,
+    ): Result<Unit> = endPollLambda(pollStartId, text)
+
+    var sendVoiceMessageLambda: (
+        file: File,
+        audioInfo: AudioInfo,
+        waveform: List<Float>,
+        progressCallback: ProgressCallback?,
+    ) -> Result<MediaUploadHandler> = { _, _, _, _ ->
+        Result.success(FakeMediaUploadHandler())
+    }
+
+    override suspend fun sendVoiceMessage(
+        file: File,
+        audioInfo: AudioInfo,
+        waveform: List<Float>,
+        progressCallback: ProgressCallback?,
+    ): Result<MediaUploadHandler> = sendVoiceMessageLambda(
         file,
         audioInfo,
         waveform,
         progressCallback
     )
 
-    var sendReadReceiptLambda: (eventId: EventId, receiptType: ReceiptType) -> Result<Unit> = { _, _ -> Result.success(Unit) }
+    var sendReadReceiptLambda: (
+        eventId: EventId,
+        receiptType: ReceiptType,
+    ) -> Result<Unit> = { _, _ ->
+        Result.success(Unit)
+    }
+
     override suspend fun sendReadReceipt(
         eventId: EventId,
         receiptType: ReceiptType,
     ): Result<Unit> = sendReadReceiptLambda(eventId, receiptType)
 
-    var paginateLambda: (direction: Timeline.PaginationDirection) -> Result<Boolean> = { Result.success(false) }
+    var paginateLambda: (direction: Timeline.PaginationDirection) -> Result<Boolean> = {
+        Result.success(false)
+    }
+
     override suspend fun paginate(direction: Timeline.PaginationDirection): Result<Boolean> = paginateLambda(direction)
 
     override fun paginationStatus(direction: Timeline.PaginationDirection): StateFlow<Timeline.PaginationStatus> {