Merge branch 'hotfix/1.4.20' into main

CHANGES.md

@@ -1,3 +1,12 @@
+Changes in Element 1.4.20 (2022-06-13)
+======================================
+
+Bugfixes 🐛
+----------
+ - Fix: All rooms are shown in Home regardless of the switch state. ([#6272](https://github.com/vector-im/element-android/issues/6272))
+ - Fix regression on EventInsertLiveObserver getting blocked so there is no event being processed anymore. ([#6278](https://github.com/vector-im/element-android/issues/6278))
+
+
 Changes in Element 1.4.19 (2022-06-07)
 ======================================
 

fastlane/metadata/android/en-US/changelogs/40104200.txt

@@ -0,0 +1,2 @@
+Main changes in this version: Various bug fixes and stability improvements.
+Full changelog: https://github.com/vector-im/element-android/releases

matrix-sdk-android/build.gradle

@@ -56,7 +56,7 @@ android {
         // that the app's state is completely cleared between tests.
         testInstrumentationRunnerArguments clearPackageData: 'true'
 
-        buildConfigField "String", "SDK_VERSION", "\"1.4.19\""
+        buildConfigField "String", "SDK_VERSION", "\"1.4.20\""
 
         buildConfigField "String", "GIT_SDK_REVISION", "\"${gitRevision()}\""
         buildConfigField "String", "GIT_SDK_REVISION_UNIX_DATE", "\"${gitRevisionUnixDate()}\""

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/database/EventInsertLiveObserver.kt

@@ -19,10 +19,9 @@ package org.matrix.android.sdk.internal.database
 import com.zhuinden.monarchy.Monarchy
 import io.realm.RealmConfiguration
 import io.realm.RealmResults
-import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import org.matrix.android.sdk.internal.database.mapper.asDomain
 import org.matrix.android.sdk.internal.database.model.EventEntity
 import org.matrix.android.sdk.internal.database.model.EventInsertEntity
@@ -37,65 +36,58 @@ internal class EventInsertLiveObserver @Inject constructor(@SessionDatabase real
                                                            private val processors: Set<@JvmSuppressWildcards EventInsertLiveProcessor>) :
         RealmLiveEntityObserver<EventInsertEntity>(realmConfiguration) {
 
+    private val lock = Mutex()
+
     override val query = Monarchy.Query {
         it.where(EventInsertEntity::class.java).equalTo(EventInsertEntityFields.CAN_BE_PROCESSED, true)
     }
 
-    private val onResultsChangedFlow = MutableSharedFlow<RealmResults<EventInsertEntity>>()
-
-    init {
-        onResultsChangedFlow
-                .onEach { handleChange(it) }
-                .launchIn(observerScope)
-    }
-
     override fun onChange(results: RealmResults<EventInsertEntity>) {
-        if (!results.isLoaded || results.isEmpty()) {
-            return
-        }
-        observerScope.launch { onResultsChangedFlow.emit(results) }
-    }
-
-    private suspend fun handleChange(results: RealmResults<EventInsertEntity>) {
-        val idsToDeleteAfterProcess = ArrayList<String>()
-        val filteredEvents = ArrayList<EventInsertEntity>(results.size)
-        Timber.v("EventInsertEntity updated with ${results.size} results in db")
-        results.forEach {
-            if (shouldProcess(it)) {
-                // don't use copy from realm over there
-                val copiedEvent = EventInsertEntity(
-                        eventId = it.eventId,
-                        eventType = it.eventType
-                ).apply {
-                    insertType = it.insertType
+        observerScope.launch {
+            lock.withLock {
+                if (!results.isLoaded || results.isEmpty()) {
+                    return@withLock
                 }
-                filteredEvents.add(copiedEvent)
+                val idsToDeleteAfterProcess = ArrayList<String>()
+                val filteredEvents = ArrayList<EventInsertEntity>(results.size)
+                Timber.v("EventInsertEntity updated with ${results.size} results in db")
+                results.forEach {
+                    if (shouldProcess(it)) {
+                        // don't use copy from realm over there
+                        val copiedEvent = EventInsertEntity(
+                                eventId = it.eventId,
+                                eventType = it.eventType
+                        ).apply {
+                            insertType = it.insertType
+                        }
+                        filteredEvents.add(copiedEvent)
+                    }
+                    idsToDeleteAfterProcess.add(it.eventId)
+                }
+                awaitTransaction(realmConfiguration) { realm ->
+                    Timber.v("##Transaction: There are ${filteredEvents.size} events to process ")
+                    filteredEvents.forEach { eventInsert ->
+                        val eventId = eventInsert.eventId
+                        val event = EventEntity.where(realm, eventId).findFirst()
+                        if (event == null) {
+                            Timber.v("Event $eventId not found")
+                            return@forEach
+                        }
+                        val domainEvent = event.asDomain()
+                        processors.filter {
+                            it.shouldProcess(eventId, domainEvent.getClearType(), eventInsert.insertType)
+                        }.forEach {
+                            it.process(realm, domainEvent)
+                        }
+                    }
+                    realm.where(EventInsertEntity::class.java)
+                            .`in`(EventInsertEntityFields.EVENT_ID, idsToDeleteAfterProcess.toTypedArray())
+                            .findAll()
+                            .deleteAllFromRealm()
+                }
+                processors.forEach { it.onPostProcess() }
             }
-            idsToDeleteAfterProcess.add(it.eventId)
         }
-
-        awaitTransaction(realmConfiguration) { realm ->
-            Timber.v("##Transaction: There are ${filteredEvents.size} events to process ")
-            filteredEvents.forEach { eventInsert ->
-                val eventId = eventInsert.eventId
-                val event = EventEntity.where(realm, eventId).findFirst()
-                if (event == null) {
-                    Timber.v("Event $eventId not found")
-                    return@forEach
-                }
-                val domainEvent = event.asDomain()
-                processors.filter {
-                    it.shouldProcess(eventId, domainEvent.getClearType(), eventInsert.insertType)
-                }.forEach {
-                    it.process(realm, domainEvent)
-                }
-            }
-            realm.where(EventInsertEntity::class.java)
-                    .`in`(EventInsertEntityFields.EVENT_ID, idsToDeleteAfterProcess.toTypedArray())
-                    .findAll()
-                    .deleteAllFromRealm()
-        }
-        processors.forEach { it.onPostProcess() }
     }
 
     private fun shouldProcess(eventInsertEntity: EventInsertEntity): Boolean {

vector/build.gradle

@@ -31,7 +31,7 @@ ext.versionMinor = 4
 // Note: even values are reserved for regular release, odd values for hotfix release.
 // When creating a hotfix, you should decrease the value, since the current value
 // is the value for the next regular release.
-ext.versionPatch = 19
+ext.versionPatch = 20
 
 static def getGitTimestamp() {
     def cmd = 'git show -s --format=%ct'

vector/src/main/java/im/vector/app/features/home/HomeDetailViewModel.kt

@@ -289,7 +289,7 @@ class HomeDetailViewModel @AssistedInject constructor(
                 .launchIn(viewModelScope)
     }
 
-    private fun RoomGroupingMethod.BySpace.toActiveSpaceOrOrphanRooms(): SpaceFilter? {
-        return spaceSummary?.roomId?.toActiveSpaceOrOrphanRooms()
+    private fun RoomGroupingMethod.BySpace.toActiveSpaceOrOrphanRooms(): SpaceFilter {
+        return spaceSummary?.roomId.toActiveSpaceOrOrphanRooms()
     }
 }

vector/src/main/java/im/vector/app/features/home/room/list/RoomListSectionBuilderSpace.kt

@@ -371,7 +371,7 @@ class RoomListSectionBuilderSpace(
                     activeSpaceUpdaters.add(object : RoomListViewModel.ActiveSpaceQueryUpdater {
                         override fun updateForSpaceId(roomId: String?) {
                             filteredPagedRoomSummariesLive.queryParams = roomQueryParams.copy(
-                                    spaceFilter = roomId?.toActiveSpaceOrOrphanRooms()
+                                    spaceFilter = roomId.toActiveSpaceOrOrphanRooms()
                             )
                             liveQueryParams.update { filteredPagedRoomSummariesLive.queryParams }
                         }
@@ -437,7 +437,7 @@ class RoomListSectionBuilderSpace(
         return when (spaceFilter) {
             RoomListViewModel.SpaceFilterStrategy.ORPHANS_IF_SPACE_NULL -> {
                 copy(
-                        spaceFilter = currentSpace?.toActiveSpaceOrOrphanRooms()
+                        spaceFilter = currentSpace.toActiveSpaceOrOrphanRooms()
                 )
             }
             RoomListViewModel.SpaceFilterStrategy.ALL_IF_SPACE_NULL     -> {