EventTypeFilter implementation to allow hiding member events.

matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/room/timeline/EventTypeFilter.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.matrix.android.sdk.api.session.room.timeline
+
+data class EventTypeFilter(
+        /**
+         * Allowed event type.
+         */
+        val eventType: String,
+        /**
+         * Allowed state key. Set null if you want to allow all events,
+         * otherwise allowed events will be filtered according to the given stateKey.
+         */
+        val stateKey: String?
+)

matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/room/timeline/TimelineEventFilters.kt

@@ -36,5 +36,5 @@ data class TimelineEventFilters(
         /**
          * If [filterTypes] is true, the list of types allowed by the list.
          */
-        val allowedTypes: List<String> = emptyList()
+        val allowedTypes: List<EventTypeFilter> = emptyList()
 )

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

@@ -71,8 +71,23 @@ internal fun TimelineEventEntity.Companion.latestEvent(realm: Realm,
 }
 
 internal fun RealmQuery<TimelineEventEntity>.filterEvents(filters: TimelineEventFilters): RealmQuery<TimelineEventEntity> {
-    if (filters.filterTypes) {
+    if (filters.filterTypes && filters.allowedTypes.isNotEmpty()) {
-        `in`(TimelineEventEntityFields.ROOT.TYPE, filters.allowedTypes.toTypedArray())
+        beginGroup()
+        filters.allowedTypes.forEachIndexed { index, filter ->
+            if (filter.stateKey == null) {
+                equalTo(TimelineEventEntityFields.ROOT.TYPE, filter.eventType)
+            } else {
+                beginGroup()
+                equalTo(TimelineEventEntityFields.ROOT.TYPE, filter.eventType)
+                and()
+                equalTo(TimelineEventEntityFields.ROOT.STATE_KEY, filter.stateKey)
+                endGroup()
+            }
+            if (index != filters.allowedTypes.size - 1) {
+                or()
+            }
+        }
+        endGroup()
     }
     if (filters.filterUseless) {
         not()

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/summary/RoomSummaryEventsHelper.kt

@@ -18,6 +18,7 @@ package org.matrix.android.sdk.internal.session.room.summary
 
 import io.realm.Realm
 import org.matrix.android.sdk.api.session.room.summary.RoomSummaryConstants
+import org.matrix.android.sdk.api.session.room.timeline.EventTypeFilter
 import org.matrix.android.sdk.api.session.room.timeline.TimelineEventFilters
 import org.matrix.android.sdk.internal.database.model.TimelineEventEntity
 import org.matrix.android.sdk.internal.database.query.latestEvent
@@ -26,7 +27,7 @@ internal object RoomSummaryEventsHelper {
 
     private val previewFilters = TimelineEventFilters(
             filterTypes = true,
-            allowedTypes = RoomSummaryConstants.PREVIEWABLE_TYPES,
+            allowedTypes = RoomSummaryConstants.PREVIEWABLE_TYPES.map { EventTypeFilter(eventType = it, stateKey = null) },
             filterUseless = true,
             filterRedacted = false,
             filterEdits = true

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/timeline/DefaultTimeline.kt

@@ -785,7 +785,7 @@ internal class DefaultTimeline(
 
     private fun List<TimelineEvent>.filterEventsWithSettings(): List<TimelineEvent> {
         return filter {
-            val filterType = !settings.filters.filterTypes || settings.filters.allowedTypes.contains(it.root.type)
+            val filterType = !settings.filters.filterTypes || settings.filters.allowedTypes.map { it.eventType }.contains(it.root.type)
             if (!filterType) return@filter false
 
             val filterEdits = if (settings.filters.filterEdits && it.root.getClearType() == EventType.MESSAGE) {

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/timeline/TimelineHiddenReadReceipts.kt

@@ -151,7 +151,7 @@ internal class TimelineHiddenReadReceipts constructor(private val readReceiptsSu
         beginGroup()
         var needOr = false
         if (settings.filters.filterTypes) {
-            val allowedTypes = settings.filters.allowedTypes.toTypedArray()
+            val allowedTypes = settings.filters.allowedTypes.map { it.eventType }.toTypedArray()
             not().`in`("${ReadReceiptsSummaryEntityFields.TIMELINE_EVENT}.${TimelineEventEntityFields.ROOT.TYPE}", allowedTypes)
             needOr = true
         }

vector/src/main/java/im/vector/app/features/home/room/detail/timeline/helper/TimelineSettingsFactory.kt

@@ -17,12 +17,17 @@
 package im.vector.app.features.home.room.detail.timeline.helper
 
 import im.vector.app.core.resources.UserPreferencesProvider
+import org.matrix.android.sdk.api.session.Session
 import org.matrix.android.sdk.api.session.events.model.EventType
+import org.matrix.android.sdk.api.session.room.timeline.EventTypeFilter
 import org.matrix.android.sdk.api.session.room.timeline.TimelineEventFilters
 import org.matrix.android.sdk.api.session.room.timeline.TimelineSettings
 import javax.inject.Inject
 
-class TimelineSettingsFactory @Inject constructor(private val userPreferencesProvider: UserPreferencesProvider) {
+class TimelineSettingsFactory @Inject constructor(
+        private val userPreferencesProvider: UserPreferencesProvider,
+        private val session: Session
+) {
 
     fun create(): TimelineSettings {
         return if (userPreferencesProvider.shouldShowHiddenEvents()) {
@@ -48,12 +53,12 @@ class TimelineSettingsFactory @Inject constructor(private val userPreferencesPro
         }
     }
 
-    private fun List<String>.filterDisplayableTypes(): List<String> {
+    private fun List<String>.filterDisplayableTypes(): List<EventTypeFilter> {
-        return filter { type ->
+        return map {
-            when (type) {
+            EventTypeFilter(
-                EventType.STATE_ROOM_MEMBER -> userPreferencesProvider.shouldShowRoomMemberStateEvents()
+                    eventType = it,
-                else                        -> true
+                    stateKey = if (it == EventType.STATE_ROOM_MEMBER && userPreferencesProvider.shouldShowRoomMemberStateEvents()) session.myUserId else null
-            }
+            )
         }
     }
 }