feat(notification): trigger in-app notification using InAppNotificationNotifier and event bus

Author: rafaeltonholo

feature/debug-settings/src/debug/kotlin/net/thunderbird/feature/debug/settings/SecretDebugSettingsScreenPreview.kt

@@ -7,6 +7,7 @@ import androidx.compose.ui.tooling.preview.PreviewLightDark
 import app.k9mail.core.ui.compose.common.koin.koinPreview
 import app.k9mail.core.ui.compose.designsystem.PreviewWithThemesLightDark
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.flowOf
 import net.thunderbird.core.common.resources.StringsResourceManager
 import net.thunderbird.core.outcome.Outcome
@@ -16,6 +17,8 @@ import net.thunderbird.feature.mail.account.api.BaseAccount
 import net.thunderbird.feature.notification.api.command.NotificationCommand.Failure
 import net.thunderbird.feature.notification.api.command.NotificationCommand.Success
 import net.thunderbird.feature.notification.api.content.Notification
+import net.thunderbird.feature.notification.api.receiver.InAppNotificationEvent
+import net.thunderbird.feature.notification.api.receiver.InAppNotificationReceiver
 import net.thunderbird.feature.notification.api.sender.NotificationSender
 
 @PreviewLightDark
@@ -47,6 +50,10 @@ private fun SecretDebugSettingsScreenPreview() {
                     ): Flow<Outcome<Success<Notification>, Failure<Notification>>> =
                         error("not implemented")
                 },
+                notificationReceiver = object : InAppNotificationReceiver {
+                    override val events: SharedFlow<InAppNotificationEvent>
+                        get() = error("not implemented")
+                },
             )
         }
     } WithContent {

feature/debug-settings/src/debug/kotlin/net/thunderbird/feature/debug/settings/inject/FeatureDebugSettingsModule.kt

@@ -13,6 +13,7 @@ val featureDebugSettingsModule = module {
             stringsResourceManager = get(),
             accountManager = get(),
             notificationSender = get(),
+            notificationReceiver = get(),
         )
     }
 }

feature/debug-settings/src/main/kotlin/net/thunderbird/feature/debug/settings/notification/DebugNotificationSectionViewModel.kt

@@ -8,6 +8,7 @@ import kotlinx.collections.immutable.persistentListOf
 import kotlinx.collections.immutable.toPersistentList
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import net.thunderbird.core.common.resources.StringsResourceManager
@@ -27,12 +28,14 @@ import net.thunderbird.feature.notification.api.content.MailNotification
 import net.thunderbird.feature.notification.api.content.Notification
 import net.thunderbird.feature.notification.api.content.PushServiceNotification
 import net.thunderbird.feature.notification.api.content.SystemNotification
+import net.thunderbird.feature.notification.api.receiver.InAppNotificationReceiver
 import net.thunderbird.feature.notification.api.sender.NotificationSender
 
 internal class DebugNotificationSectionViewModel(
     private val stringsResourceManager: StringsResourceManager,
     private val accountManager: AccountManager<BaseAccount>,
     private val notificationSender: NotificationSender,
+    private val notificationReceiver: InAppNotificationReceiver,
     private val mainDispatcher: CoroutineDispatcher = Dispatchers.Main,
     ioDispatcher: CoroutineDispatcher = Dispatchers.IO,
 ) : BaseViewModel<State, Event, Effect>(initialState = State()), DebugNotificationSectionContract.ViewModel {
@@ -76,6 +79,18 @@ internal class DebugNotificationSectionViewModel(
                 }
             }
         }
+
+        viewModelScope.launch {
+            notificationReceiver
+                .events
+                .collectLatest { event ->
+                    updateState { state ->
+                        state.copy(
+                            notificationStatusLog = state.notificationStatusLog + " In-app notification event: $event",
+                        )
+                    }
+                }
+        }
     }
 
     override fun event(event: Event) {

feature/notification/api/build.gradle.kts

@@ -2,6 +2,7 @@ import org.jetbrains.kotlin.gradle.internal.config.LanguageFeature
 
 plugins {
     id(ThunderbirdPlugins.Library.kmpCompose)
+    alias(libs.plugins.dev.mokkery)
 }
 
 kotlin {

feature/notification/api/src/commonMain/kotlin/net/thunderbird/feature/notification/api/receiver/InAppNotificationReceiver.kt

@@ -0,0 +1,19 @@
+package net.thunderbird.feature.notification.api.receiver
+
+import kotlinx.coroutines.flow.SharedFlow
+import net.thunderbird.feature.notification.api.content.InAppNotification
+
+/**
+ * Interface for receiving in-app notification events.
+ *
+ * This interface provides a [SharedFlow] of [InAppNotificationEvent]s that can be observed
+ * by UI components or other parts of the application to react to in-app notifications.
+ */
+interface InAppNotificationReceiver {
+    val events: SharedFlow<InAppNotificationEvent>
+}
+
+sealed interface InAppNotificationEvent {
+    data class Show(val notification: InAppNotification) : InAppNotificationEvent
+    data class Dismiss(val notification: InAppNotification) : InAppNotificationEvent
+}

feature/notification/api/src/commonMain/kotlin/net/thunderbird/feature/notification/api/receiver/compat/InAppNotificationReceiverCompat.kt

@@ -0,0 +1,46 @@
+package net.thunderbird.feature.notification.api.receiver.compat
+
+import androidx.annotation.Discouraged
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.DisposableHandle
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import net.thunderbird.feature.notification.api.receiver.InAppNotificationEvent
+import net.thunderbird.feature.notification.api.receiver.InAppNotificationReceiver
+
+/**
+ * A compatibility class for [InAppNotificationReceiver] that allows Java classes to observe notification events.
+ *
+ * This class is discouraged for use in Kotlin code. Use [InAppNotificationReceiver] directly instead.
+ *
+ * @param notificationReceiver The [InAppNotificationReceiver] instance to delegate to.
+ * @param listener A callback function that will be invoked when a new [InAppNotificationEvent] is received.
+ * @param mainImmediateDispatcher The [CoroutineDispatcher] to use for observing events.
+ */
+@Discouraged("Only for usage within a Java class. Use InAppNotificationReceiver instead.")
+class InAppNotificationReceiverCompat(
+    private val notificationReceiver: InAppNotificationReceiver,
+    listener: OnReceiveEventListener,
+    mainImmediateDispatcher: CoroutineDispatcher = Dispatchers.Main.immediate,
+) : InAppNotificationReceiver by notificationReceiver, DisposableHandle {
+    private val scope = CoroutineScope(SupervisorJob() + mainImmediateDispatcher)
+
+    init {
+        scope.launch {
+            events.collect { event ->
+                listener.onReceiveEvent(event)
+            }
+        }
+    }
+
+    override fun dispose() {
+        scope.cancel()
+    }
+
+    fun interface OnReceiveEventListener {
+        fun onReceiveEvent(event: InAppNotificationEvent)
+    }
+}

feature/notification/api/src/commonTest/kotlin/net/thunderbird/feature/notification/api/receiver/compat/InAppNotificationReceiverCompatTest.kt

@@ -0,0 +1,86 @@
+package net.thunderbird.feature.notification.api.receiver.compat
+
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.unit.dp
+import assertk.assertThat
+import assertk.assertions.containsExactlyInAnyOrder
+import dev.mokkery.matcher.any
+import dev.mokkery.spy
+import dev.mokkery.verify
+import dev.mokkery.verify.VerifyMode.Companion.exactly
+import kotlin.test.Test
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.runTest
+import net.thunderbird.feature.notification.api.NotificationSeverity
+import net.thunderbird.feature.notification.api.content.AppNotification
+import net.thunderbird.feature.notification.api.content.InAppNotification
+import net.thunderbird.feature.notification.api.receiver.InAppNotificationEvent
+import net.thunderbird.feature.notification.api.receiver.InAppNotificationReceiver
+import net.thunderbird.feature.notification.api.receiver.compat.InAppNotificationReceiverCompat.OnReceiveEventListener
+import net.thunderbird.feature.notification.api.ui.icon.NotificationIcon
+
+class InAppNotificationReceiverCompatTest {
+    @OptIn(ExperimentalCoroutinesApi::class)
+    @Test
+    fun `onReceiveEvent should be triggered when an event is received into InAppNotificationReceiver`() = runTest {
+        // Arrange
+        val inAppNotificationReceiver = FakeInAppNotificationReceiver()
+        val eventsTriggered = mutableListOf<InAppNotificationEvent>()
+        val expectedEvents = List(size = 100) { index ->
+            val title = "notification $index"
+            when {
+                index % 2 == 0 -> {
+                    InAppNotificationEvent.Show(FakeNotification(title = title))
+                }
+
+                else -> InAppNotificationEvent.Dismiss(FakeNotification(title = title))
+            }
+        }.toTypedArray()
+        val onReceiveEventListener = spy<OnReceiveEventListener>(
+            OnReceiveEventListener { event ->
+                eventsTriggered += event
+            },
+        )
+        InAppNotificationReceiverCompat(
+            notificationReceiver = inAppNotificationReceiver,
+            listener = onReceiveEventListener,
+            mainImmediateDispatcher = UnconfinedTestDispatcher(),
+        )
+
+        // Act
+        expectedEvents.forEach { event -> inAppNotificationReceiver.trigger(event) }
+
+        // Assert
+        verify(exactly(100)) {
+            onReceiveEventListener.onReceiveEvent(event = any())
+        }
+        assertThat(eventsTriggered).containsExactlyInAnyOrder(elements = expectedEvents)
+    }
+
+    private class FakeInAppNotificationReceiver : InAppNotificationReceiver {
+        private val _events = MutableSharedFlow<InAppNotificationEvent>()
+        override val events: SharedFlow<InAppNotificationEvent> = _events.asSharedFlow()
+
+        suspend fun trigger(event: InAppNotificationEvent) {
+            _events.emit(event)
+        }
+    }
+
+    data class FakeNotification(
+        override val title: String = "fake title",
+        override val contentText: String? = "fake content",
+        override val severity: NotificationSeverity = NotificationSeverity.Information,
+        override val icon: NotificationIcon = NotificationIcon(
+            inAppNotificationIcon = ImageVector.Builder(
+                defaultWidth = 0.dp,
+                defaultHeight = 0.dp,
+                viewportWidth = 0f,
+                viewportHeight = 0f,
+            ).build(),
+        ),
+    ) : AppNotification(), InAppNotification
+}

feature/notification/impl/src/commonMain/kotlin/net/thunderbird/feature/notification/impl/command/NotificationCommandFactory.kt

@@ -8,7 +8,6 @@ import net.thunderbird.feature.notification.api.content.InAppNotification
 import net.thunderbird.feature.notification.api.content.Notification
 import net.thunderbird.feature.notification.api.content.SystemNotification
 import net.thunderbird.feature.notification.api.receiver.NotificationNotifier
-import net.thunderbird.feature.notification.impl.receiver.InAppNotificationNotifier
 import net.thunderbird.feature.notification.impl.receiver.SystemNotificationNotifier
 
 /**

feature/notification/impl/src/commonMain/kotlin/net/thunderbird/feature/notification/impl/inject/NotificationModule.kt

@@ -2,25 +2,38 @@ package net.thunderbird.feature.notification.impl.inject
 
 import net.thunderbird.feature.notification.api.NotificationRegistry
 import net.thunderbird.feature.notification.api.content.InAppNotification
+import net.thunderbird.feature.notification.api.receiver.InAppNotificationReceiver
 import net.thunderbird.feature.notification.api.receiver.NotificationNotifier
 import net.thunderbird.feature.notification.api.sender.NotificationSender
 import net.thunderbird.feature.notification.impl.DefaultNotificationRegistry
 import net.thunderbird.feature.notification.impl.command.NotificationCommandFactory
+import net.thunderbird.feature.notification.impl.receiver.InAppNotificationEventBus
 import net.thunderbird.feature.notification.impl.receiver.InAppNotificationNotifier
 import net.thunderbird.feature.notification.impl.receiver.SystemNotificationNotifier
 import net.thunderbird.feature.notification.impl.sender.DefaultNotificationSender
 import org.koin.core.module.Module
 import org.koin.core.qualifier.named
+import org.koin.dsl.bind
 import org.koin.dsl.module
 
 internal expect val platformFeatureNotificationModule: Module
 
 val featureNotificationModule = module {
     includes(platformFeatureNotificationModule)
 
+    single<NotificationRegistry> { DefaultNotificationRegistry() }
+
     factory { SystemNotificationNotifier() }
-    factory<NotificationNotifier<InAppNotification>>(named<InAppNotificationNotifier>()) {
-        InAppNotificationNotifier()
+
+    single { InAppNotificationEventBus() }
+        .bind(InAppNotificationReceiver::class)
+
+    single<NotificationNotifier<InAppNotification>>(named<InAppNotificationNotifier>()) {
+        InAppNotificationNotifier(
+            logger = get(),
+            notificationRegistry = get(),
+            inAppNotificationEventBus = get(),
+        )
     }
 
     factory<NotificationCommandFactory> {
@@ -38,6 +51,4 @@ val featureNotificationModule = module {
             commandFactory = get(),
         )
     }
-
-    single<NotificationRegistry> { DefaultNotificationRegistry() }
 }

feature/notification/impl/src/commonMain/kotlin/net/thunderbird/feature/notification/impl/receiver/InAppNotificationEventBus.kt

@@ -0,0 +1,31 @@
+package net.thunderbird.feature.notification.impl.receiver
+
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import net.thunderbird.feature.notification.api.receiver.InAppNotificationEvent
+import net.thunderbird.feature.notification.api.receiver.InAppNotificationReceiver
+
+/**
+ * An event bus for in-app notifications.
+ *
+ * This interface extends [InAppNotificationReceiver] to allow listening for notification events,
+ * and adds a [publish] method to send new notification events.
+ */
+internal interface InAppNotificationEventBus : InAppNotificationReceiver {
+    /**
+     * Publishes an in-app notification event to the event bus.
+     *
+     * @param event The [InAppNotificationEvent] to be published.
+     */
+    suspend fun publish(event: InAppNotificationEvent)
+}
+
+internal fun InAppNotificationEventBus(): InAppNotificationEventBus = object : InAppNotificationEventBus {
+    private val _events = MutableSharedFlow<InAppNotificationEvent>(replay = 1)
+    override val events: SharedFlow<InAppNotificationEvent> = _events.asSharedFlow()
+
+    override suspend fun publish(event: InAppNotificationEvent) {
+        _events.emit(event)
+    }
+}