Sulkta-OSS/element-x-ada
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Update rust-sdk (from maven)

Browse source
This commit is contained in:
ganfra 2023-02-24 15:05:20 +01:00
parent 22fd4ac7f0
commit 830b8caa3a
12 changed files with 86 additions and 96 deletions
Download patch file Download diff file Expand all files Collapse all files

3
libraries/matrix/build.gradle.kts
View file

@ -31,7 +31,8 @@ anvil {
}
dependencies {
api(projects.libraries.rustsdk)
//api(projects.libraries.rustsdk)
api(libs.matrix.sdk)
implementation(projects.libraries.di)
implementation(libs.dagger)
implementation(projects.libraries.core)

4
libraries/matrix/src/main/kotlin/io/element/android/libraries/matrix/RustMatrixClient.kt
View file

@ -38,7 +38,7 @@ import org.matrix.rustcomponents.sdk.RequiredState
import org.matrix.rustcomponents.sdk.SlidingSyncMode
import org.matrix.rustcomponents.sdk.SlidingSyncRequestListFilters
import org.matrix.rustcomponents.sdk.SlidingSyncViewBuilder
import org.matrix.rustcomponents.sdk.StoppableSpawn
import org.matrix.rustcomponents.sdk.TaskHandle
import timber.log.Timber
import java.io.File
import java.util.concurrent.atomic.AtomicBoolean
@ -114,7 +114,7 @@ class RustMatrixClient constructor(
dispatchers,
::onRestartSync
)
private var slidingSyncObserverToken: StoppableSpawn? = null
private var slidingSyncObserverToken: TaskHandle? = null
private val mediaResolver = RustMediaResolver(this)
private val isSyncing = AtomicBoolean(false)

38
libraries/matrix/src/main/kotlin/io/element/android/libraries/matrix/room/RoomSummaryDataSource.kt
View file

@ -37,7 +37,6 @@ import org.matrix.rustcomponents.sdk.SlidingSyncViewRoomsListDiff
import org.matrix.rustcomponents.sdk.UpdateSummary
import timber.log.Timber
import java.io.Closeable
import java.util.Collections
import java.util.UUID
interface RoomSummaryDataSource {
@ -128,30 +127,40 @@ internal class RustRoomSummaryDataSource(
}
Timber.v("ApplyDiff: $diff for list with size: $size")
when (diff) {
is SlidingSyncViewRoomsListDiff.Push -> {
is SlidingSyncViewRoomsListDiff.Append -> {
val roomSummaries = diff.values.map {
buildSummaryForRoomListEntry(it)
}
addAll(roomSummaries)
}
is SlidingSyncViewRoomsListDiff.PushBack -> {
val roomSummary = buildSummaryForRoomListEntry(diff.value)
add(roomSummary)
}
is SlidingSyncViewRoomsListDiff.UpdateAt -> {
is SlidingSyncViewRoomsListDiff.PushFront -> {
val roomSummary = buildSummaryForRoomListEntry(diff.value)
add(0, roomSummary)
}
is SlidingSyncViewRoomsListDiff.Set -> {
fillUntil(diff.index.toInt())
val roomSummary = buildSummaryForRoomListEntry(diff.value)
set(diff.index.toInt(), roomSummary)
}
is SlidingSyncViewRoomsListDiff.InsertAt -> {
is SlidingSyncViewRoomsListDiff.Insert -> {
val roomSummary = buildSummaryForRoomListEntry(diff.value)
add(diff.index.toInt(), roomSummary)
}
is SlidingSyncViewRoomsListDiff.Move -> {
Collections.swap(this, diff.oldIndex.toInt(), diff.newIndex.toInt())
}
is SlidingSyncViewRoomsListDiff.RemoveAt -> {
is SlidingSyncViewRoomsListDiff.Remove -> {
removeAt(diff.index.toInt())
}
is SlidingSyncViewRoomsListDiff.Replace -> {
is SlidingSyncViewRoomsListDiff.Reset -> {
clear()
addAll(diff.values.map { buildSummaryForRoomListEntry(it) })
}
SlidingSyncViewRoomsListDiff.Pop -> {
SlidingSyncViewRoomsListDiff.PopBack -> {
removeFirstOrNull()
}
SlidingSyncViewRoomsListDiff.PopFront -> {
removeLastOrNull()
}
SlidingSyncViewRoomsListDiff.Clear -> {
@ -185,13 +194,4 @@ internal class RustRoomSummaryDataSource(
block(mutableRoomSummaries)
roomSummaries.value = mutableRoomSummaries
}
fun SlidingSyncViewRoomsListDiff.isInvalidation(): Boolean {
return when (this) {
is SlidingSyncViewRoomsListDiff.InsertAt -> this.value is RoomListEntry.Invalidated
is SlidingSyncViewRoomsListDiff.UpdateAt -> this.value is RoomListEntry.Invalidated
is SlidingSyncViewRoomsListDiff.Push -> this.value is RoomListEntry.Invalidated
else -> false
}
}
}

7
libraries/matrix/src/main/kotlin/io/element/android/libraries/matrix/timeline/MatrixTimeline.kt
View file

@ -21,16 +21,9 @@ import kotlinx.coroutines.flow.Flow
import org.matrix.rustcomponents.sdk.TimelineListener
interface MatrixTimeline {
var callback: Callback?
interface Callback {
fun onUpdatedTimelineItem(timelineItem: MatrixTimelineItem) = Unit
fun onPushedTimelineItem(timelineItem: MatrixTimelineItem) = Unit
}
fun timelineItems(): Flow<List<MatrixTimelineItem>>
suspend fun paginateBackwards(requestSize: Int, untilNumberOfItems: Int): Result<Unit>
fun addListener(timelineListener: TimelineListener)
fun initialize()
fun dispose()

69
libraries/matrix/src/main/kotlin/io/element/android/libraries/matrix/timeline/RustMatrixTimeline.kt
View file

@ -19,7 +19,7 @@ package io.element.android.libraries.matrix.timeline
import io.element.android.libraries.core.coroutine.CoroutineDispatchers
import io.element.android.libraries.matrix.core.EventId
import io.element.android.libraries.matrix.room.RustMatrixRoom
import io.element.android.libraries.matrix.util.StoppableSpawnBag
import io.element.android.libraries.matrix.util.TaskHandleBag
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.FlowPreview
import kotlinx.coroutines.flow.Flow
@ -32,9 +32,9 @@ import org.matrix.rustcomponents.sdk.Room
import org.matrix.rustcomponents.sdk.SlidingSyncRoom
import org.matrix.rustcomponents.sdk.TimelineChange
import org.matrix.rustcomponents.sdk.TimelineDiff
import org.matrix.rustcomponents.sdk.TimelineItem
import org.matrix.rustcomponents.sdk.TimelineListener
import timber.log.Timber
import java.util.Collections
class RustMatrixTimeline(
private val matrixRoom: RustMatrixRoom,
@ -54,12 +54,10 @@ class RustMatrixTimeline(
}
}
override var callback: MatrixTimeline.Callback? = null
private val timelineItems: MutableStateFlow<List<MatrixTimelineItem>> =
MutableStateFlow(emptyList())
private val listenerTokens = StoppableSpawnBag()
private val listenerTokens = TaskHandleBag()
@OptIn(FlowPreview::class)
override fun timelineItems(): Flow<List<MatrixTimelineItem>> {
@ -68,37 +66,42 @@ class RustMatrixTimeline(
private fun MutableList<MatrixTimelineItem>.applyDiff(diff: TimelineDiff) {
when (diff.change()) {
TimelineChange.PUSH -> {
val item = diff.push()?.asMatrixTimelineItem() ?: return
callback?.onPushedTimelineItem(item)
TimelineChange.APPEND -> {
val items = diff.append()?.map { it.asMatrixTimelineItem() } ?: return
addAll(items)
}
TimelineChange.PUSH_BACK -> {
val item = diff.pushBack()?.asMatrixTimelineItem() ?: return
add(item)
}
TimelineChange.UPDATE_AT -> {
val updateAtData = diff.updateAt() ?: return
TimelineChange.PUSH_FRONT -> {
val item = diff.pushFront()?.asMatrixTimelineItem() ?: return
add(0, item)
}
TimelineChange.SET -> {
val updateAtData = diff.set() ?: return
val item = updateAtData.item.asMatrixTimelineItem()
callback?.onUpdatedTimelineItem(item)
set(updateAtData.index.toInt(), item)
}
TimelineChange.INSERT_AT -> {
val insertAtData = diff.insertAt() ?: return
TimelineChange.INSERT -> {
val insertAtData = diff.insert() ?: return
val item = insertAtData.item.asMatrixTimelineItem()
add(insertAtData.index.toInt(), item)
}
TimelineChange.MOVE -> {
val moveData = diff.move() ?: return
Collections.swap(this, moveData.oldIndex.toInt(), moveData.newIndex.toInt())
}
TimelineChange.REMOVE_AT -> {
val removeAtData = diff.removeAt() ?: return
TimelineChange.REMOVE -> {
val removeAtData = diff.remove() ?: return
removeAt(removeAtData.toInt())
}
TimelineChange.REPLACE -> {
TimelineChange.RESET -> {
clear()
val items = diff.replace()?.map { it.asMatrixTimelineItem() } ?: return
val items = diff.reset()?.map { it.asMatrixTimelineItem() } ?: return
addAll(items)
}
TimelineChange.POP -> {
removeLast()
TimelineChange.POP_FRONT -> {
removeFirstOrNull()
}
TimelineChange.POP_BACK -> {
removeLastOrNull()
}
TimelineChange.CLEAR -> {
clear()
@ -128,8 +131,12 @@ class RustMatrixTimeline(
timelineItems.value = mutableTimelineItems
}
override fun addListener(timelineListener: TimelineListener) {
listenerTokens += slidingSyncRoom.subscribeAndAddTimelineListener(timelineListener, null)
private suspend fun addListener(timelineListener: TimelineListener): Result<List<TimelineItem>> = withContext(coroutineDispatchers.computation) {
runCatching {
val result = slidingSyncRoom.subscribeAndAddTimelineListener(timelineListener, null)
listenerTokens += result.taskHandle
result.items
}
}
override fun initialize() {
@ -142,7 +149,17 @@ class RustMatrixTimeline(
Timber.v("Success fetching members for room ${slidingSyncRoom.roomId()}")
}
}
addListener(innerTimelineListener)
coroutineScope.launch {
val result = addListener(innerTimelineListener)
result
.onSuccess { timelineItems ->
val matrixTimelineItems = timelineItems.map { it.asMatrixTimelineItem() }
updateTimelineItems { addAll(matrixTimelineItems) }
}
.onFailure {
Timber.e("Failed adding timeline listener on room with identifier: ${slidingSyncRoom.roomId()})")
}
}
}
override fun dispose() {

7
libraries/matrix/src/main/kotlin/io/element/android/libraries/matrix/util/CallbackFlow.kt
View file

@ -19,12 +19,13 @@ package io.element.android.libraries.matrix.util
import kotlinx.coroutines.channels.ProducerScope
import kotlinx.coroutines.channels.awaitClose
import kotlinx.coroutines.flow.callbackFlow
import org.matrix.rustcomponents.sdk.StoppableSpawn
import org.matrix.rustcomponents.sdk.TaskHandle
internal fun <T> mxCallbackFlow(block: suspend ProducerScope<T>.() -> StoppableSpawn) =
internal fun <T> mxCallbackFlow(block: suspend ProducerScope<T>.() -> TaskHandle) =
callbackFlow {
val token: StoppableSpawn = block(this)
val token: TaskHandle = block(this)
awaitClose {
token.cancel()
token.destroy()
}
}

10
libraries/matrix/src/main/kotlin/io/element/android/libraries/matrix/util/StoppableSpawnBag.kt → libraries/matrix/src/main/kotlin/io/element/android/libraries/matrix/util/TaskHandleBag.kt
View file

@ -16,14 +16,14 @@
package io.element.android.libraries.matrix.util
import org.matrix.rustcomponents.sdk.StoppableSpawn
import org.matrix.rustcomponents.sdk.TaskHandle
import java.util.concurrent.CopyOnWriteArraySet
class StoppableSpawnBag(private val tokens: MutableSet<StoppableSpawn> = CopyOnWriteArraySet()) : Set<StoppableSpawn> by tokens {
class TaskHandleBag(private val tokens: MutableSet<TaskHandle> = CopyOnWriteArraySet()) : Set<TaskHandle> by tokens {
operator fun plusAssign(stoppableSpawn: StoppableSpawn?) {
if (stoppableSpawn == null) return
tokens += stoppableSpawn
operator fun plusAssign(taskHandle: TaskHandle?) {
if (taskHandle == null) return
tokens += taskHandle
}
fun dispose() {