diff --git a/libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/notification/NotificationData.kt b/libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/notification/NotificationData.kt index 5ac236ad800..338193ed44b 100644 --- a/libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/notification/NotificationData.kt +++ b/libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/notification/NotificationData.kt @@ -9,12 +9,14 @@ package io.element.android.libraries.matrix.api.notification import io.element.android.libraries.matrix.api.core.EventId import io.element.android.libraries.matrix.api.core.RoomId +import io.element.android.libraries.matrix.api.core.SessionId import io.element.android.libraries.matrix.api.core.ThreadId import io.element.android.libraries.matrix.api.core.UserId import io.element.android.libraries.matrix.api.room.RoomMembershipState import io.element.android.libraries.matrix.api.timeline.item.event.MessageType data class NotificationData( + val sessionId: SessionId, val eventId: EventId, val threadId: ThreadId?, val roomId: RoomId, diff --git a/libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/notification/NotificationService.kt b/libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/notification/NotificationService.kt index f229a46677a..1e1c8b7fb77 100644 --- a/libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/notification/NotificationService.kt +++ b/libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/notification/NotificationService.kt @@ -11,5 +11,5 @@ import io.element.android.libraries.matrix.api.core.EventId import io.element.android.libraries.matrix.api.core.RoomId interface NotificationService { - suspend fun getNotification(roomId: RoomId, eventId: EventId): Result + suspend fun getNotifications(ids: Map>): Result> } diff --git a/libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/RustMatrixClient.kt b/libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/RustMatrixClient.kt index 9dba6fc5894..5ef878df5ac 100644 --- a/libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/RustMatrixClient.kt +++ b/libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/RustMatrixClient.kt @@ -152,7 +152,7 @@ class RustMatrixClient( ) private val notificationProcessSetup = NotificationProcessSetup.SingleProcess(innerSyncService) private val innerNotificationClient = runBlocking { innerClient.notificationClient(notificationProcessSetup) } - private val notificationService = RustNotificationService(innerNotificationClient, dispatchers, clock) + private val notificationService = RustNotificationService(sessionId, innerNotificationClient, dispatchers, clock) private val notificationSettingsService = RustNotificationSettingsService(innerClient, sessionCoroutineScope, dispatchers) private val encryptionService = RustEncryptionService( client = innerClient, diff --git a/libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/notification/NotificationMapper.kt b/libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/notification/NotificationMapper.kt index 7fdb4a9fdc0..9130df5c7a0 100644 --- a/libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/notification/NotificationMapper.kt +++ b/libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/notification/NotificationMapper.kt @@ -10,6 +10,7 @@ package io.element.android.libraries.matrix.impl.notification import io.element.android.libraries.core.bool.orFalse import io.element.android.libraries.matrix.api.core.EventId import io.element.android.libraries.matrix.api.core.RoomId +import io.element.android.libraries.matrix.api.core.SessionId import io.element.android.libraries.matrix.api.core.UserId import io.element.android.libraries.matrix.api.notification.NotificationContent import io.element.android.libraries.matrix.api.notification.NotificationData @@ -25,6 +26,7 @@ class NotificationMapper( private val notificationContentMapper = NotificationContentMapper() fun map( + sessionId: SessionId, eventId: EventId, roomId: RoomId, notificationItem: NotificationItem @@ -35,6 +37,7 @@ class NotificationMapper( activeMembersCount = item.roomInfo.joinedMembersCount.toInt(), ) NotificationData( + sessionId = sessionId, eventId = eventId, // FIXME once the `NotificationItem` in the SDK returns the thread id threadId = null, diff --git a/libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/notification/RustNotificationService.kt b/libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/notification/RustNotificationService.kt index dfc891ace85..7cf432bad41 100644 --- a/libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/notification/RustNotificationService.kt +++ b/libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/notification/RustNotificationService.kt @@ -10,28 +10,45 @@ package io.element.android.libraries.matrix.impl.notification import io.element.android.libraries.core.coroutine.CoroutineDispatchers import io.element.android.libraries.matrix.api.core.EventId import io.element.android.libraries.matrix.api.core.RoomId +import io.element.android.libraries.matrix.api.core.SessionId import io.element.android.libraries.matrix.api.notification.NotificationData import io.element.android.libraries.matrix.api.notification.NotificationService import io.element.android.services.toolbox.api.systemclock.SystemClock import kotlinx.coroutines.withContext import org.matrix.rustcomponents.sdk.NotificationClient -import org.matrix.rustcomponents.sdk.use +import org.matrix.rustcomponents.sdk.NotificationItemsRequest +import timber.log.Timber class RustNotificationService( + private val sessionId: SessionId, private val notificationClient: NotificationClient, private val dispatchers: CoroutineDispatchers, clock: SystemClock, ) : NotificationService { private val notificationMapper: NotificationMapper = NotificationMapper(clock) - override suspend fun getNotification( - roomId: RoomId, - eventId: EventId, - ): Result = withContext(dispatchers.io) { + override suspend fun getNotifications( + ids: Map> + ): Result> = withContext(dispatchers.io) { runCatching { - val item = notificationClient.getNotification(roomId.value, eventId.value) - item?.use { - notificationMapper.map(eventId, roomId, it) + val requests = ids.map { (roomId, eventIds) -> + NotificationItemsRequest( + roomId = roomId.value, + eventIds = eventIds.map { it.value } + ) + } + val items = notificationClient.getNotifications(requests) + buildMap { + val eventIds = requests.flatMap { it.eventIds } + for (eventId in eventIds) { + val item = items[eventId] + if (item != null) { + val roomId = RoomId(requests.find { it.eventIds.contains(eventId) }?.roomId!!) + put(EventId(eventId), notificationMapper.map(sessionId, EventId(eventId), roomId, item)) + } else { + Timber.e("Could not retrieve event for notification with $eventId") + } + } } } } diff --git a/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/fixtures/fakes/FakeRustNotificationClient.kt b/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/fixtures/fakes/FakeRustNotificationClient.kt index 1e607351b91..802f20c509c 100644 --- a/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/fixtures/fakes/FakeRustNotificationClient.kt +++ b/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/fixtures/fakes/FakeRustNotificationClient.kt @@ -7,15 +7,15 @@ package io.element.android.libraries.matrix.impl.fixtures.fakes -import io.element.android.tests.testutils.simulateLongTask import org.matrix.rustcomponents.sdk.NoPointer import org.matrix.rustcomponents.sdk.NotificationClient import org.matrix.rustcomponents.sdk.NotificationItem +import org.matrix.rustcomponents.sdk.NotificationItemsRequest class FakeRustNotificationClient( - var notificationItemResult: NotificationItem? = null + var notificationItemResult: Map = emptyMap(), ) : NotificationClient(NoPointer) { - override suspend fun getNotification(roomId: String, eventId: String): NotificationItem? = simulateLongTask { - notificationItemResult + override suspend fun getNotifications(requests: List): Map { + return notificationItemResult } } diff --git a/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/notification/RustNotificationServiceTest.kt b/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/notification/RustNotificationServiceTest.kt index 71623337cd9..c8d40d7332a 100644 --- a/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/notification/RustNotificationServiceTest.kt +++ b/libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/notification/RustNotificationServiceTest.kt @@ -15,6 +15,7 @@ import io.element.android.libraries.matrix.impl.fixtures.fakes.FakeRustNotificat import io.element.android.libraries.matrix.test.AN_EVENT_ID import io.element.android.libraries.matrix.test.A_MESSAGE import io.element.android.libraries.matrix.test.A_ROOM_ID +import io.element.android.libraries.matrix.test.A_SESSION_ID import io.element.android.libraries.matrix.test.A_USER_ID_2 import io.element.android.services.toolbox.api.systemclock.SystemClock import io.element.android.services.toolbox.test.systemclock.FakeSystemClock @@ -28,12 +29,12 @@ class RustNotificationServiceTest { @Test fun test() = runTest { val notificationClient = FakeRustNotificationClient( - notificationItemResult = aRustNotificationItem(), + notificationItemResult = mapOf(AN_EVENT_ID.value to aRustNotificationItem()), ) val sut = createRustNotificationService( notificationClient = notificationClient, ) - val result = sut.getNotification(A_ROOM_ID, AN_EVENT_ID).getOrThrow()!! + val result = sut.getNotifications(mapOf(A_ROOM_ID to listOf(AN_EVENT_ID))).getOrThrow()[AN_EVENT_ID]!! assertThat(result.isEncrypted).isTrue() assertThat(result.content).isEqualTo( NotificationContent.MessageLike.RoomMessage( @@ -51,6 +52,7 @@ class RustNotificationServiceTest { clock: SystemClock = FakeSystemClock(), ) = RustNotificationService( + sessionId = A_SESSION_ID, notificationClient = notificationClient, dispatchers = testCoroutineDispatchers(), clock = clock, diff --git a/libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/notification/FakeNotificationService.kt b/libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/notification/FakeNotificationService.kt index 38a8c79e175..4a9671f6773 100644 --- a/libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/notification/FakeNotificationService.kt +++ b/libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/notification/FakeNotificationService.kt @@ -13,16 +13,13 @@ import io.element.android.libraries.matrix.api.notification.NotificationData import io.element.android.libraries.matrix.api.notification.NotificationService class FakeNotificationService : NotificationService { - private var getNotificationResult: Result = Result.success(null) + private var getNotificationsResult: Result> = Result.success(emptyMap()) - fun givenGetNotificationResult(result: Result) { - getNotificationResult = result + fun givenGetNotificationsResult(result: Result>) { + getNotificationsResult = result } - override suspend fun getNotification( - roomId: RoomId, - eventId: EventId, - ): Result { - return getNotificationResult + override suspend fun getNotifications(ids: Map>): Result> { + return getNotificationsResult } } diff --git a/libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/notification/NotificationData.kt b/libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/notification/NotificationData.kt index 85473d9367f..2bfd54954b7 100644 --- a/libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/notification/NotificationData.kt +++ b/libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/notification/NotificationData.kt @@ -13,6 +13,7 @@ import io.element.android.libraries.matrix.api.notification.NotificationData import io.element.android.libraries.matrix.test.AN_EVENT_ID import io.element.android.libraries.matrix.test.A_ROOM_ID import io.element.android.libraries.matrix.test.A_ROOM_NAME +import io.element.android.libraries.matrix.test.A_SESSION_ID import io.element.android.libraries.matrix.test.A_TIMESTAMP import io.element.android.libraries.matrix.test.A_USER_NAME_2 @@ -27,6 +28,7 @@ fun aNotificationData( roomDisplayName: String? = A_ROOM_NAME ): NotificationData { return NotificationData( + sessionId = A_SESSION_ID, eventId = AN_EVENT_ID, threadId = threadId, roomId = A_ROOM_ID, diff --git a/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/DefaultNotifiableEventResolver.kt b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/DefaultNotifiableEventResolver.kt index 982daec73e3..6ee03ed4185 100644 --- a/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/DefaultNotifiableEventResolver.kt +++ b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/DefaultNotifiableEventResolver.kt @@ -11,10 +11,10 @@ import android.content.Context import android.net.Uri import androidx.core.content.FileProvider import com.squareup.anvil.annotations.ContributesBinding -import io.element.android.libraries.core.extensions.flatMap import io.element.android.libraries.core.log.logger.LoggerTag import io.element.android.libraries.di.AppScope import io.element.android.libraries.di.ApplicationContext +import io.element.android.libraries.di.SingleIn import io.element.android.libraries.matrix.api.MatrixClient import io.element.android.libraries.matrix.api.MatrixClientProvider import io.element.android.libraries.matrix.api.core.EventId @@ -61,10 +61,14 @@ private val loggerTag = LoggerTag("DefaultNotifiableEventResolver", LoggerTag.No * this pattern allow decoupling between the object responsible of displaying notifications and the matrix sdk. */ interface NotifiableEventResolver { - suspend fun resolveEvent(sessionId: SessionId, roomId: RoomId, eventId: EventId): Result + suspend fun resolveEvents( + sessionId: SessionId, + notificationEventRequests: List + ): Result>> } @ContributesBinding(AppScope::class) +@SingleIn(AppScope::class) class DefaultNotifiableEventResolver @Inject constructor( private val stringProvider: StringProvider, private val clock: SystemClock, @@ -75,29 +79,34 @@ class DefaultNotifiableEventResolver @Inject constructor( private val callNotificationEventResolver: CallNotificationEventResolver, private val appPreferencesStore: AppPreferencesStore, ) : NotifiableEventResolver { - override suspend fun resolveEvent(sessionId: SessionId, roomId: RoomId, eventId: EventId): Result { - // Restore session - val client = matrixClientProvider.getOrRestore(sessionId).getOrNull() ?: return Result.failure( - ResolvingException("Unable to restore session for $sessionId") - ) - val notificationService = client.notificationService() - val notificationData = notificationService.getNotification( - roomId = roomId, - eventId = eventId, - ).onFailure { - Timber.tag(loggerTag.value).e(it, "Unable to resolve event: $eventId.") + override suspend fun resolveEvents( + sessionId: SessionId, + notificationEventRequests: List + ): Result>> { + Timber.d("Queueing notifications: $notificationEventRequests") + val client = matrixClientProvider.getOrRestore(sessionId).getOrElse { + return Result.failure(IllegalStateException("Couldn't get or restore client for session $sessionId")) } + val ids = notificationEventRequests.groupBy { it.roomId }.mapValues { (_, value) -> value.map { it.eventId } } // TODO this notificationData is not always valid at the moment, sometimes the Rust SDK can't fetch the matching event - return notificationData.flatMap { - if (it == null) { - Timber.tag(loggerTag.value).d("No notification data found for event $eventId") - return@flatMap Result.failure(ResolvingException("Unable to resolve event $eventId")) - } else { - Timber.tag(loggerTag.value).d("Found notification item for $eventId") - it.asNotifiableEvent(client, sessionId) + val notifications = client.notificationService().getNotifications(ids).mapCatching { map -> + map.mapValues { (_, notificationData) -> + notificationData.asNotifiableEvent(client, sessionId) } } + + return Result.success( + notificationEventRequests.associate { + val notificationData = notifications.getOrNull()?.get(it.eventId) + if (notificationData != null) { + it to notificationData + } else { + // TODO once the SDK can actually return what went wrong, we should return it here instead of this generic error + it to Result.failure(ResolvingException("No notification data for ${it.roomId} - ${it.eventId}")) + } + } + ) } private suspend fun NotificationData.asNotifiableEvent( diff --git a/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/DefaultNotificationDrawerManager.kt b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/DefaultNotificationDrawerManager.kt index 93e4bd85e5d..f485ba29542 100644 --- a/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/DefaultNotificationDrawerManager.kt +++ b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/DefaultNotificationDrawerManager.kt @@ -113,6 +113,11 @@ class DefaultNotificationDrawerManager @Inject constructor( renderEvents(listOf(notifiableEvent)) } + suspend fun onNotifiableEventsReceived(notifiableEvents: List) { + val eventsToNotify = notifiableEvents.filter { !it.shouldIgnoreEventInRoom(appNavigationStateService.appNavigationState.value) } + renderEvents(eventsToNotify) + } + /** * Clear all known message events for a [sessionId]. */ diff --git a/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/DefaultOnMissedCallNotificationHandler.kt b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/DefaultOnMissedCallNotificationHandler.kt index 03a9c717d86..1efe57ce065 100644 --- a/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/DefaultOnMissedCallNotificationHandler.kt +++ b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/DefaultOnMissedCallNotificationHandler.kt @@ -30,8 +30,9 @@ class DefaultOnMissedCallNotificationHandler @Inject constructor( // Resolve the event and add a notification for it, at this point it should no longer be a ringing one val notificationData = matrixClientProvider.getOrRestore(sessionId).getOrNull() ?.notificationService() - ?.getNotification(roomId, eventId) + ?.getNotifications(mapOf(roomId to listOf(eventId))) ?.getOrNull() + ?.get(eventId) ?: return val notifiableEvent = callNotificationEventResolver.resolveEvent( diff --git a/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/NotificationBroadcastReceiverHandler.kt b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/NotificationBroadcastReceiverHandler.kt index 9c899c9dfd0..1544efb5179 100644 --- a/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/NotificationBroadcastReceiverHandler.kt +++ b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/NotificationBroadcastReceiverHandler.kt @@ -159,7 +159,7 @@ class NotificationBroadcastReceiverHandler @Inject constructor( roomIsDm = room.isDm(), outGoingMessage = true, ) - onNotifiableEventReceived.onNotifiableEventReceived(notifiableMessageEvent) + onNotifiableEventReceived.onNotifiableEventsReceived(listOf(notifiableMessageEvent)) if (threadId != null && replyToEventId != null) { room.liveTimeline.replyMessage( @@ -177,9 +177,11 @@ class NotificationBroadcastReceiverHandler @Inject constructor( ) }.onFailure { Timber.e(it, "Failed to send smart reply message") - onNotifiableEventReceived.onNotifiableEventReceived( - notifiableMessageEvent.copy( - outGoingMessageFailed = true + onNotifiableEventReceived.onNotifiableEventsReceived( + listOf( + notifiableMessageEvent.copy( + outGoingMessageFailed = true + ) ) ) } diff --git a/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/NotificationDisplayer.kt b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/NotificationDisplayer.kt index 09bfbb51ba4..88e6021cc43 100644 --- a/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/NotificationDisplayer.kt +++ b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/NotificationDisplayer.kt @@ -37,6 +37,7 @@ class DefaultNotificationDisplayer @Inject constructor( return false } notificationManager.notify(tag, id, notification) + Timber.d("Notifying with tag: $tag, id: $id") return true } diff --git a/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/NotificationResolverQueue.kt b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/NotificationResolverQueue.kt new file mode 100644 index 00000000000..fccd4df0274 --- /dev/null +++ b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/NotificationResolverQueue.kt @@ -0,0 +1,105 @@ +/* + * Copyright 2025 New Vector Ltd. + * + * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial + * Please see LICENSE files in the repository root for full details. + */ + +package io.element.android.libraries.push.impl.notifications + +import io.element.android.libraries.di.AppScope +import io.element.android.libraries.di.SingleIn +import io.element.android.libraries.matrix.api.core.EventId +import io.element.android.libraries.matrix.api.core.RoomId +import io.element.android.libraries.matrix.api.core.SessionId +import io.element.android.libraries.push.impl.notifications.model.ResolvedPushEvent +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.Job +import kotlinx.coroutines.channels.Channel +import kotlinx.coroutines.delay +import kotlinx.coroutines.flow.MutableSharedFlow +import kotlinx.coroutines.flow.SharedFlow +import kotlinx.coroutines.isActive +import kotlinx.coroutines.launch +import timber.log.Timber +import javax.inject.Inject +import kotlin.time.Duration.Companion.milliseconds + +/** + * This class is responsible for periodically batching notification requests and resolving them in a single call, + * so that we can avoid having to resolve each notification individually in the SDK. + */ +@OptIn(ExperimentalCoroutinesApi::class) +@SingleIn(AppScope::class) +class NotificationResolverQueue @Inject constructor( + private val notifiableEventResolver: NotifiableEventResolver, + private val coroutineScope: CoroutineScope, +) { + companion object { + private const val BATCH_WINDOW_MS = 250L + } + private val requestQueue = Channel(capacity = 100) + + private var currentProcessingJob: Job? = null + + /** + * A flow that emits pairs of a list of notification event requests and a map of the resolved events. + * The map contains the original request as the key and the resolved event as the value. + */ + val results: SharedFlow, Map>>> = MutableSharedFlow() + + /** + * Enqueues a notification event request to be resolved. + * The request will be processed in batches, so it may not be resolved immediately. + * + * @param request The notification event request to enqueue. + */ + suspend fun enqueue(request: NotificationEventRequest) { + // Cancel previous processing job if it exists, acting as a debounce operation + Timber.d("Cancelling job: $currentProcessingJob") + currentProcessingJob?.cancel() + + // Enqueue the request and start a delayed processing job + requestQueue.send(request) + currentProcessingJob = processQueue() + Timber.d("Starting processing job for request: $request") + } + + private fun processQueue() = coroutineScope.launch { + if (!isActive) return@launch + + delay(BATCH_WINDOW_MS.milliseconds) + + if (!isActive) return@launch + + // If this job is still active (so this is the latest job), we launch a separate one that won't be cancelled when enqueueing new items + // to process the existing queued items. + coroutineScope.launch { + val groupedRequestsById = buildList { + while (!requestQueue.isEmpty) { + requestQueue.receiveCatching().getOrNull()?.let(this::add) + } + }.groupBy { it.sessionId } + + val sessionIds = groupedRequestsById.keys + for (sessionId in sessionIds) { + val requests = groupedRequestsById[sessionId].orEmpty() + Timber.d("Fetching notifications for $sessionId: $requests. Pending requests: ${!requestQueue.isEmpty}") + // Resolving the events in parallel should improve performance since each session id will query a different Client + launch { + // No need for a Mutex since the SDK already has one internally + val notifications = notifiableEventResolver.resolveEvents(sessionId, requests).getOrNull().orEmpty() + (results as MutableSharedFlow).emit(requests to notifications) + } + } + } + } +} + +data class NotificationEventRequest( + val sessionId: SessionId, + val roomId: RoomId, + val eventId: EventId, + val providerInfo: String, +) diff --git a/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/model/ResolvedPushEvent.kt b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/model/ResolvedPushEvent.kt index 48e2af6e980..2363e38e1d7 100644 --- a/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/model/ResolvedPushEvent.kt +++ b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/notifications/model/ResolvedPushEvent.kt @@ -12,12 +12,22 @@ import io.element.android.libraries.matrix.api.core.RoomId import io.element.android.libraries.matrix.api.core.SessionId sealed interface ResolvedPushEvent { - data class Event(val notifiableEvent: NotifiableEvent) : ResolvedPushEvent + val sessionId: SessionId + val roomId: RoomId + val eventId: EventId + + data class Event(val notifiableEvent: NotifiableEvent) : ResolvedPushEvent { + override val sessionId: SessionId = notifiableEvent.sessionId + override val roomId: RoomId = notifiableEvent.roomId + override val eventId: EventId = notifiableEvent.eventId + } data class Redaction( - val sessionId: SessionId, - val roomId: RoomId, + override val sessionId: SessionId, + override val roomId: RoomId, val redactedEventId: EventId, val reason: String?, - ) : ResolvedPushEvent + ) : ResolvedPushEvent { + override val eventId: EventId = redactedEventId + } } diff --git a/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/push/DefaultPushHandler.kt b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/push/DefaultPushHandler.kt index f6b6ace8664..19b060d36b9 100644 --- a/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/push/DefaultPushHandler.kt +++ b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/push/DefaultPushHandler.kt @@ -13,6 +13,7 @@ import io.element.android.features.call.api.ElementCallEntryPoint import io.element.android.libraries.core.log.logger.LoggerTag import io.element.android.libraries.core.meta.BuildMeta import io.element.android.libraries.di.AppScope +import io.element.android.libraries.di.SingleIn import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService import io.element.android.libraries.push.impl.history.PushHistoryService import io.element.android.libraries.push.impl.history.onDiagnosticPush @@ -20,8 +21,10 @@ import io.element.android.libraries.push.impl.history.onInvalidPushReceived import io.element.android.libraries.push.impl.history.onSuccess import io.element.android.libraries.push.impl.history.onUnableToResolveEvent import io.element.android.libraries.push.impl.history.onUnableToRetrieveSession -import io.element.android.libraries.push.impl.notifications.NotifiableEventResolver +import io.element.android.libraries.push.impl.notifications.NotificationEventRequest +import io.element.android.libraries.push.impl.notifications.NotificationResolverQueue import io.element.android.libraries.push.impl.notifications.channels.NotificationChannels +import io.element.android.libraries.push.impl.notifications.model.NotifiableEvent import io.element.android.libraries.push.impl.notifications.model.NotifiableRingingCallEvent import io.element.android.libraries.push.impl.notifications.model.ResolvedPushEvent import io.element.android.libraries.push.impl.test.DefaultTestPush @@ -30,17 +33,21 @@ import io.element.android.libraries.pushproviders.api.PushData import io.element.android.libraries.pushproviders.api.PushHandler import io.element.android.libraries.pushstore.api.UserPushStoreFactory import io.element.android.libraries.pushstore.api.clientsecret.PushClientSecret +import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.flow.first +import kotlinx.coroutines.flow.launchIn +import kotlinx.coroutines.flow.map +import kotlinx.coroutines.launch import timber.log.Timber import javax.inject.Inject private val loggerTag = LoggerTag("PushHandler", LoggerTag.PushLoggerTag) +@SingleIn(AppScope::class) @ContributesBinding(AppScope::class) class DefaultPushHandler @Inject constructor( private val onNotifiableEventReceived: OnNotifiableEventReceived, private val onRedactedEventReceived: OnRedactedEventReceived, - private val notifiableEventResolver: NotifiableEventResolver, private val incrementPushDataStore: IncrementPushDataStore, private val userPushStoreFactory: UserPushStoreFactory, private val pushClientSecret: PushClientSecret, @@ -50,7 +57,85 @@ class DefaultPushHandler @Inject constructor( private val elementCallEntryPoint: ElementCallEntryPoint, private val notificationChannels: NotificationChannels, private val pushHistoryService: PushHistoryService, + private val resolverQueue: NotificationResolverQueue, + private val appCoroutineScope: CoroutineScope, ) : PushHandler { + init { + processPushEventResults() + } + + /** + * Process the push notification event results emitted by the [resolverQueue]. + */ + private fun processPushEventResults() { + resolverQueue.results + .map { (requests, resolvedEvents) -> + for (request in requests) { + // Log the result of the push notification event + val result = resolvedEvents[request] + if (result?.isSuccess == true) { + pushHistoryService.onSuccess( + providerInfo = request.providerInfo, + eventId = request.eventId, + roomId = request.roomId, + sessionId = request.sessionId, + comment = "Push handled successfully", + ) + } else { + pushHistoryService.onUnableToResolveEvent( + providerInfo = request.providerInfo, + eventId = request.eventId, + roomId = request.roomId, + sessionId = request.sessionId, + reason = "Push not handled", + ) + } + } + + val events = mutableListOf() + val redactions = mutableListOf() + + @Suppress("LoopWithTooManyJumpStatements") + for (result in resolvedEvents.values) { + val event = result.getOrNull() ?: continue + val userPushStore = userPushStoreFactory.getOrCreate(event.sessionId) + val areNotificationsEnabled = userPushStore.getNotificationEnabledForDevice().first() + // If notifications are disabled for this session and device, we don't want to show the notification + // But if it's a ringing call, we want to show it anyway + val isRingingCall = (event as? ResolvedPushEvent.Event)?.notifiableEvent is NotifiableRingingCallEvent + if (!areNotificationsEnabled && !isRingingCall) continue + + // We categorise each result into either a NotifiableEvent or a Redaction + when (event) { + is ResolvedPushEvent.Event -> { + events.add(event.notifiableEvent) + } + is ResolvedPushEvent.Redaction -> { + redactions.add(event) + } + } + } + + // Process redactions of messages + if (redactions.isNotEmpty()) { + onRedactedEventReceived.onRedactedEventsReceived(redactions) + } + + // Find and process ringing call notifications separately + val (ringingCallEvents, nonRingingCallEvents) = events.partition { it is NotifiableRingingCallEvent } + for (ringingCallEvent in ringingCallEvents) { + Timber.tag(loggerTag.value).d("Ringing call event: $ringingCallEvent") + handleRingingCallEvent(ringingCallEvent as NotifiableRingingCallEvent) + } + + // Finally, process other notifications (messages, invites, generic notifications, etc.) + if (nonRingingCallEvents.isNotEmpty()) { + onNotifiableEventReceived.onNotifiableEventsReceived(nonRingingCallEvents) + } + } + .launchIn(appCoroutineScope) + } + /** * Called when message is received. * @@ -119,52 +204,17 @@ class DefaultPushHandler @Inject constructor( ) return } - notifiableEventResolver.resolveEvent(userId, pushData.roomId, pushData.eventId).fold( - onSuccess = { resolvedPushEvent -> - pushHistoryService.onSuccess( - providerInfo = providerInfo, - eventId = pushData.eventId, - roomId = pushData.roomId, - sessionId = userId, - comment = resolvedPushEvent.javaClass.simpleName, - ) - - when (resolvedPushEvent) { - is ResolvedPushEvent.Event -> { - when (val notifiableEvent = resolvedPushEvent.notifiableEvent) { - is NotifiableRingingCallEvent -> { - Timber.tag(loggerTag.value).d("Notifiable event ${pushData.eventId} is ringing call: $notifiableEvent") - onNotifiableEventReceived.onNotifiableEventReceived(notifiableEvent) - handleRingingCallEvent(notifiableEvent) - } - else -> { - Timber.tag(loggerTag.value).d("Notifiable event ${pushData.eventId} is normal event: $notifiableEvent") - val userPushStore = userPushStoreFactory.getOrCreate(userId) - val areNotificationsEnabled = userPushStore.getNotificationEnabledForDevice().first() - if (areNotificationsEnabled) { - onNotifiableEventReceived.onNotifiableEventReceived(notifiableEvent) - } else { - Timber.tag(loggerTag.value).i("Notification are disabled for this device, ignore push.") - } - } - } - } - is ResolvedPushEvent.Redaction -> { - onRedactedEventReceived.onRedactedEventReceived(resolvedPushEvent) - } - } - }, - onFailure = { failure -> - Timber.tag(loggerTag.value).w(failure, "Unable to get a notification data") - pushHistoryService.onUnableToResolveEvent( - providerInfo = providerInfo, - eventId = pushData.eventId, - roomId = pushData.roomId, - sessionId = userId, - reason = failure.message ?: failure.javaClass.simpleName, - ) - } - ) + + appCoroutineScope.launch { + val notificationEventRequest = NotificationEventRequest( + sessionId = userId, + roomId = pushData.roomId, + eventId = pushData.eventId, + providerInfo = providerInfo, + ) + Timber.d("Queueing notification: $notificationEventRequest") + resolverQueue.enqueue(notificationEventRequest) + } } catch (e: Exception) { Timber.tag(loggerTag.value).e(e, "## handleInternal() failed") } diff --git a/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/push/OnNotifiableEventReceived.kt b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/push/OnNotifiableEventReceived.kt index 7269dbcff77..14cb3d8ac64 100644 --- a/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/push/OnNotifiableEventReceived.kt +++ b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/push/OnNotifiableEventReceived.kt @@ -17,7 +17,7 @@ import kotlinx.coroutines.launch import javax.inject.Inject interface OnNotifiableEventReceived { - fun onNotifiableEventReceived(notifiableEvent: NotifiableEvent) + fun onNotifiableEventsReceived(notifiableEvents: List) } @ContributesBinding(AppScope::class) @@ -26,12 +26,10 @@ class DefaultOnNotifiableEventReceived @Inject constructor( private val coroutineScope: CoroutineScope, private val syncOnNotifiableEvent: SyncOnNotifiableEvent, ) : OnNotifiableEventReceived { - override fun onNotifiableEventReceived(notifiableEvent: NotifiableEvent) { + override fun onNotifiableEventsReceived(notifiableEvents: List) { coroutineScope.launch { - launch { syncOnNotifiableEvent(notifiableEvent) } - if (notifiableEvent !is NotifiableRingingCallEvent) { - defaultNotificationDrawerManager.onNotifiableEventReceived(notifiableEvent) - } + launch { syncOnNotifiableEvent(notifiableEvents) } + defaultNotificationDrawerManager.onNotifiableEventsReceived(notifiableEvents.filter { it !is NotifiableRingingCallEvent }) } } } diff --git a/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/push/OnRedactedEventReceived.kt b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/push/OnRedactedEventReceived.kt index bf452bd3b7b..8cf77b18988 100644 --- a/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/push/OnRedactedEventReceived.kt +++ b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/push/OnRedactedEventReceived.kt @@ -29,7 +29,7 @@ import timber.log.Timber import javax.inject.Inject interface OnRedactedEventReceived { - fun onRedactedEventReceived(redaction: ResolvedPushEvent.Redaction) + fun onRedactedEventsReceived(redactions: List) } @ContributesBinding(AppScope::class) @@ -40,48 +40,54 @@ class DefaultOnRedactedEventReceived @Inject constructor( @ApplicationContext private val context: Context, private val stringProvider: StringProvider, ) : OnRedactedEventReceived { - override fun onRedactedEventReceived(redaction: ResolvedPushEvent.Redaction) { + override fun onRedactedEventsReceived(redactions: List) { coroutineScope.launch { - val notifications = activeNotificationsProvider.getMessageNotificationsForRoom( - redaction.sessionId, - redaction.roomId, - ) - if (notifications.isEmpty()) { - Timber.d("No notifications found for redacted event") + val redactionsBySessionIdAndRoom = redactions.groupBy { redaction -> + redaction.sessionId to redaction.roomId } - notifications.forEach { statusBarNotification -> - val notification = statusBarNotification.notification - val messagingStyle = MessagingStyle.extractMessagingStyleFromNotification(notification) - if (messagingStyle == null) { - Timber.w("Unable to retrieve messaging style from notification") - return@forEach - } - val messageToRedactIndex = messagingStyle.messages.indexOfFirst { message -> - message.extras.getString(DefaultNotificationCreator.MESSAGE_EVENT_ID) == redaction.redactedEventId.value - } - if (messageToRedactIndex == -1) { - Timber.d("Unable to find the message to remove from notification") - return@forEach + for ((keys, roomRedactions) in redactionsBySessionIdAndRoom) { + val (sessionId, roomId) = keys + val notifications = activeNotificationsProvider.getMessageNotificationsForRoom( + sessionId, + roomId, + ) + if (notifications.isEmpty()) { + Timber.d("No notifications found for redacted event") } - val oldMessage = messagingStyle.messages[messageToRedactIndex] - val content = buildSpannedString { - inSpans(StyleSpan(Typeface.ITALIC)) { - append(stringProvider.getString(CommonStrings.common_message_removed)) + notifications.forEach { statusBarNotification -> + val notification = statusBarNotification.notification + val messagingStyle = MessagingStyle.extractMessagingStyleFromNotification(notification) + if (messagingStyle == null) { + Timber.w("Unable to retrieve messaging style from notification") + return@forEach + } + val messageToRedactIndex = messagingStyle.messages.indexOfFirst { message -> + roomRedactions.any { it.redactedEventId.value == message.extras.getString(DefaultNotificationCreator.MESSAGE_EVENT_ID) } } + if (messageToRedactIndex == -1) { + Timber.d("Unable to find the message to remove from notification") + return@forEach + } + val oldMessage = messagingStyle.messages[messageToRedactIndex] + val content = buildSpannedString { + inSpans(StyleSpan(Typeface.ITALIC)) { + append(stringProvider.getString(CommonStrings.common_message_removed)) + } + } + val newMessage = MessagingStyle.Message( + content, + oldMessage.timestamp, + oldMessage.person + ) + messagingStyle.messages[messageToRedactIndex] = newMessage + notificationDisplayer.showNotificationMessage( + statusBarNotification.tag, + statusBarNotification.id, + NotificationCompat.Builder(context, notification) + .setStyle(messagingStyle) + .build() + ) } - val newMessage = MessagingStyle.Message( - content, - oldMessage.timestamp, - oldMessage.person - ) - messagingStyle.messages[messageToRedactIndex] = newMessage - notificationDisplayer.showNotificationMessage( - statusBarNotification.tag, - statusBarNotification.id, - NotificationCompat.Builder(context, notification) - .setStyle(messagingStyle) - .build() - ) } } } diff --git a/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/push/SyncOnNotifiableEvent.kt b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/push/SyncOnNotifiableEvent.kt index 4c5eee260b7..3c1f1a0f0ab 100644 --- a/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/push/SyncOnNotifiableEvent.kt +++ b/libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/push/SyncOnNotifiableEvent.kt @@ -8,15 +8,14 @@ package io.element.android.libraries.push.impl.push import io.element.android.libraries.core.coroutine.CoroutineDispatchers +import io.element.android.libraries.core.coroutine.parallelMap import io.element.android.libraries.featureflag.api.FeatureFlagService import io.element.android.libraries.featureflag.api.FeatureFlags import io.element.android.libraries.matrix.api.MatrixClientProvider import io.element.android.libraries.matrix.api.core.EventId -import io.element.android.libraries.matrix.api.room.BaseRoom import io.element.android.libraries.matrix.api.room.JoinedRoom import io.element.android.libraries.matrix.api.timeline.MatrixTimelineItem import io.element.android.libraries.push.impl.notifications.model.NotifiableEvent -import io.element.android.libraries.push.impl.notifications.model.NotifiableRingingCallEvent import io.element.android.services.appnavstate.api.AppForegroundStateService import kotlinx.coroutines.flow.first import kotlinx.coroutines.withContext @@ -31,41 +30,34 @@ class SyncOnNotifiableEvent @Inject constructor( private val appForegroundStateService: AppForegroundStateService, private val dispatchers: CoroutineDispatchers, ) { - suspend operator fun invoke(notifiableEvent: NotifiableEvent) = withContext(dispatchers.io) { - val isRingingCallEvent = notifiableEvent is NotifiableRingingCallEvent - if (!featureFlagService.isFeatureEnabled(FeatureFlags.SyncOnPush) && !isRingingCallEvent) { + suspend operator fun invoke(notifiableEvents: List) = withContext(dispatchers.io) { + if (!featureFlagService.isFeatureEnabled(FeatureFlags.SyncOnPush)) { return@withContext } - val client = matrixClientProvider.getOrRestore(notifiableEvent.sessionId).getOrNull() ?: return@withContext - client.getJoinedRoom(notifiableEvent.roomId)?.use { room -> - room.subscribeToSync() + try { + val eventsBySession = notifiableEvents.groupBy { it.sessionId } - // If the app is in foreground, sync is already running, so we just add the subscription above. - if (!appForegroundStateService.isInForeground.value) { - if (isRingingCallEvent) { - room.waitsUntilUserIsInTheCall(timeout = 60.seconds) - } else { - try { - appForegroundStateService.updateIsSyncingNotificationEvent(true) - room.waitsUntilEventIsKnown(eventId = notifiableEvent.eventId, timeout = 10.seconds) - } finally { - appForegroundStateService.updateIsSyncingNotificationEvent(false) + appForegroundStateService.updateIsSyncingNotificationEvent(true) + + for ((sessionId, events) in eventsBySession) { + val client = matrixClientProvider.getOrRestore(sessionId).getOrNull() ?: continue + val eventsByRoomId = events.groupBy { it.roomId } + + client.roomListService.subscribeToVisibleRooms(eventsByRoomId.keys.toList()) + + if (!appForegroundStateService.isInForeground.value) { + for ((roomId, eventsInRoom) in eventsByRoomId) { + client.getJoinedRoom(roomId)?.use { room -> + eventsInRoom.parallelMap { event -> + room.waitsUntilEventIsKnown(event.eventId, timeout = 10.seconds) + } + } } } } - } - } - - /** - * User can be in the call if they answer using another session. - * If the user does not join the call, the timeout will be reached. - */ - private suspend fun BaseRoom.waitsUntilUserIsInTheCall(timeout: Duration) { - withTimeoutOrNull(timeout) { - roomInfoFlow.first { - sessionId in it.activeRoomCallParticipants - } + } finally { + appForegroundStateService.updateIsSyncingNotificationEvent(false) } } diff --git a/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/notifications/DefaultNotifiableEventResolverTest.kt b/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/notifications/DefaultNotifiableEventResolverTest.kt index cf9244166d6..2ba00156c7c 100644 --- a/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/notifications/DefaultNotifiableEventResolverTest.kt +++ b/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/notifications/DefaultNotifiableEventResolverTest.kt @@ -9,6 +9,7 @@ package io.element.android.libraries.push.impl.notifications import android.content.Context import com.google.common.truth.Truth.assertThat +import io.element.android.libraries.matrix.api.core.EventId import io.element.android.libraries.matrix.api.media.MediaSource import io.element.android.libraries.matrix.api.notification.CallNotifyType import io.element.android.libraries.matrix.api.notification.NotificationContent @@ -67,7 +68,7 @@ class DefaultNotifiableEventResolverTest { @Test fun `resolve event no session`() = runTest { val sut = createDefaultNotifiableEventResolver(notificationService = null) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) + val result = sut.resolveEvents(A_SESSION_ID, listOf(NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase"))) assertThat(result.isFailure).isTrue() } @@ -76,36 +77,31 @@ class DefaultNotifiableEventResolverTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.failure(AN_EXCEPTION) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) - assertThat(result.isFailure).isTrue() - } - - @Test - fun `resolve event null`() = runTest { - val sut = createDefaultNotifiableEventResolver( - notificationResult = Result.success(null) - ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) - assertThat(result.isFailure).isTrue() + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) + assertThat(result.getEvent(request)?.isFailure).isTrue() } @Test fun `resolve event message text`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.MessageLike.RoomMessage( - senderId = A_USER_ID_2, - messageType = TextMessageType(body = "Hello world", formatted = null) - ), + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.MessageLike.RoomMessage( + senderId = A_USER_ID_2, + messageType = TextMessageType(body = "Hello world", formatted = null) + ), + ) ) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) val expectedResult = ResolvedPushEvent.Event( aNotifiableMessageEvent(body = "Hello world") ) - assertThat(result.getOrNull()).isEqualTo(expectedResult) + assertThat(result.getEvent(request)).isEqualTo(Result.success(expectedResult)) } @Test @@ -113,292 +109,337 @@ class DefaultNotifiableEventResolverTest { fun `resolve event message with mention`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.MessageLike.RoomMessage( - senderId = A_USER_ID_2, - messageType = TextMessageType(body = "Hello world", formatted = null) - ), - hasMention = true, + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.MessageLike.RoomMessage( + senderId = A_USER_ID_2, + messageType = TextMessageType(body = "Hello world", formatted = null) + ), + hasMention = true, + ) ) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) val expectedResult = ResolvedPushEvent.Event( aNotifiableMessageEvent(body = "Hello world", hasMentionOrReply = true) ) - assertThat(result.getOrNull()).isEqualTo(expectedResult) + assertThat(result.getEvent(request)).isEqualTo(Result.success(expectedResult)) } @Test fun `resolve HTML formatted event message text takes plain text version`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.MessageLike.RoomMessage( - senderId = A_USER_ID_2, - messageType = TextMessageType( - body = "Hello world!", - formatted = FormattedBody( - body = "Hello world", - format = MessageFormat.HTML, + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.MessageLike.RoomMessage( + senderId = A_USER_ID_2, + messageType = TextMessageType( + body = "Hello world!", + formatted = FormattedBody( + body = "Hello world", + format = MessageFormat.HTML, + ) ) - ) - ), + ), + ) ) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) val expectedResult = ResolvedPushEvent.Event( aNotifiableMessageEvent(body = "Hello world") ) - assertThat(result.getOrNull()).isEqualTo(expectedResult) + assertThat(result.getEvent(request)).isEqualTo(Result.success(expectedResult)) } @Test fun `resolve incorrectly formatted event message text uses fallback`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.MessageLike.RoomMessage( - senderId = A_USER_ID_2, - messageType = TextMessageType( - body = "Hello world", - formatted = FormattedBody( - body = "???Hello world!???", - format = MessageFormat.UNKNOWN, + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.MessageLike.RoomMessage( + senderId = A_USER_ID_2, + messageType = TextMessageType( + body = "Hello world", + formatted = FormattedBody( + body = "???Hello world!???", + format = MessageFormat.UNKNOWN, + ) ) - ) - ), + ), + ) ) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) val expectedResult = ResolvedPushEvent.Event( aNotifiableMessageEvent(body = "Hello world") ) - assertThat(result.getOrNull()).isEqualTo(expectedResult) + assertThat(result.getEvent(request)).isEqualTo(Result.success(expectedResult)) } @Test fun `resolve event message audio`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.MessageLike.RoomMessage( - senderId = A_USER_ID_2, - messageType = AudioMessageType("Audio", null, null, MediaSource("url"), null) - ), + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.MessageLike.RoomMessage( + senderId = A_USER_ID_2, + messageType = AudioMessageType("Audio", null, null, MediaSource("url"), null) + ), + ) ) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) val expectedResult = ResolvedPushEvent.Event( aNotifiableMessageEvent(body = "Audio") ) - assertThat(result.getOrNull()).isEqualTo(expectedResult) + assertThat(result.getEvent(request)).isEqualTo(Result.success(expectedResult)) } @Test fun `resolve event message video`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.MessageLike.RoomMessage( - senderId = A_USER_ID_2, - messageType = VideoMessageType("Video", null, null, MediaSource("url"), null) - ), + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.MessageLike.RoomMessage( + senderId = A_USER_ID_2, + messageType = VideoMessageType("Video", null, null, MediaSource("url"), null) + ), + ) ) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) val expectedResult = ResolvedPushEvent.Event( aNotifiableMessageEvent(body = "Video") ) - assertThat(result.getOrNull()).isEqualTo(expectedResult) + assertThat(result.getEvent(request)).isEqualTo(Result.success(expectedResult)) } @Test fun `resolve event message voice`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.MessageLike.RoomMessage( - senderId = A_USER_ID_2, - messageType = VoiceMessageType("Voice", null, null, MediaSource("url"), null, null) - ), + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.MessageLike.RoomMessage( + senderId = A_USER_ID_2, + messageType = VoiceMessageType("Voice", null, null, MediaSource("url"), null, null) + ), + ) ) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) val expectedResult = ResolvedPushEvent.Event( aNotifiableMessageEvent(body = "Voice message") ) - assertThat(result.getOrNull()).isEqualTo(expectedResult) + assertThat(result.getEvent(request)).isEqualTo(Result.success(expectedResult)) } @Test fun `resolve event message image`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.MessageLike.RoomMessage( - senderId = A_USER_ID_2, - messageType = ImageMessageType("Image", null, null, MediaSource("url"), null), - ), + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.MessageLike.RoomMessage( + senderId = A_USER_ID_2, + messageType = ImageMessageType("Image", null, null, MediaSource("url"), null), + ), + ) ) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) val expectedResult = ResolvedPushEvent.Event( aNotifiableMessageEvent(body = "Image") ) - assertThat(result.getOrNull()).isEqualTo(expectedResult) + assertThat(result.getEvent(request)).isEqualTo(Result.success(expectedResult)) } @Test fun `resolve event message sticker`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.MessageLike.RoomMessage( - senderId = A_USER_ID_2, - messageType = StickerMessageType("Sticker", null, null, MediaSource("url"), null), - ), + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.MessageLike.RoomMessage( + senderId = A_USER_ID_2, + messageType = StickerMessageType("Sticker", null, null, MediaSource("url"), null), + ), + ) ) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) val expectedResult = ResolvedPushEvent.Event( aNotifiableMessageEvent(body = "Sticker") ) - assertThat(result.getOrNull()).isEqualTo(expectedResult) + assertThat(result.getEvent(request)).isEqualTo(Result.success(expectedResult)) } @Test fun `resolve event message file`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.MessageLike.RoomMessage( - senderId = A_USER_ID_2, - messageType = FileMessageType("File", null, null, MediaSource("url"), null), - ), + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.MessageLike.RoomMessage( + senderId = A_USER_ID_2, + messageType = FileMessageType("File", null, null, MediaSource("url"), null), + ), + ) ) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) val expectedResult = ResolvedPushEvent.Event( aNotifiableMessageEvent(body = "File") ) - assertThat(result.getOrNull()).isEqualTo(expectedResult) + assertThat(result.getEvent(request)).isEqualTo(Result.success(expectedResult)) } @Test fun `resolve event message location`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.MessageLike.RoomMessage( - senderId = A_USER_ID_2, - messageType = LocationMessageType("Location", "geo:1,2", null), - ), + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.MessageLike.RoomMessage( + senderId = A_USER_ID_2, + messageType = LocationMessageType("Location", "geo:1,2", null), + ), + ) ) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) val expectedResult = ResolvedPushEvent.Event( aNotifiableMessageEvent(body = "Location") ) - assertThat(result.getOrNull()).isEqualTo(expectedResult) + assertThat(result.getEvent(request)).isEqualTo(Result.success(expectedResult)) } @Test fun `resolve event message notice`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.MessageLike.RoomMessage( - senderId = A_USER_ID_2, - messageType = NoticeMessageType("Notice", null), - ), + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.MessageLike.RoomMessage( + senderId = A_USER_ID_2, + messageType = NoticeMessageType("Notice", null), + ), + ) ) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) val expectedResult = ResolvedPushEvent.Event( aNotifiableMessageEvent(body = "Notice") ) - assertThat(result.getOrNull()).isEqualTo(expectedResult) + assertThat(result.getEvent(request)).isEqualTo(Result.success(expectedResult)) } @Test fun `resolve event message emote`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.MessageLike.RoomMessage( - senderId = A_USER_ID_2, - messageType = EmoteMessageType("is happy", null), - ), + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.MessageLike.RoomMessage( + senderId = A_USER_ID_2, + messageType = EmoteMessageType("is happy", null), + ), + ) ) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) val expectedResult = ResolvedPushEvent.Event( aNotifiableMessageEvent(body = "* Bob is happy") ) - assertThat(result.getOrNull()).isEqualTo(expectedResult) + assertThat(result.getEvent(request)).isEqualTo(Result.success(expectedResult)) } @Test fun `resolve poll`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.MessageLike.Poll( - senderId = A_USER_ID_2, - question = "A question" - ), + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.MessageLike.Poll( + senderId = A_USER_ID_2, + question = "A question" + ), + ) ) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) val expectedResult = ResolvedPushEvent.Event( aNotifiableMessageEvent(body = "Poll: A question") ) - assertThat(result.getOrNull()).isEqualTo(expectedResult) + assertThat(result.getEvent(request)).isEqualTo(Result.success(expectedResult)) } @Test fun `resolve RoomMemberContent invite room`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.StateEvent.RoomMemberContent( - userId = A_USER_ID_2, - membershipState = RoomMembershipState.INVITE - ), - isDirect = false, + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.StateEvent.RoomMemberContent( + userId = A_USER_ID_2, + membershipState = RoomMembershipState.INVITE + ), + isDirect = false, + ) ) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) - assertThat(result.getOrNull()).isNull() + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) + assertThat(result.getEvent(request)?.getOrNull()).isNull() } @Test fun `resolve invite room`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.Invite( - senderId = A_USER_ID_2, - ), - isDirect = false, + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.Invite( + senderId = A_USER_ID_2, + ), + isDirect = false, + ) ) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) val expectedResult = ResolvedPushEvent.Event( InviteNotifiableEvent( sessionId = A_SESSION_ID, @@ -417,22 +458,25 @@ class DefaultNotifiableEventResolverTest { isUpdated = false, ) ) - assertThat(result.getOrNull()).isEqualTo(expectedResult) + assertThat(result.getEvent(request)).isEqualTo(Result.success(expectedResult)) } @Test fun `resolve invite direct`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.Invite( - senderId = A_USER_ID_2, - ), - isDirect = true, + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.Invite( + senderId = A_USER_ID_2, + ), + isDirect = true, + ) ) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) val expectedResult = ResolvedPushEvent.Event( InviteNotifiableEvent( sessionId = A_SESSION_ID, @@ -451,23 +495,26 @@ class DefaultNotifiableEventResolverTest { isUpdated = false, ) ) - assertThat(result.getOrNull()).isEqualTo(expectedResult) + assertThat(result.getEvent(request)).isEqualTo(Result.success(expectedResult)) } @Test fun `resolve invite direct, no display name`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.Invite( - senderId = A_USER_ID_2, - ), - isDirect = true, - senderDisplayName = null, + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.Invite( + senderId = A_USER_ID_2, + ), + isDirect = true, + senderDisplayName = null, + ) ) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) val expectedResult = ResolvedPushEvent.Event( InviteNotifiableEvent( sessionId = A_SESSION_ID, @@ -486,23 +533,26 @@ class DefaultNotifiableEventResolverTest { isUpdated = false, ) ) - assertThat(result.getOrNull()).isEqualTo(expectedResult) + assertThat(result.getEvent(request)).isEqualTo(Result.success(expectedResult)) } @Test fun `resolve invite direct, ambiguous display name`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.Invite( - senderId = A_USER_ID_2, - ), - isDirect = false, - senderIsNameAmbiguous = true, + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.Invite( + senderId = A_USER_ID_2, + ), + isDirect = false, + senderIsNameAmbiguous = true, + ) ) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) val expectedResult = ResolvedPushEvent.Event( InviteNotifiableEvent( sessionId = A_SESSION_ID, @@ -521,35 +571,37 @@ class DefaultNotifiableEventResolverTest { isUpdated = false, ) ) - assertThat(result.getOrNull()).isEqualTo(expectedResult) + assertThat(result.getEvent(request)).isEqualTo(Result.success(expectedResult)) } @Test fun `resolve RoomMemberContent other`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.StateEvent.RoomMemberContent( - userId = A_USER_ID_2, - membershipState = RoomMembershipState.JOIN + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.StateEvent.RoomMemberContent( + userId = A_USER_ID_2, + membershipState = RoomMembershipState.JOIN + ) ) ) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) - assertThat(result.getOrNull()).isNull() + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) + assertThat(result.getEvent(request)?.getOrNull()).isNull() } @Test fun `resolve RoomEncrypted`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.MessageLike.RoomEncrypted - ) + mapOf(AN_EVENT_ID to aNotificationData(content = NotificationContent.MessageLike.RoomEncrypted)) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) val expectedResult = ResolvedPushEvent.Event( FallbackNotifiableEvent( sessionId = A_SESSION_ID, @@ -563,19 +615,22 @@ class DefaultNotifiableEventResolverTest { timestamp = A_FAKE_TIMESTAMP, ) ) - assertThat(result.getOrNull()).isEqualTo(expectedResult) + assertThat(result.getEvent(request)).isEqualTo(Result.success(expectedResult)) } @Test fun `resolve CallInvite`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.MessageLike.CallInvite(A_USER_ID_2), + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.MessageLike.CallInvite(A_USER_ID_2), + ) ) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) val expectedResult = ResolvedPushEvent.Event( NotifiableMessageEvent( sessionId = A_SESSION_ID, @@ -601,7 +656,7 @@ class DefaultNotifiableEventResolverTest { isUpdated = false ) ) - assertThat(result.getOrNull()).isEqualTo(expectedResult) + assertThat(result.getEvent(request)).isEqualTo(Result.success(expectedResult)) } @Test @@ -609,11 +664,13 @@ class DefaultNotifiableEventResolverTest { val callNotificationEventResolver = FakeCallNotificationEventResolver() val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.MessageLike.CallNotify( - A_USER_ID_2, - CallNotifyType.NOTIFY - ), + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.MessageLike.CallNotify( + A_USER_ID_2, + CallNotifyType.NOTIFY + ), + ) ) ), callNotificationEventResolver = callNotificationEventResolver, @@ -639,18 +696,21 @@ class DefaultNotifiableEventResolverTest { ) ) callNotificationEventResolver.resolveEventLambda = { _, _, _ -> Result.success(expectedResult.notifiableEvent) } - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) - assertThat(result.getOrNull()).isEqualTo(expectedResult) + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) + assertThat(result.getEvent(request)).isEqualTo(Result.success(expectedResult)) } @Test fun `resolve RoomRedaction`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.MessageLike.RoomRedaction( - AN_EVENT_ID_2, - A_REDACTION_REASON, + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.MessageLike.RoomRedaction( + AN_EVENT_ID_2, + A_REDACTION_REASON, + ) ) ) ) @@ -661,82 +721,91 @@ class DefaultNotifiableEventResolverTest { redactedEventId = AN_EVENT_ID_2, reason = A_REDACTION_REASON, ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) - assertThat(result.getOrNull()).isEqualTo(expectedResult) + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) + assertThat(result.getEvent(request)).isEqualTo(Result.success(expectedResult)) } @Test fun `resolve RoomRedaction with null redactedEventId should return null`() = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = NotificationContent.MessageLike.RoomRedaction( - null, - A_REDACTION_REASON, + mapOf( + AN_EVENT_ID to aNotificationData( + content = NotificationContent.MessageLike.RoomRedaction( + null, + A_REDACTION_REASON, + ) ) ) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) - assertThat(result.isFailure).isTrue() + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) + assertThat(result.getEvent(request)?.getOrNull()).isNull() } @Test fun `resolve null cases`() { - testFailure(NotificationContent.MessageLike.CallAnswer) - testFailure(NotificationContent.MessageLike.CallHangup) - testFailure(NotificationContent.MessageLike.CallCandidates) - testFailure(NotificationContent.MessageLike.KeyVerificationReady) - testFailure(NotificationContent.MessageLike.KeyVerificationStart) - testFailure(NotificationContent.MessageLike.KeyVerificationCancel) - testFailure(NotificationContent.MessageLike.KeyVerificationAccept) - testFailure(NotificationContent.MessageLike.KeyVerificationKey) - testFailure(NotificationContent.MessageLike.KeyVerificationMac) - testFailure(NotificationContent.MessageLike.KeyVerificationDone) - testFailure(NotificationContent.MessageLike.ReactionContent(relatedEventId = AN_EVENT_ID_2.value)) - testFailure(NotificationContent.MessageLike.Sticker) - testFailure(NotificationContent.StateEvent.PolicyRuleRoom) - testFailure(NotificationContent.StateEvent.PolicyRuleServer) - testFailure(NotificationContent.StateEvent.PolicyRuleUser) - testFailure(NotificationContent.StateEvent.RoomAliases) - testFailure(NotificationContent.StateEvent.RoomAvatar) - testFailure(NotificationContent.StateEvent.RoomCanonicalAlias) - testFailure(NotificationContent.StateEvent.RoomCreate) - testFailure(NotificationContent.StateEvent.RoomEncryption) - testFailure(NotificationContent.StateEvent.RoomGuestAccess) - testFailure(NotificationContent.StateEvent.RoomHistoryVisibility) - testFailure(NotificationContent.StateEvent.RoomJoinRules) - testFailure(NotificationContent.StateEvent.RoomName) - testFailure(NotificationContent.StateEvent.RoomPinnedEvents) - testFailure(NotificationContent.StateEvent.RoomPowerLevels) - testFailure(NotificationContent.StateEvent.RoomServerAcl) - testFailure(NotificationContent.StateEvent.RoomThirdPartyInvite) - testFailure(NotificationContent.StateEvent.RoomTombstone) - testFailure(NotificationContent.StateEvent.RoomTopic("")) - testFailure(NotificationContent.StateEvent.SpaceChild) - testFailure(NotificationContent.StateEvent.SpaceParent) + testNoResults(NotificationContent.MessageLike.CallAnswer) + testNoResults(NotificationContent.MessageLike.CallHangup) + testNoResults(NotificationContent.MessageLike.CallCandidates) + testNoResults(NotificationContent.MessageLike.KeyVerificationReady) + testNoResults(NotificationContent.MessageLike.KeyVerificationStart) + testNoResults(NotificationContent.MessageLike.KeyVerificationCancel) + testNoResults(NotificationContent.MessageLike.KeyVerificationAccept) + testNoResults(NotificationContent.MessageLike.KeyVerificationKey) + testNoResults(NotificationContent.MessageLike.KeyVerificationMac) + testNoResults(NotificationContent.MessageLike.KeyVerificationDone) + testNoResults(NotificationContent.MessageLike.ReactionContent(relatedEventId = AN_EVENT_ID_2.value)) + testNoResults(NotificationContent.MessageLike.Sticker) + testNoResults(NotificationContent.StateEvent.PolicyRuleRoom) + testNoResults(NotificationContent.StateEvent.PolicyRuleServer) + testNoResults(NotificationContent.StateEvent.PolicyRuleUser) + testNoResults(NotificationContent.StateEvent.RoomAliases) + testNoResults(NotificationContent.StateEvent.RoomAvatar) + testNoResults(NotificationContent.StateEvent.RoomCanonicalAlias) + testNoResults(NotificationContent.StateEvent.RoomCreate) + testNoResults(NotificationContent.StateEvent.RoomEncryption) + testNoResults(NotificationContent.StateEvent.RoomGuestAccess) + testNoResults(NotificationContent.StateEvent.RoomHistoryVisibility) + testNoResults(NotificationContent.StateEvent.RoomJoinRules) + testNoResults(NotificationContent.StateEvent.RoomName) + testNoResults(NotificationContent.StateEvent.RoomPinnedEvents) + testNoResults(NotificationContent.StateEvent.RoomPowerLevels) + testNoResults(NotificationContent.StateEvent.RoomServerAcl) + testNoResults(NotificationContent.StateEvent.RoomThirdPartyInvite) + testNoResults(NotificationContent.StateEvent.RoomTombstone) + testNoResults(NotificationContent.StateEvent.RoomTopic("")) + testNoResults(NotificationContent.StateEvent.SpaceChild) + testNoResults(NotificationContent.StateEvent.SpaceParent) } - private fun testFailure(content: NotificationContent) = runTest { + private fun testNoResults(content: NotificationContent) = runTest { val sut = createDefaultNotifiableEventResolver( notificationResult = Result.success( - aNotificationData( - content = content - ) + mapOf(AN_EVENT_ID to aNotificationData(content = content)) ) ) - val result = sut.resolveEvent(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID) - assertThat(result.isFailure).isTrue() + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, "firebase") + val result = sut.resolveEvents(A_SESSION_ID, listOf(request)) + assertThat(result.getEvent(request)?.getOrNull()).isNull() + } + + private fun Result>>.getEvent( + request: NotificationEventRequest + ): Result? { + return getOrNull()?.get(request) } private fun createDefaultNotifiableEventResolver( notificationService: FakeNotificationService? = FakeNotificationService(), - notificationResult: Result = Result.success(null), + notificationResult: Result> = Result.success(emptyMap()), appPreferencesStore: AppPreferencesStore = InMemoryAppPreferencesStore(), callNotificationEventResolver: FakeCallNotificationEventResolver = FakeCallNotificationEventResolver(), ): DefaultNotifiableEventResolver { val context = RuntimeEnvironment.getApplication() as Context - notificationService?.givenGetNotificationResult(notificationResult) + notificationService?.givenGetNotificationsResult(notificationResult) val matrixClientProvider = FakeMatrixClientProvider(getClient = { if (notificationService == null) { Result.failure(IllegalStateException("Client not found")) diff --git a/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/notifications/DefaultOnMissedCallNotificationHandlerTest.kt b/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/notifications/DefaultOnMissedCallNotificationHandlerTest.kt index 6a4cd52430c..1dc21a7ebee 100644 --- a/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/notifications/DefaultOnMissedCallNotificationHandlerTest.kt +++ b/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/notifications/DefaultOnMissedCallNotificationHandlerTest.kt @@ -42,7 +42,9 @@ class DefaultOnMissedCallNotificationHandlerTest { // Create a fake matrix client provider that returns a fake matrix client with a fake notification service that returns a valid notification data val matrixClientProvider = FakeMatrixClientProvider(getClient = { val notificationService = FakeNotificationService().apply { - givenGetNotificationResult(Result.success(aNotificationData(senderDisplayName = A_USER_NAME, senderIsNameAmbiguous = false))) + givenGetNotificationsResult( + Result.success(mapOf(AN_EVENT_ID to aNotificationData(senderDisplayName = A_USER_NAME, senderIsNameAmbiguous = false))) + ) } Result.success(FakeMatrixClient(notificationService = notificationService)) }) diff --git a/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/notifications/FakeNotifiableEventResolver.kt b/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/notifications/FakeNotifiableEventResolver.kt index 3e98f8f9e85..d38bc098a01 100644 --- a/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/notifications/FakeNotifiableEventResolver.kt +++ b/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/notifications/FakeNotifiableEventResolver.kt @@ -7,16 +7,18 @@ package io.element.android.libraries.push.impl.notifications -import io.element.android.libraries.matrix.api.core.EventId -import io.element.android.libraries.matrix.api.core.RoomId import io.element.android.libraries.matrix.api.core.SessionId import io.element.android.libraries.push.impl.notifications.model.ResolvedPushEvent import io.element.android.tests.testutils.lambda.lambdaError class FakeNotifiableEventResolver( - private val notifiableEventResult: (SessionId, RoomId, EventId) -> Result = { _, _, _ -> lambdaError() } + private val resolveEventsResult: (SessionId, List) -> Result>> = + { _, _ -> lambdaError() } ) : NotifiableEventResolver { - override suspend fun resolveEvent(sessionId: SessionId, roomId: RoomId, eventId: EventId): Result { - return notifiableEventResult(sessionId, roomId, eventId) + override suspend fun resolveEvents( + sessionId: SessionId, + notificationEventRequests: List + ): Result>> { + return resolveEventsResult(sessionId, notificationEventRequests) } } diff --git a/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/notifications/NotificationBroadcastReceiverHandlerTest.kt b/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/notifications/NotificationBroadcastReceiverHandlerTest.kt index dfa440bcf05..4d781152ef4 100644 --- a/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/notifications/NotificationBroadcastReceiverHandlerTest.kt +++ b/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/notifications/NotificationBroadcastReceiverHandlerTest.kt @@ -353,8 +353,8 @@ class NotificationBroadcastReceiverHandlerTest { ) ) } - val onNotifiableEventReceivedResult = lambdaRecorder { _ -> } - val onNotifiableEventReceived = FakeOnNotifiableEventReceived(onNotifiableEventReceivedResult = onNotifiableEventReceivedResult) + val onNotifiableEventsReceivedResult = lambdaRecorder, Unit> { _ -> } + val onNotifiableEventReceived = FakeOnNotifiableEventReceived(onNotifiableEventsReceivedResult = onNotifiableEventsReceivedResult) val sut = createNotificationBroadcastReceiverHandler( joinedRoom = joinedRoom, onNotifiableEventReceived = onNotifiableEventReceived, @@ -370,7 +370,7 @@ class NotificationBroadcastReceiverHandlerTest { sendMessage.assertions() .isCalledOnce() .with(value(A_MESSAGE), value(null), value(emptyList())) - onNotifiableEventReceivedResult.assertions() + onNotifiableEventsReceivedResult.assertions() .isCalledOnce() replyMessage.assertions() .isNeverCalled() @@ -420,8 +420,8 @@ class NotificationBroadcastReceiverHandlerTest { ) ) } - val onNotifiableEventReceivedResult = lambdaRecorder { _ -> } - val onNotifiableEventReceived = FakeOnNotifiableEventReceived(onNotifiableEventReceivedResult = onNotifiableEventReceivedResult) + val onNotifiableEventsReceivedResult = lambdaRecorder, Unit> { _ -> } + val onNotifiableEventReceived = FakeOnNotifiableEventReceived(onNotifiableEventsReceivedResult = onNotifiableEventsReceivedResult) val sut = createNotificationBroadcastReceiverHandler( joinedRoom = joinedRoom, onNotifiableEventReceived = onNotifiableEventReceived, @@ -438,7 +438,7 @@ class NotificationBroadcastReceiverHandlerTest { runCurrent() sendMessage.assertions() .isNeverCalled() - onNotifiableEventReceivedResult.assertions() + onNotifiableEventsReceivedResult.assertions() .isCalledOnce() replyMessage.assertions() .isCalledOnce() diff --git a/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/push/DefaultOnRedactedEventReceivedTest.kt b/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/push/DefaultOnRedactedEventReceivedTest.kt index 2c8583bb614..1b08f7b14c4 100644 --- a/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/push/DefaultOnRedactedEventReceivedTest.kt +++ b/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/push/DefaultOnRedactedEventReceivedTest.kt @@ -34,7 +34,7 @@ class DefaultOnRedactedEventReceivedTest { val sut = createDefaultOnRedactedEventReceived( getMessageNotificationsForRoomResult = { _, _ -> emptyList() } ) - sut.onRedactedEventReceived(ResolvedPushEvent.Redaction(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, null)) + sut.onRedactedEventsReceived(listOf(ResolvedPushEvent.Redaction(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, null))) } @Test @@ -48,7 +48,7 @@ class DefaultOnRedactedEventReceivedTest { ) } ) - sut.onRedactedEventReceived(ResolvedPushEvent.Redaction(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, null)) + sut.onRedactedEventsReceived(listOf(ResolvedPushEvent.Redaction(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, null))) } private fun TestScope.createDefaultOnRedactedEventReceived( diff --git a/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/push/DefaultPushHandlerTest.kt b/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/push/DefaultPushHandlerTest.kt index 77b71c0c696..933c830525b 100644 --- a/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/push/DefaultPushHandlerTest.kt +++ b/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/push/DefaultPushHandlerTest.kt @@ -31,6 +31,8 @@ import io.element.android.libraries.matrix.test.core.aBuildMeta import io.element.android.libraries.push.impl.history.FakePushHistoryService import io.element.android.libraries.push.impl.history.PushHistoryService import io.element.android.libraries.push.impl.notifications.FakeNotifiableEventResolver +import io.element.android.libraries.push.impl.notifications.NotificationEventRequest +import io.element.android.libraries.push.impl.notifications.NotificationResolverQueue import io.element.android.libraries.push.impl.notifications.ResolvingException import io.element.android.libraries.push.impl.notifications.channels.FakeNotificationChannels import io.element.android.libraries.push.impl.notifications.fixtures.aNotifiableCallEvent @@ -48,11 +50,15 @@ import io.element.android.libraries.pushstore.test.userpushstore.clientsecret.Fa import io.element.android.tests.testutils.lambda.any import io.element.android.tests.testutils.lambda.lambdaError import io.element.android.tests.testutils.lambda.lambdaRecorder +import io.element.android.tests.testutils.lambda.matching import io.element.android.tests.testutils.lambda.value import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.test.TestScope +import kotlinx.coroutines.test.advanceTimeBy import kotlinx.coroutines.test.runTest import org.junit.Test import java.time.Instant +import kotlin.time.Duration.Companion.milliseconds private const val A_PUSHER_INFO = "info" @@ -80,10 +86,11 @@ class DefaultPushHandlerTest { fun `when classical PushData is received, the notification drawer is informed`() = runTest { val aNotifiableMessageEvent = aNotifiableMessageEvent() val notifiableEventResult = - lambdaRecorder> { _, _, _ -> - Result.success(ResolvedPushEvent.Event(aNotifiableMessageEvent)) + lambdaRecorder, Result>>> { _, _, -> + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, A_PUSHER_INFO) + Result.success(mapOf(request to Result.success(ResolvedPushEvent.Event(aNotifiableMessageEvent)))) } - val onNotifiableEventReceived = lambdaRecorder {} + val onNotifiableEventsReceived = lambdaRecorder, Unit> {} val incrementPushCounterResult = lambdaRecorder {} val onPushReceivedResult = lambdaRecorder { _, _, _, _, _, _, _ -> } val pushHistoryService = FakePushHistoryService( @@ -96,8 +103,8 @@ class DefaultPushHandlerTest { clientSecret = A_SECRET, ) val defaultPushHandler = createDefaultPushHandler( - onNotifiableEventReceived = onNotifiableEventReceived, - notifiableEventResult = notifiableEventResult, + onNotifiableEventsReceived = onNotifiableEventsReceived, + notifiableEventsResult = notifiableEventResult, pushClientSecret = FakePushClientSecret( getUserIdFromSecretResult = { A_USER_ID } ), @@ -105,14 +112,17 @@ class DefaultPushHandlerTest { pushHistoryService = pushHistoryService, ) defaultPushHandler.handle(aPushData, A_PUSHER_INFO) + + advanceTimeBy(300.milliseconds) + incrementPushCounterResult.assertions() .isCalledOnce() notifiableEventResult.assertions() .isCalledOnce() - .with(value(A_USER_ID), value(A_ROOM_ID), value(AN_EVENT_ID)) - onNotifiableEventReceived.assertions() + .with(value(A_USER_ID), any()) + onNotifiableEventsReceived.assertions() .isCalledOnce() - .with(value(aNotifiableMessageEvent)) + .with(value(listOf(aNotifiableMessageEvent))) onPushReceivedResult.assertions() .isCalledOnce() } @@ -122,10 +132,11 @@ class DefaultPushHandlerTest { runTest { val aNotifiableMessageEvent = aNotifiableMessageEvent() val notifiableEventResult = - lambdaRecorder> { _, _, _ -> - Result.success(ResolvedPushEvent.Event(aNotifiableMessageEvent)) + lambdaRecorder, Result>>> { _, _ -> + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, A_PUSHER_INFO) + Result.success(mapOf(request to Result.success(ResolvedPushEvent.Event(aNotifiableMessageEvent)))) } - val onNotifiableEventReceived = lambdaRecorder {} + val onNotifiableEventsReceived = lambdaRecorder, Unit> {} val incrementPushCounterResult = lambdaRecorder {} val aPushData = PushData( eventId = AN_EVENT_ID, @@ -138,8 +149,8 @@ class DefaultPushHandlerTest { onPushReceivedResult = onPushReceivedResult, ) val defaultPushHandler = createDefaultPushHandler( - onNotifiableEventReceived = onNotifiableEventReceived, - notifiableEventResult = notifiableEventResult, + onNotifiableEventsReceived = onNotifiableEventsReceived, + notifiableEventsResult = notifiableEventResult, pushClientSecret = FakePushClientSecret( getUserIdFromSecretResult = { A_USER_ID } ), @@ -150,11 +161,14 @@ class DefaultPushHandlerTest { pushHistoryService = pushHistoryService, ) defaultPushHandler.handle(aPushData, A_PUSHER_INFO) + + advanceTimeBy(300.milliseconds) + incrementPushCounterResult.assertions() .isCalledOnce() notifiableEventResult.assertions() .isCalledOnce() - onNotifiableEventReceived.assertions() + onNotifiableEventsReceived.assertions() .isNeverCalled() onPushReceivedResult.assertions() .isCalledOnce() @@ -165,10 +179,11 @@ class DefaultPushHandlerTest { runTest { val aNotifiableMessageEvent = aNotifiableMessageEvent() val notifiableEventResult = - lambdaRecorder> { _, _, _ -> - Result.success(ResolvedPushEvent.Event(aNotifiableMessageEvent)) + lambdaRecorder, Result>>> { _, _ -> + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, A_PUSHER_INFO) + Result.success(mapOf(request to Result.success(ResolvedPushEvent.Event(aNotifiableMessageEvent)))) } - val onNotifiableEventReceived = lambdaRecorder {} + val onNotifiableEventsReceived = lambdaRecorder, Unit> {} val incrementPushCounterResult = lambdaRecorder {} val aPushData = PushData( eventId = AN_EVENT_ID, @@ -181,8 +196,8 @@ class DefaultPushHandlerTest { onPushReceivedResult = onPushReceivedResult, ) val defaultPushHandler = createDefaultPushHandler( - onNotifiableEventReceived = onNotifiableEventReceived, - notifiableEventResult = notifiableEventResult, + onNotifiableEventsReceived = onNotifiableEventsReceived, + notifiableEventsResult = notifiableEventResult, pushClientSecret = FakePushClientSecret( getUserIdFromSecretResult = { null } ), @@ -193,14 +208,17 @@ class DefaultPushHandlerTest { pushHistoryService = pushHistoryService, ) defaultPushHandler.handle(aPushData, A_PUSHER_INFO) + + advanceTimeBy(300.milliseconds) + incrementPushCounterResult.assertions() .isCalledOnce() notifiableEventResult.assertions() .isCalledOnce() - .with(value(A_USER_ID), value(A_ROOM_ID), value(AN_EVENT_ID)) - onNotifiableEventReceived.assertions() + .with(value(A_USER_ID), any()) + onNotifiableEventsReceived.assertions() .isCalledOnce() - .with(value(aNotifiableMessageEvent)) + .with(value(listOf(aNotifiableMessageEvent))) onPushReceivedResult.assertions() .isCalledOnce() } @@ -210,10 +228,11 @@ class DefaultPushHandlerTest { runTest { val aNotifiableMessageEvent = aNotifiableMessageEvent() val notifiableEventResult = - lambdaRecorder> { _, _, _ -> - Result.success(ResolvedPushEvent.Event(aNotifiableMessageEvent)) + lambdaRecorder, Result>>> { _, _ -> + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, A_PUSHER_INFO) + Result.success(mapOf(request to Result.success(ResolvedPushEvent.Event(aNotifiableMessageEvent)))) } - val onNotifiableEventReceived = lambdaRecorder {} + val onNotifiableEventsReceived = lambdaRecorder, Unit> {} val incrementPushCounterResult = lambdaRecorder {} val aPushData = PushData( eventId = AN_EVENT_ID, @@ -226,8 +245,8 @@ class DefaultPushHandlerTest { onPushReceivedResult = onPushReceivedResult, ) val defaultPushHandler = createDefaultPushHandler( - onNotifiableEventReceived = onNotifiableEventReceived, - notifiableEventResult = notifiableEventResult, + onNotifiableEventsReceived = onNotifiableEventsReceived, + notifiableEventsResult = notifiableEventResult, pushClientSecret = FakePushClientSecret( getUserIdFromSecretResult = { null } ), @@ -242,7 +261,7 @@ class DefaultPushHandlerTest { .isCalledOnce() notifiableEventResult.assertions() .isNeverCalled() - onNotifiableEventReceived.assertions() + onNotifiableEventsReceived.assertions() .isNeverCalled() onPushReceivedResult.assertions() .isCalledOnce() @@ -252,10 +271,10 @@ class DefaultPushHandlerTest { fun `when classical PushData is received, but not able to resolve the event, nothing happen`() = runTest { val notifiableEventResult = - lambdaRecorder> { _, _, _ -> + lambdaRecorder, Result>>> { _, _ -> Result.failure(ResolvingException("Unable to resolve")) } - val onNotifiableEventReceived = lambdaRecorder {} + val onNotifiableEventsReceived = lambdaRecorder, Unit> {} val incrementPushCounterResult = lambdaRecorder {} val aPushData = PushData( eventId = AN_EVENT_ID, @@ -268,8 +287,8 @@ class DefaultPushHandlerTest { onPushReceivedResult = onPushReceivedResult, ) val defaultPushHandler = createDefaultPushHandler( - onNotifiableEventReceived = onNotifiableEventReceived, - notifiableEventResult = notifiableEventResult, + onNotifiableEventsReceived = onNotifiableEventsReceived, + notifiableEventsResult = notifiableEventResult, buildMeta = aBuildMeta( // Also test `lowPrivacyLoggingEnabled = false` here lowPrivacyLoggingEnabled = false @@ -281,12 +300,15 @@ class DefaultPushHandlerTest { pushHistoryService = pushHistoryService, ) defaultPushHandler.handle(aPushData, A_PUSHER_INFO) + + advanceTimeBy(300.milliseconds) + incrementPushCounterResult.assertions() .isCalledOnce() notifiableEventResult.assertions() .isCalledOnce() - .with(value(A_USER_ID), value(A_ROOM_ID), value(AN_EVENT_ID)) - onNotifiableEventReceived.assertions() + .with(value(A_USER_ID), any()) + onNotifiableEventsReceived.assertions() .isNeverCalled() onPushReceivedResult.assertions() .isCalledOnce() @@ -313,28 +335,38 @@ class DefaultPushHandlerTest { Unit, > { _, _, _, _, _, _, _, _ -> } val elementCallEntryPoint = FakeElementCallEntryPoint(handleIncomingCallResult = handleIncomingCallLambda) - val onNotifiableEventReceived = lambdaRecorder {} + val onNotifiableEventsReceived = lambdaRecorder, Unit> {} val onPushReceivedResult = lambdaRecorder { _, _, _, _, _, _, _ -> } val pushHistoryService = FakePushHistoryService( onPushReceivedResult = onPushReceivedResult, ) val defaultPushHandler = createDefaultPushHandler( elementCallEntryPoint = elementCallEntryPoint, - notifiableEventResult = { _, _, _ -> + notifiableEventsResult = { _, _ -> + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, A_PUSHER_INFO) Result.success( - ResolvedPushEvent.Event(aNotifiableCallEvent(callNotifyType = CallNotifyType.RING, timestamp = Instant.now().toEpochMilli())) + mapOf( + request to Result.success( + ResolvedPushEvent.Event( + aNotifiableCallEvent(callNotifyType = CallNotifyType.RING, timestamp = Instant.now().toEpochMilli()) + ) + ) + ) ) }, incrementPushCounterResult = {}, pushClientSecret = FakePushClientSecret( getUserIdFromSecretResult = { A_USER_ID } ), - onNotifiableEventReceived = onNotifiableEventReceived, + onNotifiableEventsReceived = onNotifiableEventsReceived, pushHistoryService = pushHistoryService, ) defaultPushHandler.handle(aPushData, A_PUSHER_INFO) + + advanceTimeBy(300.milliseconds) + handleIncomingCallLambda.assertions().isCalledOnce() - onNotifiableEventReceived.assertions().isCalledOnce() + onNotifiableEventsReceived.assertions().isNeverCalled() onPushReceivedResult.assertions().isCalledOnce() } @@ -346,7 +378,7 @@ class DefaultPushHandlerTest { unread = 0, clientSecret = A_SECRET, ) - val onNotifiableEventReceived = lambdaRecorder {} + val onNotifiableEventsReceived = lambdaRecorder, Unit> {} val handleIncomingCallLambda = lambdaRecorder< CallType.RoomCall, EventId, @@ -365,9 +397,10 @@ class DefaultPushHandlerTest { ) val defaultPushHandler = createDefaultPushHandler( elementCallEntryPoint = elementCallEntryPoint, - onNotifiableEventReceived = onNotifiableEventReceived, - notifiableEventResult = { _, _, _ -> - Result.success(ResolvedPushEvent.Event(aNotifiableMessageEvent(type = EventType.CALL_NOTIFY))) + onNotifiableEventsReceived = onNotifiableEventsReceived, + notifiableEventsResult = { _, _ -> + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, A_PUSHER_INFO) + Result.success(mapOf(request to Result.success(ResolvedPushEvent.Event(aNotifiableMessageEvent(type = EventType.CALL_NOTIFY))))) }, incrementPushCounterResult = {}, pushClientSecret = FakePushClientSecret( @@ -377,8 +410,10 @@ class DefaultPushHandlerTest { ) defaultPushHandler.handle(aPushData, A_PUSHER_INFO) + advanceTimeBy(300.milliseconds) + handleIncomingCallLambda.assertions().isNeverCalled() - onNotifiableEventReceived.assertions().isCalledOnce() + onNotifiableEventsReceived.assertions().isCalledOnce() onPushReceivedResult.assertions().isCalledOnce() } @@ -390,7 +425,7 @@ class DefaultPushHandlerTest { unread = 0, clientSecret = A_SECRET, ) - val onNotifiableEventReceived = lambdaRecorder {} + val onNotifiableEventsReceived = lambdaRecorder, Unit> {} val handleIncomingCallLambda = lambdaRecorder< CallType.RoomCall, EventId, @@ -409,9 +444,10 @@ class DefaultPushHandlerTest { ) val defaultPushHandler = createDefaultPushHandler( elementCallEntryPoint = elementCallEntryPoint, - onNotifiableEventReceived = onNotifiableEventReceived, - notifiableEventResult = { _, _, _ -> - Result.success(ResolvedPushEvent.Event(aNotifiableCallEvent())) + onNotifiableEventsReceived = onNotifiableEventsReceived, + notifiableEventsResult = { _, _ -> + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, A_PUSHER_INFO) + Result.success(mapOf(request to Result.success(ResolvedPushEvent.Event(aNotifiableCallEvent())))) }, incrementPushCounterResult = {}, userPushStore = FakeUserPushStore().apply { @@ -423,8 +459,11 @@ class DefaultPushHandlerTest { pushHistoryService = pushHistoryService, ) defaultPushHandler.handle(aPushData, A_PUSHER_INFO) + + advanceTimeBy(300.milliseconds) + handleIncomingCallLambda.assertions().isCalledOnce() - onNotifiableEventReceived.assertions().isCalledOnce() + onNotifiableEventsReceived.assertions().isNeverCalled() onPushReceivedResult.assertions().isCalledOnce() } @@ -442,26 +481,32 @@ class DefaultPushHandlerTest { redactedEventId = AN_EVENT_ID_2, reason = null ) - val onRedactedEventReceived = lambdaRecorder { } + val onRedactedEventReceived = lambdaRecorder, Unit> { } val incrementPushCounterResult = lambdaRecorder {} val onPushReceivedResult = lambdaRecorder { _, _, _, _, _, _, _ -> } val pushHistoryService = FakePushHistoryService( onPushReceivedResult = onPushReceivedResult, ) val defaultPushHandler = createDefaultPushHandler( - onRedactedEventReceived = onRedactedEventReceived, + onRedactedEventsReceived = onRedactedEventReceived, incrementPushCounterResult = incrementPushCounterResult, - notifiableEventResult = { _, _, _ -> Result.success(aRedaction) }, + notifiableEventsResult = { _, _ -> + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, A_PUSHER_INFO) + Result.success(mapOf(request to Result.success(aRedaction))) + }, pushClientSecret = FakePushClientSecret( getUserIdFromSecretResult = { A_USER_ID } ), pushHistoryService = pushHistoryService, ) defaultPushHandler.handle(aPushData, A_PUSHER_INFO) + + advanceTimeBy(300.milliseconds) + incrementPushCounterResult.assertions() .isCalledOnce() onRedactedEventReceived.assertions().isCalledOnce() - .with(value(aRedaction)) + .with(value(listOf(aRedaction))) onPushReceivedResult.assertions() .isCalledOnce() } @@ -493,10 +538,64 @@ class DefaultPushHandlerTest { .isCalledOnce() } - private fun createDefaultPushHandler( - onNotifiableEventReceived: (NotifiableEvent) -> Unit = { lambdaError() }, - onRedactedEventReceived: (ResolvedPushEvent.Redaction) -> Unit = { lambdaError() }, - notifiableEventResult: (SessionId, RoomId, EventId) -> Result = { _, _, _ -> lambdaError() }, + @Test + fun `when receiving several push notifications at the same time, those are batched before being processed`() = runTest { + val aNotifiableMessageEvent = aNotifiableMessageEvent() + val notifiableEventResult = + lambdaRecorder, Result>>> { _, _, -> + val request = NotificationEventRequest(A_SESSION_ID, A_ROOM_ID, AN_EVENT_ID, A_PUSHER_INFO) + Result.success(mapOf(request to Result.success(ResolvedPushEvent.Event(aNotifiableMessageEvent)))) + } + val onNotifiableEventsReceived = lambdaRecorder, Unit> {} + val incrementPushCounterResult = lambdaRecorder {} + val onPushReceivedResult = lambdaRecorder { _, _, _, _, _, _, _ -> } + val pushHistoryService = FakePushHistoryService( + onPushReceivedResult = onPushReceivedResult, + ) + val aPushData = PushData( + eventId = AN_EVENT_ID, + roomId = A_ROOM_ID, + unread = 0, + clientSecret = A_SECRET, + ) + val anotherPushData = PushData( + eventId = AN_EVENT_ID_2, + roomId = A_ROOM_ID, + unread = 0, + clientSecret = A_SECRET, + ) + val defaultPushHandler = createDefaultPushHandler( + onNotifiableEventsReceived = onNotifiableEventsReceived, + notifiableEventsResult = notifiableEventResult, + pushClientSecret = FakePushClientSecret( + getUserIdFromSecretResult = { A_USER_ID } + ), + incrementPushCounterResult = incrementPushCounterResult, + pushHistoryService = pushHistoryService, + ) + defaultPushHandler.handle(aPushData, A_PUSHER_INFO) + defaultPushHandler.handle(anotherPushData, A_PUSHER_INFO) + + advanceTimeBy(300.milliseconds) + + incrementPushCounterResult.assertions() + .isCalledExactly(2) + notifiableEventResult.assertions() + .isCalledOnce() + .with(value(A_USER_ID), matching> { requests -> + requests.size == 2 && requests.first().eventId == AN_EVENT_ID && requests.last().eventId == AN_EVENT_ID_2 + }) + onNotifiableEventsReceived.assertions() + .isCalledOnce() + onPushReceivedResult.assertions() + .isCalledExactly(2) + } + + private fun TestScope.createDefaultPushHandler( + onNotifiableEventsReceived: (List) -> Unit = { lambdaError() }, + onRedactedEventsReceived: (List) -> Unit = { lambdaError() }, + notifiableEventsResult: (SessionId, List) -> Result>> = + { _, _, -> lambdaError() }, incrementPushCounterResult: () -> Unit = { lambdaError() }, userPushStore: UserPushStore = FakeUserPushStore(), pushClientSecret: PushClientSecret = FakePushClientSecret(), @@ -508,9 +607,8 @@ class DefaultPushHandlerTest { pushHistoryService: PushHistoryService = FakePushHistoryService(), ): DefaultPushHandler { return DefaultPushHandler( - onNotifiableEventReceived = FakeOnNotifiableEventReceived(onNotifiableEventReceived), - onRedactedEventReceived = FakeOnRedactedEventReceived(onRedactedEventReceived), - notifiableEventResolver = FakeNotifiableEventResolver(notifiableEventResult), + onNotifiableEventReceived = FakeOnNotifiableEventReceived(onNotifiableEventsReceived), + onRedactedEventReceived = FakeOnRedactedEventReceived(onRedactedEventsReceived), incrementPushDataStore = object : IncrementPushDataStore { override suspend fun incrementPushCounter() { incrementPushCounterResult() @@ -524,6 +622,8 @@ class DefaultPushHandlerTest { elementCallEntryPoint = elementCallEntryPoint, notificationChannels = notificationChannels, pushHistoryService = pushHistoryService, + resolverQueue = NotificationResolverQueue(notifiableEventResolver = FakeNotifiableEventResolver(notifiableEventsResult), backgroundScope), + appCoroutineScope = backgroundScope, ) } } diff --git a/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/push/FakeOnNotifiableEventReceived.kt b/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/push/FakeOnNotifiableEventReceived.kt index 0de4094809a..055b1f322e5 100644 --- a/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/push/FakeOnNotifiableEventReceived.kt +++ b/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/push/FakeOnNotifiableEventReceived.kt @@ -11,9 +11,9 @@ import io.element.android.libraries.push.impl.notifications.model.NotifiableEven import io.element.android.tests.testutils.lambda.lambdaError class FakeOnNotifiableEventReceived( - private val onNotifiableEventReceivedResult: (NotifiableEvent) -> Unit = { lambdaError() }, + private val onNotifiableEventsReceivedResult: (List) -> Unit = { lambdaError() }, ) : OnNotifiableEventReceived { - override fun onNotifiableEventReceived(notifiableEvent: NotifiableEvent) { - onNotifiableEventReceivedResult(notifiableEvent) + override fun onNotifiableEventsReceived(notifiableEvents: List) { + onNotifiableEventsReceivedResult(notifiableEvents) } } diff --git a/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/push/FakeOnRedactedEventReceived.kt b/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/push/FakeOnRedactedEventReceived.kt index 96e76f6da0a..b5a3731830e 100644 --- a/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/push/FakeOnRedactedEventReceived.kt +++ b/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/push/FakeOnRedactedEventReceived.kt @@ -11,9 +11,9 @@ import io.element.android.libraries.push.impl.notifications.model.ResolvedPushEv import io.element.android.tests.testutils.lambda.lambdaError class FakeOnRedactedEventReceived( - private val onRedactedEventReceivedResult: (ResolvedPushEvent.Redaction) -> Unit = { lambdaError() }, + private val onRedactedEventsReceivedResult: (List) -> Unit = { lambdaError() }, ) : OnRedactedEventReceived { - override fun onRedactedEventReceived(redaction: ResolvedPushEvent.Redaction) { - onRedactedEventReceivedResult(redaction) + override fun onRedactedEventsReceived(redactions: List) { + onRedactedEventsReceivedResult(redactions) } } diff --git a/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/push/SyncOnNotifiableEventTest.kt b/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/push/SyncOnNotifiableEventTest.kt index 8b3907be0b4..cb0c233503d 100644 --- a/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/push/SyncOnNotifiableEventTest.kt +++ b/libraries/push/impl/src/test/kotlin/io/element/android/libraries/push/impl/push/SyncOnNotifiableEventTest.kt @@ -75,7 +75,7 @@ class SyncOnNotifiableEventTest { fun `when feature flag is disabled, nothing happens`() = runTest { val sut = createSyncOnNotifiableEvent(client = client, isSyncOnPushEnabled = false) - sut(notifiableEvent) + sut(listOf(notifiableEvent)) assert(startSyncLambda).isNeverCalled() assert(stopSyncLambda).isNeverCalled() @@ -96,7 +96,7 @@ class SyncOnNotifiableEventTest { unlocked.set(true) room.givenRoomInfo(aRoomInfo(hasRoomCall = true)) } - sut(incomingCallNotifiableEvent) + sut(listOf(incomingCallNotifiableEvent)) // The process was completed before the timeout assertThat(unlocked.get()).isTrue() @@ -116,30 +116,12 @@ class SyncOnNotifiableEventTest { unlocked.set(true) room.givenRoomInfo(aRoomInfo(hasRoomCall = true)) } - sut(incomingCallNotifiableEvent) + sut(listOf(incomingCallNotifiableEvent)) // Didn't unlock before the timeout assertThat(unlocked.get()).isFalse() } - @Test - fun `when feature flag is enabled and app is in foreground, sync is not started`() = runTest { - val appForegroundStateService = FakeAppForegroundStateService( - initialForegroundValue = true, - ) - val sut = createSyncOnNotifiableEvent(client = client, appForegroundStateService = appForegroundStateService, isSyncOnPushEnabled = true) - - appForegroundStateService.isSyncingNotificationEvent.test { - sut(notifiableEvent) - sut(incomingCallNotifiableEvent) - - // It's initially false - assertThat(awaitItem()).isFalse() - // It never becomes true - ensureAllEventsConsumed() - } - } - @Test fun `when feature flag is enabled and app is in background, sync is started and stopped`() = runTest { val appForegroundStateService = FakeAppForegroundStateService( @@ -153,7 +135,7 @@ class SyncOnNotifiableEventTest { appForegroundStateService.isSyncingNotificationEvent.test { syncService.emitSyncState(SyncState.Running) - sut(notifiableEvent) + sut(listOf(notifiableEvent)) // It's initially false assertThat(awaitItem()).isFalse() @@ -174,8 +156,8 @@ class SyncOnNotifiableEventTest { val sut = createSyncOnNotifiableEvent(client = client, appForegroundStateService = appForegroundStateService, isSyncOnPushEnabled = true) appForegroundStateService.isSyncingNotificationEvent.test { - launch { sut(notifiableEvent) } - launch { sut(notifiableEvent) } + launch { sut(listOf(notifiableEvent)) } + launch { sut(listOf(notifiableEvent)) } launch { delay(1) timelineItems.emit( diff --git a/tests/testutils/src/main/kotlin/io/element/android/tests/testutils/lambda/ParameterMatcher.kt b/tests/testutils/src/main/kotlin/io/element/android/tests/testutils/lambda/ParameterMatcher.kt index 8a692f67db8..2b16b099bf0 100644 --- a/tests/testutils/src/main/kotlin/io/element/android/tests/testutils/lambda/ParameterMatcher.kt +++ b/tests/testutils/src/main/kotlin/io/element/android/tests/testutils/lambda/ParameterMatcher.kt @@ -24,6 +24,18 @@ fun value(expectedValue: T) = object : ParameterMatcher { override fun toString(): String = "value($expectedValue)" } +/** + * A matcher that matches a value based on a condition. + * Can be used to assert that a lambda has been called with a value that satisfies a specific condition. + */ +fun matching(check: (T) -> Boolean) = object : ParameterMatcher { + override fun match(param: Any?): Boolean { + @Suppress("UNCHECKED_CAST") + return (param as? T)?.let { check(it) } ?: false + } + override fun toString(): String = "matching(condition)" +} + /** * A matcher that matches any value. * Can be used when we don't care about the value of a parameter.