2018-10-17 16:21:09 +00:00
|
|
|
package im.vector.matrix.android.internal.session.sync
|
2018-10-11 18:01:08 +00:00
|
|
|
|
2018-10-18 09:16:02 +00:00
|
|
|
import com.zhuinden.monarchy.Monarchy
|
2018-10-17 16:21:09 +00:00
|
|
|
import im.vector.matrix.android.api.session.events.model.Event
|
2018-10-23 16:25:28 +00:00
|
|
|
import im.vector.matrix.android.api.session.room.model.MyMembership
|
2018-10-16 13:52:30 +00:00
|
|
|
import im.vector.matrix.android.internal.database.mapper.asEntity
|
2018-10-12 17:26:22 +00:00
|
|
|
import im.vector.matrix.android.internal.database.model.ChunkEntity
|
|
|
|
import im.vector.matrix.android.internal.database.model.RoomEntity
|
2018-10-23 16:25:28 +00:00
|
|
|
import im.vector.matrix.android.internal.database.model.RoomSummaryEntity
|
2018-10-18 16:38:11 +00:00
|
|
|
import im.vector.matrix.android.internal.database.query.findAllIncludingEvents
|
2018-10-22 13:17:50 +00:00
|
|
|
import im.vector.matrix.android.internal.database.query.findLastLiveChunkFromRoom
|
2018-10-18 16:38:11 +00:00
|
|
|
import im.vector.matrix.android.internal.database.query.where
|
2018-10-17 16:21:09 +00:00
|
|
|
import im.vector.matrix.android.internal.session.sync.model.InvitedRoomSync
|
|
|
|
import im.vector.matrix.android.internal.session.sync.model.RoomSync
|
2018-10-23 16:25:28 +00:00
|
|
|
import im.vector.matrix.android.internal.session.sync.model.RoomSyncSummary
|
2018-10-15 17:42:13 +00:00
|
|
|
import io.realm.Realm
|
2018-10-11 18:01:08 +00:00
|
|
|
|
|
|
|
|
2018-10-18 09:16:02 +00:00
|
|
|
class RoomSyncHandler(private val monarchy: Monarchy) {
|
2018-10-11 18:01:08 +00:00
|
|
|
|
2018-10-15 17:42:13 +00:00
|
|
|
sealed class HandlingStrategy {
|
|
|
|
data class JOINED(val data: Map<String, RoomSync>) : HandlingStrategy()
|
|
|
|
data class INVITED(val data: Map<String, InvitedRoomSync>) : HandlingStrategy()
|
|
|
|
data class LEFT(val data: Map<String, RoomSync>) : HandlingStrategy()
|
|
|
|
}
|
2018-10-11 18:01:08 +00:00
|
|
|
|
2018-10-15 17:42:13 +00:00
|
|
|
fun handleRoomSync(handlingStrategy: HandlingStrategy) {
|
2018-10-18 16:38:11 +00:00
|
|
|
monarchy.runTransactionSync { realm ->
|
2018-10-15 17:42:13 +00:00
|
|
|
val roomEntities = when (handlingStrategy) {
|
|
|
|
is HandlingStrategy.JOINED -> handlingStrategy.data.map { handleJoinedRoom(realm, it.key, it.value) }
|
|
|
|
is HandlingStrategy.INVITED -> handlingStrategy.data.map { handleInvitedRoom(realm, it.key, it.value) }
|
|
|
|
is HandlingStrategy.LEFT -> handlingStrategy.data.map { handleLeftRoom(it.key, it.value) }
|
|
|
|
}
|
2018-10-18 09:16:02 +00:00
|
|
|
realm.insertOrUpdate(roomEntities)
|
2018-10-12 17:26:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-15 17:42:13 +00:00
|
|
|
|
|
|
|
// PRIVATE METHODS *****************************************************************************
|
|
|
|
|
|
|
|
private fun handleJoinedRoom(realm: Realm,
|
|
|
|
roomId: String,
|
|
|
|
roomSync: RoomSync): RoomEntity {
|
|
|
|
|
2018-10-18 16:38:11 +00:00
|
|
|
val roomEntity = RoomEntity.where(realm, roomId).findFirst() ?: RoomEntity(roomId)
|
2018-10-15 17:42:13 +00:00
|
|
|
|
2018-10-23 16:25:28 +00:00
|
|
|
if (roomEntity.membership == MyMembership.INVITED) {
|
2018-10-15 17:42:13 +00:00
|
|
|
roomEntity.chunks.deleteAllFromRealm()
|
2018-10-12 17:26:22 +00:00
|
|
|
}
|
2018-10-15 17:42:13 +00:00
|
|
|
|
2018-10-23 16:25:28 +00:00
|
|
|
|
|
|
|
roomEntity.membership = MyMembership.JOINED
|
|
|
|
|
|
|
|
if (roomSync.summary != null) {
|
|
|
|
handleRoomSummary(realm, roomId, roomSync.summary)
|
|
|
|
}
|
2018-10-15 17:42:13 +00:00
|
|
|
if (roomSync.state != null && roomSync.state.events.isNotEmpty()) {
|
2018-10-22 17:36:29 +00:00
|
|
|
val chunkEntity = StateEventsChunkHandler().handle(realm, roomId, roomSync.state.events)
|
2018-10-15 17:42:13 +00:00
|
|
|
if (!roomEntity.chunks.contains(chunkEntity)) {
|
|
|
|
roomEntity.chunks.add(chunkEntity)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (roomSync.timeline != null && roomSync.timeline.events.isNotEmpty()) {
|
2018-10-22 17:36:29 +00:00
|
|
|
val chunkEntity = handleListOfEvent(realm, roomId, roomSync.timeline.events, roomSync.timeline.prevToken, isLimited = roomSync.timeline.limited)
|
2018-10-15 17:42:13 +00:00
|
|
|
if (!roomEntity.chunks.contains(chunkEntity)) {
|
|
|
|
roomEntity.chunks.add(chunkEntity)
|
|
|
|
}
|
2018-10-12 17:26:22 +00:00
|
|
|
}
|
2018-10-15 17:42:13 +00:00
|
|
|
return roomEntity
|
|
|
|
}
|
2018-10-12 17:26:22 +00:00
|
|
|
|
2018-10-15 17:42:13 +00:00
|
|
|
private fun handleInvitedRoom(realm: Realm,
|
|
|
|
roomId: String,
|
|
|
|
roomSync:
|
|
|
|
InvitedRoomSync): RoomEntity {
|
|
|
|
val roomEntity = RoomEntity()
|
|
|
|
roomEntity.roomId = roomId
|
2018-10-23 16:25:28 +00:00
|
|
|
roomEntity.membership = MyMembership.INVITED
|
2018-10-15 17:42:13 +00:00
|
|
|
if (roomSync.inviteState != null && roomSync.inviteState.events.isNotEmpty()) {
|
2018-10-22 17:36:29 +00:00
|
|
|
val chunkEntity = handleListOfEvent(realm, roomId, roomSync.inviteState.events)
|
2018-10-15 17:42:13 +00:00
|
|
|
if (!roomEntity.chunks.contains(chunkEntity)) {
|
|
|
|
roomEntity.chunks.add(chunkEntity)
|
|
|
|
}
|
2018-10-12 17:26:22 +00:00
|
|
|
}
|
|
|
|
return roomEntity
|
|
|
|
}
|
2018-10-11 18:01:08 +00:00
|
|
|
|
2018-10-15 17:42:13 +00:00
|
|
|
// TODO : handle it
|
|
|
|
private fun handleLeftRoom(roomId: String,
|
|
|
|
roomSync: RoomSync): RoomEntity {
|
|
|
|
return RoomEntity().apply {
|
|
|
|
this.roomId = roomId
|
2018-10-23 16:25:28 +00:00
|
|
|
this.membership = MyMembership.LEFT
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private fun handleRoomSummary(realm: Realm,
|
|
|
|
roomId: String,
|
|
|
|
roomSummary: RoomSyncSummary) {
|
|
|
|
|
|
|
|
val roomSummaryEntity = RoomSummaryEntity.where(realm, roomId).findFirst()
|
|
|
|
?: RoomSummaryEntity(roomId)
|
|
|
|
|
|
|
|
if (roomSummary.heroes.isNotEmpty()) {
|
|
|
|
roomSummaryEntity.heroes.clear()
|
|
|
|
roomSummaryEntity.heroes.addAll(roomSummary.heroes)
|
|
|
|
}
|
|
|
|
if (roomSummary.invitedMembersCount != null) {
|
|
|
|
roomSummaryEntity.invitedMembersCount = roomSummary.invitedMembersCount
|
|
|
|
}
|
|
|
|
if (roomSummary.joinedMembersCount != null) {
|
|
|
|
roomSummaryEntity.joinedMembersCount = roomSummary.joinedMembersCount
|
2018-10-15 17:42:13 +00:00
|
|
|
}
|
2018-10-23 16:25:28 +00:00
|
|
|
realm.insertOrUpdate(roomSummaryEntity)
|
2018-10-15 17:42:13 +00:00
|
|
|
}
|
|
|
|
|
2018-10-22 17:36:29 +00:00
|
|
|
private fun handleListOfEvent(realm: Realm,
|
|
|
|
roomId: String,
|
|
|
|
eventList: List<Event>,
|
|
|
|
prevToken: String? = null,
|
|
|
|
nextToken: String? = null,
|
|
|
|
isLimited: Boolean = true): ChunkEntity {
|
2018-10-15 17:42:13 +00:00
|
|
|
|
|
|
|
val chunkEntity = if (!isLimited) {
|
2018-10-22 13:17:50 +00:00
|
|
|
ChunkEntity.findLastLiveChunkFromRoom(realm, roomId)
|
2018-10-15 17:42:13 +00:00
|
|
|
} else {
|
2018-10-16 13:52:30 +00:00
|
|
|
val eventIds = eventList.filter { it.eventId != null }.map { it.eventId!! }
|
2018-10-18 16:38:11 +00:00
|
|
|
ChunkEntity.findAllIncludingEvents(realm, eventIds).firstOrNull()
|
2018-10-16 13:52:30 +00:00
|
|
|
} ?: ChunkEntity().apply { this.prevToken = prevToken }
|
2018-10-15 17:42:13 +00:00
|
|
|
|
2018-10-13 09:18:49 +00:00
|
|
|
chunkEntity.nextToken = nextToken
|
2018-10-17 11:59:21 +00:00
|
|
|
|
2018-10-15 17:42:13 +00:00
|
|
|
eventList.forEach { event ->
|
2018-10-16 13:52:30 +00:00
|
|
|
val eventEntity = event.asEntity().let {
|
2018-10-15 17:42:13 +00:00
|
|
|
realm.copyToRealmOrUpdate(it)
|
|
|
|
}
|
|
|
|
if (!chunkEntity.events.contains(eventEntity)) {
|
|
|
|
chunkEntity.events.add(eventEntity)
|
|
|
|
}
|
|
|
|
}
|
2018-10-13 09:18:49 +00:00
|
|
|
return chunkEntity
|
|
|
|
}
|
|
|
|
|
2018-10-11 18:01:08 +00:00
|
|
|
}
|