Refactor: Introduce SnackbarCoordinator for managing snackbar display

gstamatop · gstamatop · commit 9b6a961ec77b · 2025-09-08T17:33:08.000+03:00
This commit introduces a `SnackbarCoordinator` to manage snackbar messages across different screens within the dashboard.

Key changes:
- Added `SnackbarCoordinator` to handle snackbar ownership and prevent conflicts between screens.
- Implemented `rememberScreenSnackbarController` to allow screens to claim ownership and display snackbars.
- Integrated `ShowErrorAsSnackbar` composable to display error messages using the new snackbar system.
- Updated `DocumentsScreen` and `TransactionsScreen` to utilize the `ScreenSnackbar` controller for error display.
- Modified `DashboardScreen` to use `SnackbarCoordinator` and provide snackbar controllers to child screens.
- Added `WrapSnackbar` composable for custom and default snackbar styles.
diff --git a/dashboard-feature/src/main/java/eu/europa/ec/dashboardfeature/ui/dashboard/DashboardScreen.kt b/dashboard-feature/src/main/java/eu/europa/ec/dashboardfeature/ui/dashboard/DashboardScreen.kt
@@ -55,10 +55,14 @@ import eu.europa.ec.dashboardfeature.ui.transactions.list.TransactionsScreen
 import eu.europa.ec.dashboardfeature.ui.transactions.list.TransactionsViewModel
 import eu.europa.ec.resourceslogic.R
 import eu.europa.ec.uilogic.component.SystemBroadcastReceiver
+import eu.europa.ec.uilogic.component.snackbar.rememberScreenSnackbarController
+import eu.europa.ec.uilogic.component.snackbar.rememberSnackbarCoordinator
 import eu.europa.ec.uilogic.component.utils.LifecycleEffect
 import eu.europa.ec.uilogic.component.wrap.BottomSheetTextDataUi
 import eu.europa.ec.uilogic.component.wrap.BottomSheetWithOptionsList
+import eu.europa.ec.uilogic.component.wrap.SnackbarType
 import eu.europa.ec.uilogic.component.wrap.WrapModalBottomSheet
+import eu.europa.ec.uilogic.component.wrap.WrapSnackbar
 import eu.europa.ec.uilogic.extension.finish
 import eu.europa.ec.uilogic.extension.getPendingDeepLink
 import eu.europa.ec.uilogic.extension.openAppSettings
@@ -89,7 +93,15 @@ internal fun DashboardScreen(
         skipPartiallyExpanded = true
     )
 
+    val snackbarCoordinator = rememberSnackbarCoordinator()
+
     Scaffold(
+        snackbarHost = {
+            WrapSnackbar(
+                hostState = snackbarCoordinator.hostState,
+                type = SnackbarType.DEFAULT
+            )
+        },
         bottomBar = { BottomNavigationBar(bottomNavigationController) }
     ) { padding ->
         NavHost(
@@ -101,26 +113,42 @@ internal fun DashboardScreen(
         ) {
             composable(BottomNavigationItem.Home.route) {
                 HomeScreen(
-                    hostNavController,
-                    homeViewModel,
+                    navHostController = hostNavController,
+                    viewModel = homeViewModel,
                     onDashboardEventSent = { event ->
                         viewModel.setEvent(event)
                     }
                 )
             }
             composable(BottomNavigationItem.Documents.route) {
+                val snackbarController = rememberScreenSnackbarController(
+                    ownerKey = BottomNavigationItem.Documents.route,
+                    hostState = snackbarCoordinator.hostState,
+                    activeOwnerState = { snackbarCoordinator.activeOwner },
+                    setActiveOwner = { snackbarCoordinator.activeOwner = it }
+                )
+
                 DocumentsScreen(
-                    hostNavController,
-                    documentsViewModel,
+                    navHostController = hostNavController,
+                    snackbar = snackbarController,
+                    viewModel = documentsViewModel,
                     onDashboardEventSent = { event ->
                         viewModel.setEvent(event)
                     }
                 )
             }
             composable(BottomNavigationItem.Transactions.route) {
+                val snackbarController = rememberScreenSnackbarController(
+                    ownerKey = BottomNavigationItem.Transactions.route,
+                    hostState = snackbarCoordinator.hostState,
+                    activeOwnerState = { snackbarCoordinator.activeOwner },
+                    setActiveOwner = { snackbarCoordinator.activeOwner = it }
+                )
+
                 TransactionsScreen(
-                    hostNavController,
-                    transactionsViewModel,
+                    navHostController = hostNavController,
+                    snackbar = snackbarController,
+                    viewModel = transactionsViewModel,
                     onDashboardEventSent = { event ->
                         viewModel.setEvent(event)
                     }
diff --git a/dashboard-feature/src/main/java/eu/europa/ec/dashboardfeature/ui/documents/list/DocumentsScreen.kt b/dashboard-feature/src/main/java/eu/europa/ec/dashboardfeature/ui/documents/list/DocumentsScreen.kt
@@ -78,6 +78,8 @@ import eu.europa.ec.uilogic.component.content.ContentScreen
 import eu.europa.ec.uilogic.component.content.ScreenNavigateAction
 import eu.europa.ec.uilogic.component.preview.PreviewTheme
 import eu.europa.ec.uilogic.component.preview.ThemeModePreviews
+import eu.europa.ec.uilogic.component.snackbar.ScreenSnackbar
+import eu.europa.ec.uilogic.component.snackbar.ShowErrorAsSnackbar
 import eu.europa.ec.uilogic.component.utils.HSpacer
 import eu.europa.ec.uilogic.component.utils.LifecycleEffect
 import eu.europa.ec.uilogic.component.utils.OneTimeLaunchedEffect
@@ -114,6 +116,7 @@ typealias OpenSideMenuEvent = eu.europa.ec.dashboardfeature.ui.dashboard.Event.S
 @Composable
 fun DocumentsScreen(
     navHostController: NavController,
+    snackbar: ScreenSnackbar,
     viewModel: DocumentsViewModel,
     onDashboardEventSent: (DashboardEvent) -> Unit,
 ) {
@@ -130,7 +133,7 @@ fun DocumentsScreen(
         isLoading = state.isLoading,
         navigatableAction = ScreenNavigateAction.NONE,
         onBack = { context.finish() },
-        contentErrorConfig = state.error,
+        contentErrorConfig = null,
         topBar = {
             TopBar(
                 onEventSend = { viewModel.setEvent(it) },
@@ -179,6 +182,11 @@ fun DocumentsScreen(
             }
         }
     }
+
+    ShowErrorAsSnackbar(
+        error = state.error,
+        snackbar = snackbar
+    )
 }
 
 private fun handleNavigationEffect(
diff --git a/dashboard-feature/src/main/java/eu/europa/ec/dashboardfeature/ui/transactions/list/TransactionsScreen.kt b/dashboard-feature/src/main/java/eu/europa/ec/dashboardfeature/ui/transactions/list/TransactionsScreen.kt
@@ -85,6 +85,8 @@ import eu.europa.ec.uilogic.component.SectionTitle
 import eu.europa.ec.uilogic.component.content.ContentScreen
 import eu.europa.ec.uilogic.component.content.ScreenNavigateAction
 import eu.europa.ec.uilogic.component.preview.ThemeModePreviews
+import eu.europa.ec.uilogic.component.snackbar.ScreenSnackbar
+import eu.europa.ec.uilogic.component.snackbar.ShowErrorAsSnackbar
 import eu.europa.ec.uilogic.component.utils.HSpacer
 import eu.europa.ec.uilogic.component.utils.LifecycleEffect
 import eu.europa.ec.uilogic.component.utils.OneTimeLaunchedEffect
@@ -119,6 +121,7 @@ typealias OpenSideMenuEvent = eu.europa.ec.dashboardfeature.ui.dashboard.Event.S
 @Composable
 fun TransactionsScreen(
     navHostController: NavController,
+    snackbar: ScreenSnackbar,
     viewModel: TransactionsViewModel,
     onDashboardEventSent: (DashboardEvent) -> Unit,
 ) {
@@ -134,7 +137,7 @@ fun TransactionsScreen(
 
     ContentScreen(
         isLoading = state.isLoading,
-        contentErrorConfig = state.error,
+        contentErrorConfig = null,
         navigatableAction = ScreenNavigateAction.NONE,
         onBack = { context.finish() },
         topBar = {
@@ -213,6 +216,11 @@ fun TransactionsScreen(
             )
         }
     }
+
+    ShowErrorAsSnackbar(
+        error = state.error,
+        snackbar = snackbar
+    )
 }
 
 @OptIn(ExperimentalMaterial3Api::class)
diff --git a/ui-logic/src/main/java/eu/europa/ec/uilogic/component/snackbar/ScreenSnackbar.kt b/ui-logic/src/main/java/eu/europa/ec/uilogic/component/snackbar/ScreenSnackbar.kt
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2025 European Commission
+ *
+ * Licensed under the EUPL, Version 1.2 or - as soon they will be approved by the European
+ * Commission - subsequent versions of the EUPL (the "Licence"); You may not use this work
+ * except in compliance with the Licence.
+ *
+ * You may obtain a copy of the Licence at:
+ * https://joinup.ec.europa.eu/software/page/eupl
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the Licence is distributed on an "AS IS" basis, WITHOUT WARRANTIES OR CONDITIONS OF
+ * ANY KIND, either express or implied. See the Licence for the specific language
+ * governing permissions and limitations under the Licence.
+ */
+
+package eu.europa.ec.uilogic.component.snackbar
+
+import androidx.compose.material3.SnackbarDuration
+import androidx.compose.material3.SnackbarHostState
+import androidx.compose.material3.SnackbarResult
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.res.stringResource
+import eu.europa.ec.resourceslogic.R
+import eu.europa.ec.uilogic.component.content.ContentErrorConfig
+import kotlinx.coroutines.launch
+
+interface ScreenSnackbar {
+    fun show(
+        message: String,
+        actionLabel: String? = null,
+        duration: SnackbarDuration = SnackbarDuration.Indefinite,
+        onAction: (() -> Unit)? = null,
+        onDismiss: (() -> Unit)? = null,
+    )
+
+    fun dismiss()
+}
+
+/**
+ * A small controller that lets a screen *coordinate* Snackbar usage when multiple siblings
+ * share the same [SnackbarHostState] (e.g., tabs in a bottom nav).
+ *
+ * Ownership model:
+ * - Each screen has a unique [ownerKey].
+ * - Before showing a snackbar, the screen "claims" ownership via [setActiveOwner].
+ * - When the snackbar completes (action/dismiss) the screen *releases* ownership,
+ *   but only if it's still the owner (another screen might have claimed it in the meantime).
+ *
+ * This prevents one screen from accidentally dismissing or overriding another screen’s snackbar,
+ * and keeps callbacks (onAction/onDismiss) scoped to the screen that actually owned the snackbar.
+ *
+ * @param ownerKey          Unique id for the caller (e.g., "DOCUMENTS", "TRANSACTIONS").
+ * @param hostState         The shared SnackbarHostState.
+ * @param activeOwnerState  Read the current owner (null if none).
+ * @param setActiveOwner    Write the current owner (set to null to release).
+ */
+@Composable
+fun rememberScreenSnackbarController(
+    ownerKey: String,
+    hostState: SnackbarHostState,
+    activeOwnerState: () -> String?,
+    setActiveOwner: (String?) -> Unit
+): ScreenSnackbar {
+    val scope = rememberCoroutineScope()
+
+    // Recreate the controller only if the owner identity or host changes.
+    return remember(ownerKey, hostState) {
+        object : ScreenSnackbar {
+            override fun show(
+                message: String,
+                actionLabel: String?,
+                duration: SnackbarDuration,
+                onAction: (() -> Unit)?,
+                onDismiss: (() -> Unit)?
+            ) {
+                scope.launch {
+                    // Claim ownership for *this* screen before showing.
+                    setActiveOwner(ownerKey)
+
+                    // Suspends until the snackbar is acted upon or dismissed.
+                    val snackbarResult = hostState.showSnackbar(
+                        message = message,
+                        actionLabel = actionLabel,
+                        withDismissAction = true,
+                        duration = duration
+                    )
+
+                    // Only fire callbacks if we *still* own it.
+                    // Another screen might have claimed ownership while this was showing.
+                    if (activeOwnerState() == ownerKey) {
+                        when (snackbarResult) {
+                            SnackbarResult.ActionPerformed -> onAction?.invoke()
+                            SnackbarResult.Dismissed -> onDismiss?.invoke()
+                        }
+
+                        // Release the lock, but only if we are still the owner.
+                        // (Callbacks above could navigate and cause ownership changes.)
+                        if (activeOwnerState() == ownerKey) {
+                            setActiveOwner(null)
+                        }
+                    }
+                }
+            }
+
+            override fun dismiss() {
+                // Only dismiss if we currently own the snackbar.
+                if (activeOwnerState() == ownerKey) {
+                    hostState.currentSnackbarData?.dismiss()
+
+                    // Release ownership if it still belongs to us after dismissal.
+                    if (activeOwnerState() == ownerKey) {
+                        setActiveOwner(null)
+                    }
+                }
+            }
+        }
+    }
+}
+
+/**
+ * Displays an error message as a snackbar on the current screen.
+ *
+ * This Composable function takes a [ContentErrorConfig] object and uses the provided
+ * [ScreenSnackbar] controller to show an error message.
+ *
+ * Behavior:
+ * - If an action is performed on the snackbar (e.g., tapping a "Retry" button),
+ *   the `error.onRetry` lambda will be invoked.
+ * - If the snackbar is dismissed (either by user swipe, timeout, or programmatically),
+ *   the `error.onCancel` lambda will be invoked.
+ * - The snackbar will be automatically dismissed when this Composable leaves the composition
+ *   (e.g., when the screen is navigated away from).
+ * - If the [error] parameter is `null`, any currently shown snackbar by this controller
+ *   will be dismissed.
+ *
+ * @param error The configuration for the error to be displayed.
+ * @param snackbar The [ScreenSnackbar] controller responsible for managing and displaying
+ *                 the snackbar.
+ * @param fallbackMessage The message to display if [error] is `null` or if both
+ *                        `error.errorTitle` and `error.errorSubTitle` are `null`.
+ *                        Defaults to the generic error message.
+ * @param retryLabel The text to display for the snackbar's action button. This is only
+ *                   shown if `error.onRetry` is not `null`. Defaults to the generic "Retry" label.
+ * @param duration The duration for which the snackbar should be displayed. Defaults to
+ *                 [SnackbarDuration.Indefinite], meaning it will stay until an action
+ *                 is taken or it's dismissed.
+ */
+@Composable
+fun ShowErrorAsSnackbar(
+    error: ContentErrorConfig?,
+    snackbar: ScreenSnackbar,
+    fallbackMessage: String = stringResource(R.string.generic_error_message),
+    retryLabel: String = stringResource(R.string.generic_error_button_retry),
+    duration: SnackbarDuration = SnackbarDuration.Indefinite,
+) {
+    val message = remember(error, fallbackMessage) {
+        error?.errorTitle ?: error?.errorSubTitle ?: fallbackMessage
+    }
+    val actionLabel = remember(error, retryLabel) {
+        error?.onRetry?.let {
+            retryLabel
+        }
+    }
+
+    LaunchedEffect(error, snackbar) {
+        if (error != null) {
+            snackbar.show(
+                message = message,
+                actionLabel = actionLabel,
+                duration = duration,
+                onAction = error.onRetry,
+                onDismiss = error.onCancel
+            )
+        }
+    }
+
+    DisposableEffect(snackbar) {
+        onDispose { snackbar.dismiss() }
+    }
+}
diff --git a/ui-logic/src/main/java/eu/europa/ec/uilogic/component/snackbar/SnackbarCoordinator.kt b/ui-logic/src/main/java/eu/europa/ec/uilogic/component/snackbar/SnackbarCoordinator.kt
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2025 European Commission
+ *
+ * Licensed under the EUPL, Version 1.2 or - as soon they will be approved by the European
+ * Commission - subsequent versions of the EUPL (the "Licence"); You may not use this work
+ * except in compliance with the Licence.
+ *
+ * You may obtain a copy of the Licence at:
+ * https://joinup.ec.europa.eu/software/page/eupl
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the Licence is distributed on an "AS IS" basis, WITHOUT WARRANTIES OR CONDITIONS OF
+ * ANY KIND, either express or implied. See the Licence for the specific language
+ * governing permissions and limitations under the Licence.
+ */
+
+package eu.europa.ec.uilogic.component.snackbar
+
+import androidx.compose.material3.SnackbarHostState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+
+/**
+ * Manages the display of Snackbar messages across multiple components (owners).
+ *
+ * This coordinator ensures that only one snackbar is shown at a time, even if multiple
+ * components attempt to display a message simultaneously. It tracks the "active owner"
+ * of the snackbar, allowing components to request to show a snackbar and become the
+ * active owner.
+ *
+ * @property hostState The [SnackbarHostState] used to show snackbar messages. This is
+ *                     typically provided by a `Scaffold` composable.
+ * @property activeOwner The identifier of the component that currently "owns" the
+ *                       snackbar. This is `null` if no snackbar is currently being shown
+ *                       or if the active snackbar is not associated with a specific owner.
+ *                       This property is observable using Compose's state mechanism.
+ */
+class SnackbarCoordinator(
+    val hostState: SnackbarHostState
+) {
+    var activeOwner by mutableStateOf<String?>(null)
+}
+
+@Composable
+fun rememberSnackbarCoordinator(): SnackbarCoordinator {
+    return remember { SnackbarCoordinator(hostState = SnackbarHostState()) }
+}
diff --git a/ui-logic/src/main/java/eu/europa/ec/uilogic/component/wrap/WrapSnackbar.kt b/ui-logic/src/main/java/eu/europa/ec/uilogic/component/wrap/WrapSnackbar.kt
