2018-11-13 18:17:59 +00:00
|
|
|
package im.vector.matrix.android.internal.database.helper
|
|
|
|
|
|
|
|
import im.vector.matrix.android.api.session.events.model.Event
|
2018-11-22 10:20:50 +00:00
|
|
|
import im.vector.matrix.android.api.session.events.model.EventType
|
2018-11-15 17:32:39 +00:00
|
|
|
import im.vector.matrix.android.internal.database.mapper.asDomain
|
2018-11-27 21:42:46 +00:00
|
|
|
import im.vector.matrix.android.internal.database.mapper.fillWith
|
2018-11-13 18:17:59 +00:00
|
|
|
import im.vector.matrix.android.internal.database.model.ChunkEntity
|
2018-11-27 21:42:46 +00:00
|
|
|
import im.vector.matrix.android.internal.database.model.EventEntity
|
2018-11-22 10:20:50 +00:00
|
|
|
import im.vector.matrix.android.internal.database.model.EventEntityFields
|
2018-11-13 18:17:59 +00:00
|
|
|
import im.vector.matrix.android.internal.database.query.fastContains
|
2018-11-15 17:32:39 +00:00
|
|
|
import im.vector.matrix.android.internal.database.query.find
|
2018-11-13 18:17:59 +00:00
|
|
|
import im.vector.matrix.android.internal.session.room.timeline.PaginationDirection
|
2018-11-22 10:20:50 +00:00
|
|
|
import io.realm.Sort
|
2018-11-27 21:42:46 +00:00
|
|
|
import io.realm.kotlin.createObject
|
2018-11-13 18:17:59 +00:00
|
|
|
|
2018-11-27 21:42:46 +00:00
|
|
|
internal fun ChunkEntity.isUnlinked(): Boolean {
|
|
|
|
return events.where().equalTo(EventEntityFields.IS_UNLINKED, true).findAll().isNotEmpty()
|
|
|
|
}
|
2018-11-15 17:32:39 +00:00
|
|
|
|
2018-11-27 21:42:46 +00:00
|
|
|
internal fun ChunkEntity.merge(chunkToMerge: ChunkEntity,
|
2018-11-15 17:32:39 +00:00
|
|
|
direction: PaginationDirection) {
|
|
|
|
|
2018-11-27 21:42:46 +00:00
|
|
|
val isChunkToMergeUnlinked = chunkToMerge.isUnlinked()
|
|
|
|
val isCurrentChunkUnlinked = this.isUnlinked()
|
|
|
|
val isUnlinked = isCurrentChunkUnlinked && isChunkToMergeUnlinked
|
2018-11-19 14:47:54 +00:00
|
|
|
|
2018-11-27 21:42:46 +00:00
|
|
|
if (isCurrentChunkUnlinked && !isChunkToMergeUnlinked) {
|
|
|
|
this.events.forEach { it.isUnlinked = false }
|
2018-11-19 14:47:54 +00:00
|
|
|
}
|
2018-11-27 21:42:46 +00:00
|
|
|
val eventsToMerge: List<EventEntity>
|
2018-11-15 17:32:39 +00:00
|
|
|
if (direction == PaginationDirection.FORWARDS) {
|
2018-11-27 21:42:46 +00:00
|
|
|
this.nextToken = chunkToMerge.nextToken
|
|
|
|
this.isLast = chunkToMerge.isLast
|
|
|
|
eventsToMerge = chunkToMerge.events.reversed()
|
2018-11-15 17:32:39 +00:00
|
|
|
} else {
|
2018-11-27 21:42:46 +00:00
|
|
|
this.prevToken = chunkToMerge.prevToken
|
|
|
|
eventsToMerge = chunkToMerge.events
|
|
|
|
}
|
|
|
|
eventsToMerge.forEach {
|
|
|
|
addOrUpdate(it.asDomain(), direction, isUnlinked = isUnlinked)
|
2018-11-15 17:32:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
internal fun ChunkEntity.addAll(events: List<Event>,
|
|
|
|
direction: PaginationDirection,
|
2018-11-27 21:42:46 +00:00
|
|
|
stateIndexOffset: Int = 0,
|
|
|
|
isUnlinked: Boolean = false) {
|
2018-11-15 17:32:39 +00:00
|
|
|
|
|
|
|
events.forEach { event ->
|
2018-11-27 21:42:46 +00:00
|
|
|
addOrUpdate(event, direction, stateIndexOffset, isUnlinked)
|
2018-11-15 17:32:39 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-25 15:17:47 +00:00
|
|
|
internal fun ChunkEntity.updateDisplayIndexes() {
|
|
|
|
events.forEachIndexed { index, eventEntity -> eventEntity.displayIndex = index }
|
|
|
|
}
|
|
|
|
|
2018-11-15 17:32:39 +00:00
|
|
|
internal fun ChunkEntity.addOrUpdate(event: Event,
|
2018-11-19 14:47:54 +00:00
|
|
|
direction: PaginationDirection,
|
2018-11-27 21:42:46 +00:00
|
|
|
stateIndexOffset: Int = 0,
|
|
|
|
isUnlinked: Boolean = false) {
|
2018-11-15 17:32:39 +00:00
|
|
|
if (!isManaged) {
|
2018-11-13 18:17:59 +00:00
|
|
|
throw IllegalStateException("Chunk entity should be managed to use fast contains")
|
|
|
|
}
|
|
|
|
|
2018-11-14 18:32:42 +00:00
|
|
|
if (event.eventId == null) {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2018-11-22 10:20:50 +00:00
|
|
|
var currentStateIndex = lastStateIndex(direction, defaultValue = stateIndexOffset)
|
|
|
|
if (direction == PaginationDirection.FORWARDS && event.isStateEvent()) {
|
|
|
|
currentStateIndex += 1
|
|
|
|
} else if (direction == PaginationDirection.BACKWARDS && events.isNotEmpty()) {
|
|
|
|
val lastEventType = events.last()?.type ?: ""
|
|
|
|
if (EventType.isStateEvent(lastEventType)) {
|
|
|
|
currentStateIndex -= 1
|
|
|
|
}
|
2018-11-19 14:47:54 +00:00
|
|
|
}
|
|
|
|
|
2018-11-27 21:42:46 +00:00
|
|
|
val eventEntity: EventEntity?
|
2018-11-15 17:32:39 +00:00
|
|
|
if (!events.fastContains(event.eventId)) {
|
2018-11-27 21:42:46 +00:00
|
|
|
eventEntity = realm.createObject()
|
|
|
|
eventEntity.fillWith(event)
|
2018-11-15 17:32:39 +00:00
|
|
|
val position = if (direction == PaginationDirection.FORWARDS) 0 else this.events.size
|
|
|
|
events.add(position, eventEntity)
|
|
|
|
} else {
|
2018-11-27 21:42:46 +00:00
|
|
|
eventEntity = events.find(event.eventId)
|
2018-11-13 18:17:59 +00:00
|
|
|
}
|
2018-11-27 21:42:46 +00:00
|
|
|
eventEntity?.stateIndex = currentStateIndex
|
|
|
|
eventEntity?.isUnlinked = isUnlinked
|
2018-11-22 10:20:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
internal fun ChunkEntity.lastStateIndex(direction: PaginationDirection, defaultValue: Int = 0): Int {
|
|
|
|
return when (direction) {
|
2018-11-25 15:17:47 +00:00
|
|
|
PaginationDirection.FORWARDS -> events.where().sort(EventEntityFields.STATE_INDEX, Sort.DESCENDING).findFirst()?.stateIndex
|
|
|
|
PaginationDirection.BACKWARDS -> events.where().sort(EventEntityFields.STATE_INDEX, Sort.ASCENDING).findFirst()?.stateIndex
|
|
|
|
} ?: defaultValue
|
2018-11-13 18:17:59 +00:00
|
|
|
}
|