chore(deps): update gradle to v9.7.1

app/src/main/java/de/jeanlucmakiola/calendula/domain/Models.kt

@@ -253,13 +253,6 @@ enum class FailureReason {
     PermissionRevoked,
     NoCalendarsConfigured,
     AllCalendarsHidden,
-
-    /**
-     * Calendars exist and are switched on, but none can receive an event: every
-     * one is read-only, app-managed, or not synced to this device. Distinct from
-     * [AllCalendarsHidden], which a visibility switch fixes.
-     */
-    NoImportTarget,
     ProviderUnavailable,
     EventNotFound,
     Unknown,

app/src/main/java/de/jeanlucmakiola/calendula/ui/CalendarHost.kt

@@ -550,30 +550,18 @@ fun CalendarHost(
             enter = slideInHorizontally(slideSpec) { it } + fadeIn(),
             exit = slideOutHorizontally(slideSpec) { it } + fadeOut(),
         ) {
-            // Settings can open this screen without the manager underneath, so
-            // its failure states' "Manage calendars" way out has to open the
-            // manager rather than just pop — popping alone lands on Settings
-            // (#304). Coming from the manager the flag is already set, so this
-            // is the same pop-back there.
-            CompositionLocalProvider(
-                LocalManageCalendars provides {
-                    showCalendars = true
+            BackupScreen(
+                onBack = { showBackup = false },
+                // Restore runs the normal .ics import, and both this screen and
+                // the manager that can have opened it are declared above the
+                // import overlays — so both have to step aside.
+                onImport = {
+                    importUri = it
+                    importForceMany = true
                     showBackup = false
+                    showCalendars = false
                 },
-            ) {
-                BackupScreen(
-                    onBack = { showBackup = false },
-                    // Restore runs the normal .ics import, and both this screen
-                    // and the manager that can have opened it are declared above
-                    // the import overlays — so both have to step aside.
-                    onImport = {
-                        importUri = it
-                        importForceMany = true
-                        showBackup = false
-                        showCalendars = false
-                    },
-                )
-            }
+            )
         }
     }
 }

app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/BackupScreen.kt

@@ -4,11 +4,9 @@ import android.net.Uri
 import android.text.format.DateUtils
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
@@ -20,7 +18,6 @@ import androidx.compose.material.icons.filled.Schedule
 import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Button
 import androidx.compose.material3.Checkbox
-import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.SnackbarHostState
@@ -50,10 +47,9 @@ import de.jeanlucmakiola.calendula.R
 import de.jeanlucmakiola.calendula.data.prefs.BackupStatus
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.domain.CalendarSource
+import de.jeanlucmakiola.calendula.domain.isEventTarget
 import de.jeanlucmakiola.calendula.ui.common.CalendarColorChip
-import de.jeanlucmakiola.calendula.ui.common.CalendarFailure
 import de.jeanlucmakiola.calendula.ui.common.LeadingAvatar
-import de.jeanlucmakiola.calendula.ui.common.LocalManageCalendars
 import de.jeanlucmakiola.floret.components.CollapsingScaffold
 import de.jeanlucmakiola.floret.components.DialogAmountField
 import de.jeanlucmakiola.floret.components.DialogUnitDropdown
@@ -84,13 +80,18 @@ fun BackupScreen(
     onImport: (Uri) -> Unit,
     viewModel: CalendarsViewModel = hiltViewModel(),
 ) {
-    val state by viewModel.backupState.collectAsStateWithLifecycle()
+    val calendars by viewModel.calendars.collectAsStateWithLifecycle()
     val backupResult by viewModel.backupResult.collectAsStateWithLifecycle()
     val autoBackup by viewModel.autoBackup.collectAsStateWithLifecycle()
 
     val context = LocalContext.current
     val snackbarHostState = remember { SnackbarHostState() }
 
+    // Export covers local calendars only; managed special-dates mirrors are
+    // rebuilt from contacts. Restore can target anything the import picker offers.
+    val exportable = calendars.filter { it.isLocal && it.canModifyContents && !it.isManaged }
+    val canImport = calendars.any { it.isEventTarget }
+
     // Exports everything eligible (null); the per-calendar selector owns its
     // own launcher.
     val createBackup = rememberLauncherForActivityResult(
@@ -131,42 +132,78 @@ fun BackupScreen(
     CollapsingScaffold(
         title = stringResource(R.string.settings_section_backup),
         onBack = onBack,
-        // Loading and failure fill the screen and centre themselves, which they
-        // can only do in an unscrolled column — the scrolling one measures them
-        // against an unbounded height and leaves them hanging under the header.
-        scrollable = state is BackupUiState.Ready,
         snackbarHost = { SnackbarHost(snackbarHostState) },
         predictiveBack = true,
     ) {
-        when (val s = state) {
-            BackupUiState.Loading -> BackupLoading()
-            is BackupUiState.Failure -> CalendarFailure(reason = s.reason, onRetry = onBack)
-            is BackupUiState.Ready -> BackupContent(
-                exportable = s.exportable,
-                canImport = s.canImport,
-                autoBackup = autoBackup,
-                viewModel = viewModel,
-                onRestore = { runCatching { openBackup.launch(RESTORE_MIME_TYPES) } },
-                onPickFolder = { runCatching { pickFolder.launch(null) } },
-                onExportAll = {
-                    runCatching { createBackup.launch(defaultBackupName()) }
+        HintText(stringResource(R.string.calendars_backup_hint))
+
+        if (exportable.isNotEmpty()) {
+            GroupedRow(
+                title = stringResource(R.string.calendars_backup_action),
+                position = Position.Top,
+                leading = { LeadingAvatar(Icons.Default.FileDownload) },
+                onClick = {
+                    // A single exportable calendar skips the selector.
+                    if (exportable.size == 1) {
+                        runCatching { createBackup.launch("calendula-backup-${LocalDate.now()}.ics") }
+                    } else {
+                        showExportPicker = true
+                    }
                 },
-                onExportPick = { showExportPicker = true },
-                onEditInterval = { showInterval = true },
+            )
+            GroupedRow(
+                title = stringResource(R.string.calendars_restore_action),
+                summary = stringResource(R.string.calendars_restore_hint),
+                position = Position.Middle,
+                leading = { LeadingAvatar(Icons.Default.FileUpload) },
+                onClick = { runCatching { openBackup.launch(RESTORE_MIME_TYPES) } },
+            )
+            GroupedRow(
+                title = stringResource(R.string.calendars_auto_backup),
+                summary = stringResource(R.string.calendars_auto_backup_hint),
+                position = if (autoBackup.enabled) Position.Middle else Position.Bottom,
+                leading = { LeadingAvatar(Icons.Default.Schedule) },
+                trailing = {
+                    Switch(checked = autoBackup.enabled, onCheckedChange = viewModel::setAutoBackupEnabled)
+                },
+                onClick = { viewModel.setAutoBackupEnabled(!autoBackup.enabled) },
+            )
+            if (autoBackup.enabled) {
+                GroupedRow(
+                    title = stringResource(R.string.calendars_auto_backup_folder),
+                    summary = rememberFolderName(autoBackup.folderUri)
+                        ?: stringResource(R.string.calendars_auto_backup_folder_unset),
+                    position = Position.Middle,
+                    onClick = { runCatching { pickFolder.launch(null) } },
+                )
+                GroupedRow(
+                    title = stringResource(R.string.calendars_auto_backup_interval),
+                    summary = backupIntervalLabel(autoBackup.intervalMinutes),
+                    position = Position.Bottom,
+                    onClick = { showInterval = true },
+                )
+                HintText(backupStatusText(autoBackup.status))
+            }
+        } else if (canImport) {
+            // Nothing to back up, but restore is still possible — don't hide
+            // it behind export eligibility.
+            SectionHeader(stringResource(R.string.calendars_restore_header))
+            HintText(stringResource(R.string.calendars_restore_hint))
+            GroupedRow(
+                title = stringResource(R.string.calendars_restore_action),
+                position = Position.Alone,
+                leading = { LeadingAvatar(Icons.Default.FileUpload) },
+                onClick = { runCatching { openBackup.launch(RESTORE_MIME_TYPES) } },
             )
         }
     }
 
-    // Gated on Ready rather than resetting the flag when the state leaves it:
-    // flipping it here would be a write during composition.
-    (state as? BackupUiState.Ready)?.let { ready ->
-        if (showExportPicker) {
-            ExportCalendarPicker(
-                calendars = ready.exportable,
-                onExport = viewModel::exportBackup,
-                onDismiss = { showExportPicker = false },
-            )
-        }
+    if (showExportPicker) {
+        ExportCalendarPicker(
+            calendars = exportable,
+            onExport = viewModel::exportBackup,
+            onDismiss = { showExportPicker = false },
+        )
     }
     if (showInterval) {
         BackupIntervalDialog(
@@ -177,103 +214,6 @@ fun BackupScreen(
     }
 }
 
-/** The screen's loading state, centred in the scaffold's content column. */
-@Composable
-private fun BackupLoading() {
-    Box(
-        modifier = Modifier.fillMaxSize(),
-        contentAlignment = Alignment.Center,
-    ) {
-        CircularProgressIndicator()
-    }
-}
-
-/** Default file name for a one-shot export. */
-private fun defaultBackupName(): String = "calendula-backup-${LocalDate.now()}.ics"
-
-/**
- * The working screen: export (when there are local calendars to export), restore,
- * and the automatic-backup block. Restore is always on screen — when nothing can
- * receive the events it says so and routes to the calendar manager rather than
- * disappearing, which is what #304 reported as an invisible button.
- */
-@Composable
-private fun BackupContent(
-    exportable: List<CalendarSource>,
-    canImport: Boolean,
-    autoBackup: AutoBackupUiState,
-    viewModel: CalendarsViewModel,
-    onRestore: () -> Unit,
-    onPickFolder: () -> Unit,
-    onExportAll: () -> Unit,
-    onExportPick: () -> Unit,
-    onEditInterval: () -> Unit,
-) {
-    val manageCalendars = LocalManageCalendars.current
-    // Restore never depends on export eligibility, and never disappears: when no
-    // calendar can receive events it explains that and offers the way to fix it.
-    val restoreSummary = if (canImport) {
-        stringResource(R.string.calendars_restore_hint)
-    } else {
-        stringResource(R.string.calendars_restore_unavailable)
-    }
-    val onRestoreClick = if (canImport) onRestore else (manageCalendars ?: onRestore)
-
-    if (exportable.isEmpty()) {
-        SectionHeader(stringResource(R.string.calendars_restore_header))
-        HintText(restoreSummary)
-        GroupedRow(
-            title = stringResource(R.string.calendars_restore_action),
-            position = Position.Alone,
-            leading = { LeadingAvatar(Icons.Default.FileUpload) },
-            onClick = onRestoreClick,
-        )
-        return
-    }
-
-    HintText(stringResource(R.string.calendars_backup_hint))
-    GroupedRow(
-        title = stringResource(R.string.calendars_backup_action),
-        position = Position.Top,
-        leading = { LeadingAvatar(Icons.Default.FileDownload) },
-        // A single exportable calendar skips the selector.
-        onClick = if (exportable.size == 1) onExportAll else onExportPick,
-    )
-    GroupedRow(
-        title = stringResource(R.string.calendars_restore_action),
-        summary = restoreSummary,
-        position = Position.Middle,
-        leading = { LeadingAvatar(Icons.Default.FileUpload) },
-        onClick = onRestoreClick,
-    )
-    GroupedRow(
-        title = stringResource(R.string.calendars_auto_backup),
-        summary = stringResource(R.string.calendars_auto_backup_hint),
-        position = if (autoBackup.enabled) Position.Middle else Position.Bottom,
-        leading = { LeadingAvatar(Icons.Default.Schedule) },
-        trailing = {
-            Switch(checked = autoBackup.enabled, onCheckedChange = viewModel::setAutoBackupEnabled)
-        },
-        onClick = { viewModel.setAutoBackupEnabled(!autoBackup.enabled) },
-    )
-    if (autoBackup.enabled) {
-        GroupedRow(
-            title = stringResource(R.string.calendars_auto_backup_folder),
-            summary = rememberFolderName(autoBackup.folderUri)
-                ?: stringResource(R.string.calendars_auto_backup_folder_unset),
-            position = Position.Middle,
-            onClick = onPickFolder,
-        )
-        GroupedRow(
-            title = stringResource(R.string.calendars_auto_backup_interval),
-            summary = backupIntervalLabel(autoBackup.intervalMinutes),
-            position = Position.Bottom,
-            onClick = onEditInterval,
-        )
-        HintText(backupStatusText(autoBackup.status))
-    }
-}
-
 /**
  * Choose which local calendars to include in a one-time `.ics` export. Defaults
  * to all selected; the Export action opens the SAF save dialog and hands back

app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/BackupUiState.kt

@@ -1,53 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.calendars
-
-import de.jeanlucmakiola.calendula.domain.CalendarSource
-import de.jeanlucmakiola.calendula.domain.FailureReason
-import de.jeanlucmakiola.calendula.domain.calendarListFailure
-import de.jeanlucmakiola.calendula.domain.isEventTarget
-
-/**
- * State of the Backup & restore screen (#69). Three states, because the calendar
- * list it is derived from has all three: it arrives empty, it can throw, and
- * "loaded but nothing to offer" is a real outcome the screen used to render as a
- * blank page (#304).
- */
-sealed interface BackupUiState {
-    data object Loading : BackupUiState
-    data class Failure(val reason: FailureReason) : BackupUiState
-
-    /**
-     * At least one half of the screen works. [exportable] may be empty (restore
-     * only) and [canImport] may be false (export only), but never both — that is
-     * a [Failure].
-     */
-    data class Ready(
-        val exportable: List<CalendarSource>,
-        val canImport: Boolean,
-    ) : BackupUiState
-}
-
-/**
- * What the screen can offer for this calendar list.
- *
- * Export covers the app's own local calendars; managed special-dates mirrors are
- * rebuilt from contacts, so they are excluded. Restore can target anything the
- * import picker offers ([isEventTarget]).
- *
- * A failure is raised only when *neither* is possible — deliberately not
- * [calendarListFailure] on its own, which would call an all-hidden device a
- * failure while its local calendars are still perfectly exportable. When both
- * halves are dead the list itself usually says why (no calendars, everything
- * switched off); [FailureReason.NoImportTarget] covers the remaining case, where
- * calendars exist and are visible but every one of them is read-only, managed or
- * not synced to the device.
- */
-fun backupUiState(calendars: List<CalendarSource>): BackupUiState {
-    val exportable = calendars.filter { it.isLocal && it.canModifyContents && !it.isManaged }
-    val canImport = calendars.any { it.isEventTarget }
-    if (exportable.isEmpty() && !canImport) {
-        return BackupUiState.Failure(
-            calendarListFailure(calendars) ?: FailureReason.NoImportTarget,
-        )
-    }
-    return BackupUiState.Ready(exportable = exportable, canImport = canImport)
-}

app/src/main/java/de/jeanlucmakiola/calendula/ui/calendars/CalendarsViewModel.kt

@@ -14,7 +14,6 @@ import de.jeanlucmakiola.calendula.data.ics.IcsExporter
 import de.jeanlucmakiola.calendula.data.prefs.BackupStatus
 import de.jeanlucmakiola.calendula.data.prefs.SettingsPrefs
 import de.jeanlucmakiola.calendula.domain.CalendarSource
-import de.jeanlucmakiola.calendula.domain.FailureReason
 import de.jeanlucmakiola.calendula.domain.ics.IcsWriter
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -25,7 +24,6 @@ import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flowOn
-import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -58,22 +56,6 @@ class CalendarsViewModel @Inject constructor(
                 initialValue = emptyList(),
             )
 
-    /**
-     * The Backup & restore screen's own view of that list, with the loading and
-     * failure states [calendars] flattens away — it starts empty and catches to
-     * empty, which that screen used to render as a blank page (#304).
-     */
-    val backupState: StateFlow<BackupUiState> =
-        repository.calendars()
-            .map { backupUiState(it) }
-            .catch { emit(BackupUiState.Failure(FailureReason.ProviderUnavailable)) }
-            .flowOn(io)
-            .stateIn(
-                scope = viewModelScope,
-                started = SharingStarted.WhileSubscribed(5_000L),
-                initialValue = BackupUiState.Loading,
-            )
-
     /** Automatic-backup settings + last-run status, for the Backup section UI. */
     val autoBackup: StateFlow<AutoBackupUiState> = combine(
         settingsPrefs.autoBackupEnabled,

app/src/main/java/de/jeanlucmakiola/calendula/ui/common/CalendarFailure.kt

@@ -4,36 +4,19 @@ import android.content.Context
 import android.content.Intent
 import android.provider.CalendarContract
 import android.provider.Settings
-import androidx.annotation.StringRes
-import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.widthIn
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.outlined.CalendarMonth
-import androidx.compose.material.icons.outlined.EditOff
-import androidx.compose.material.icons.outlined.ErrorOutline
-import androidx.compose.material.icons.outlined.EventBusy
-import androidx.compose.material.icons.outlined.Lock
-import androidx.compose.material.icons.outlined.SyncProblem
-import androidx.compose.material.icons.outlined.VisibilityOff
 import androidx.compose.material3.FilledTonalButton
-import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.compositionLocalOf
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
@@ -43,150 +26,52 @@ import de.jeanlucmakiola.calendula.domain.FailureReason
 
 /**
  * Full-screen failure state shared by every calendar screen (spec §7).
- * A tonal icon, one headline, one supporting line and one recovery action —
- * never a toast.
+ * One explanation line + one recovery action, never a toast.
  */
 @Composable
-fun CalendarFailure(
-    reason: FailureReason,
-    onRetry: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
+fun CalendarFailure(reason: FailureReason, onRetry: () -> Unit) {
     val context = LocalContext.current
     val manageCalendars = LocalManageCalendars.current
-    val copy = failureCopy(reason)
+    val titleRes = when (reason) {
+        FailureReason.PermissionRevoked -> R.string.state_failure_permission
+        FailureReason.NoCalendarsConfigured -> R.string.state_failure_no_calendars
+        FailureReason.AllCalendarsHidden -> R.string.state_failure_all_hidden
+        FailureReason.ProviderUnavailable -> R.string.state_failure_provider
+        FailureReason.Unknown,
+        FailureReason.EventNotFound -> R.string.state_failure_unknown
+    }
+    val actionRes = when (reason) {
+        FailureReason.NoCalendarsConfigured -> R.string.state_failure_no_calendars_action
+        FailureReason.AllCalendarsHidden -> R.string.state_failure_all_hidden_action
+        FailureReason.PermissionRevoked -> R.string.state_failure_permission_action
+        else -> R.string.state_retry
+    }
     val onAction: () -> Unit = when (reason) {
         FailureReason.NoCalendarsConfigured -> {
             { context.startCalendarSetup() }
         }
-        FailureReason.AllCalendarsHidden,
-        FailureReason.NoImportTarget,
-        -> manageCalendars ?: onRetry
+        FailureReason.AllCalendarsHidden -> manageCalendars ?: onRetry
         else -> onRetry
     }
     Column(
-        modifier = modifier
+        modifier = Modifier
             .fillMaxSize()
-            .padding(horizontal = 32.dp, vertical = 24.dp),
+            .padding(32.dp),
         verticalArrangement = Arrangement.Center,
         horizontalAlignment = Alignment.CenterHorizontally,
     ) {
-        FailureIcon(icon = copy.icon, isError = copy.isError)
-        Spacer(Modifier.height(24.dp))
         Text(
-            text = stringResource(copy.title),
+            text = stringResource(titleRes),
             style = MaterialTheme.typography.headlineSmall,
             textAlign = TextAlign.Center,
-            modifier = Modifier.widthIn(max = TEXT_MAX_WIDTH),
         )
-        copy.body?.let { body ->
-            Spacer(Modifier.height(12.dp))
-            Text(
-                text = stringResource(body),
-                style = MaterialTheme.typography.bodyMedium,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                textAlign = TextAlign.Center,
-                modifier = Modifier.widthIn(max = TEXT_MAX_WIDTH),
-            )
-        }
-        Spacer(Modifier.height(32.dp))
+        Spacer(Modifier.height(24.dp))
         FilledTonalButton(onClick = onAction) {
-            Text(stringResource(copy.action))
+            Text(stringResource(actionRes))
         }
     }
 }
 
-/** The state's mark: the reason's icon in a tonal circle above the headline. */
-@Composable
-private fun FailureIcon(icon: ImageVector, isError: Boolean) {
-    val container: Color
-    val content: Color
-    if (isError) {
-        container = MaterialTheme.colorScheme.errorContainer
-        content = MaterialTheme.colorScheme.onErrorContainer
-    } else {
-        container = MaterialTheme.colorScheme.secondaryContainer
-        content = MaterialTheme.colorScheme.onSecondaryContainer
-    }
-    Box(
-        modifier = Modifier
-            .size(72.dp)
-            .background(container, CircleShape),
-        contentAlignment = Alignment.Center,
-    ) {
-        Icon(
-            imageVector = icon,
-            contentDescription = null,
-            tint = content,
-            modifier = Modifier.size(36.dp),
-        )
-    }
-}
-
-/**
- * What a reason says and offers. Headline and supporting line are separate so
- * the explanation reads as body text instead of a headline that runs over three
- * lines; [isError] tints the mark for the two reasons that are an actual fault
- * rather than a calendar the user can switch back on.
- */
-private data class FailureCopy(
-    val icon: ImageVector,
-    @StringRes val title: Int,
-    @StringRes val body: Int?,
-    @StringRes val action: Int,
-    val isError: Boolean = false,
-)
-
-private fun failureCopy(reason: FailureReason): FailureCopy = when (reason) {
-    FailureReason.PermissionRevoked -> FailureCopy(
-        icon = Icons.Outlined.Lock,
-        title = R.string.state_failure_permission,
-        body = R.string.state_failure_permission_body,
-        action = R.string.state_failure_permission_action,
-    )
-    FailureReason.NoCalendarsConfigured -> FailureCopy(
-        icon = Icons.Outlined.CalendarMonth,
-        title = R.string.state_failure_no_calendars,
-        body = R.string.state_failure_no_calendars_body,
-        action = R.string.state_failure_no_calendars_action,
-    )
-    FailureReason.AllCalendarsHidden -> FailureCopy(
-        icon = Icons.Outlined.VisibilityOff,
-        title = R.string.state_failure_all_hidden,
-        body = R.string.state_failure_all_hidden_body,
-        action = R.string.state_failure_all_hidden_action,
-    )
-    FailureReason.NoImportTarget -> FailureCopy(
-        icon = Icons.Outlined.EditOff,
-        title = R.string.state_failure_no_import_target,
-        body = R.string.state_failure_no_import_target_body,
-        action = R.string.state_failure_all_hidden_action,
-    )
-    FailureReason.EventNotFound -> FailureCopy(
-        icon = Icons.Outlined.EventBusy,
-        title = R.string.state_failure_event_not_found,
-        body = R.string.state_failure_event_not_found_body,
-        action = R.string.state_retry,
-    )
-    FailureReason.ProviderUnavailable -> FailureCopy(
-        icon = Icons.Outlined.SyncProblem,
-        title = R.string.state_failure_provider,
-        body = R.string.state_failure_provider_body,
-        action = R.string.state_retry,
-        isError = true,
-    )
-    FailureReason.Unknown -> FailureCopy(
-        icon = Icons.Outlined.ErrorOutline,
-        title = R.string.state_failure_unknown,
-        body = null,
-        action = R.string.state_retry,
-        isError = true,
-    )
-}
-
-/** Keeps the headline and its supporting line at a readable measure. */
-private val TEXT_MAX_WIDTH = 320.dp
-
 /**
  * Opens Settings → Calendars, the only screen that can switch a calendar back
  * on. Null outside the calendar host — screens without it never raise the

app/src/main/java/de/jeanlucmakiola/calendula/ui/detail/EventDetailScreen.kt

@@ -302,7 +302,6 @@ fun EventDetailScreen(
             is EventDetailUiState.Failure -> CalendarFailure(
                 reason = s.reason,
                 onRetry = viewModel::retry,
-                modifier = contentModifier,
             )
             is EventDetailUiState.Success -> EventDetailContent(s, copyField, contentModifier)
         }

app/src/main/res/values/strings.xml

@@ -11,20 +11,12 @@
     <string name="state_retry">Retry</string>
     <string name="state_failure_unknown">Something went wrong.</string>
     <string name="state_failure_permission">Calendar access is required.</string>
-    <string name="state_failure_permission_body">Calendula reads your events straight from the system calendar, so it needs calendar access to show anything.</string>
     <string name="state_failure_permission_action">Grant access</string>
     <string name="state_failure_no_calendars">No calendars configured.</string>
-    <string name="state_failure_no_calendars_body">Add a calendar account to this device and its calendars show up here.</string>
     <string name="state_failure_no_calendars_action">Open system calendar settings</string>
     <string name="state_failure_all_hidden">All your calendars are switched off.</string>
-    <string name="state_failure_all_hidden_body">Switch at least one calendar back on to see its events.</string>
     <string name="state_failure_all_hidden_action">Manage calendars</string>
-    <string name="state_failure_no_import_target">No calendar can take new events.</string>
-    <string name="state_failure_no_import_target_body">The calendars that are switched on are read-only, managed by another app, or not synced to this device. Switch on a calendar that can take events, or add a local one.</string>
-    <string name="state_failure_event_not_found">This event is no longer there.</string>
-    <string name="state_failure_event_not_found_body">It may have been deleted, or moved to a calendar that is switched off.</string>
     <string name="state_failure_provider">Could not read the calendar.</string>
-    <string name="state_failure_provider_body">The system calendar did not answer. Try again in a moment.</string>
 
     <!-- Long-press a field to copy it (#195) -->
     <string name="field_copy_action">Copy</string>
@@ -687,7 +679,6 @@
     <string name="calendars_restore_header">Restore</string>
     <string name="calendars_restore_action">Restore from .ics file</string>
     <string name="calendars_restore_hint">Import events from a backup or another calendar app.</string>
-    <string name="calendars_restore_unavailable">No calendar can take the imported events yet.</string>
     <string name="calendars_auto_backup">Automatic backup</string>
     <string name="calendars_auto_backup_hint">Periodically export your local calendars to a folder as an .ics file.</string>
     <string name="calendars_auto_backup_folder">Backup folder</string>

app/src/test/java/de/jeanlucmakiola/calendula/domain/ModelsTest.kt

@@ -36,13 +36,12 @@ class ModelsTest {
     }
 
     @Test
-    fun `FailureReason enum has all seven variants`() {
+    fun `FailureReason enum has all six variants`() {
         assertThat(FailureReason.values().toSet()).isEqualTo(
             setOf(
                 FailureReason.PermissionRevoked,
                 FailureReason.NoCalendarsConfigured,
                 FailureReason.AllCalendarsHidden,
-                FailureReason.NoImportTarget,
                 FailureReason.ProviderUnavailable,
                 FailureReason.EventNotFound,
                 FailureReason.Unknown,

app/src/test/java/de/jeanlucmakiola/calendula/domain/ics/IcsGoogleImportTest.kt

@@ -1,116 +0,0 @@
-package de.jeanlucmakiola.calendula.domain.ics
-
-import com.google.common.truth.Truth.assertThat
-import de.jeanlucmakiola.calendula.domain.Availability
-import kotlinx.datetime.TimeZone
-import org.junit.jupiter.api.Test
-
-/**
- * Reading a Google Calendar export (Codeberg #304), whose dialect the parser had
- * never been held to: `VTIMEZONE` blocks with `X-LIC-LOCATION`, `TZID`-qualified
- * `DTSTART`/`EXDATE`, folded `DESCRIPTION` and `ATTENDEE` lines, `RECURRENCE-ID`
- * overrides written as separate `VEVENT`s, and `@google.com` UIDs.
- *
- * The fixture is a trimmed copy of what "Settings → Import & export → Export"
- * produces, CRLF and all. Note that Google hands that export out as a **zip**
- * containing one `.ics` per calendar — the file here is one member of it.
- */
-class IcsGoogleImportTest {
-
-    private val parser = IcsParser(TimeZone.of("Europe/Berlin"))
-
-    private val result: IcsParseResult = parser.parse(
-        checkNotNull(
-            javaClass.classLoader?.getResourceAsStream("ics/google-calendar-export.ics"),
-        ).use { it.readBytes().toString(Charsets.UTF_8) },
-    )
-
-    private fun event(summary: String) = result.events.single { it.summary == summary }
-
-    @Test
-    fun `every master event imports and the VTIMEZONE block is not mistaken for one`() {
-        assertThat(result.events.map { it.summary })
-            .containsExactly("Team standup", "Day off", "Christmas break")
-    }
-
-    @Test
-    fun `X-WR-CALNAME names the calendar for all of them`() {
-        assertThat(result.events.map { it.calendarName }.distinct())
-            .containsExactly("jane@example.com")
-    }
-
-    @Test
-    fun `a TZID-qualified start resolves against the device tz database`() {
-        val standup = event("Team standup")
-        assertThat(standup.isAllDay).isFalse()
-        assertThat(standup.zoneId).isEqualTo("Europe/Berlin")
-        // 10:00 CEST is 08:00 UTC.
-        assertThat(standup.start.toString()).isEqualTo("2026-09-15T08:00:00Z")
-        assertThat((standup.end - standup.start).inWholeMinutes).isEqualTo(90)
-    }
-
-    @Test
-    fun `the recurrence rule and its TZID-qualified EXDATE survive`() {
-        val standup = event("Team standup")
-        assertThat(standup.recurrenceRule).isEqualTo("FREQ=WEEKLY;BYDAY=TU")
-        assertThat(standup.exDates).containsExactly("20260929T080000Z")
-    }
-
-    @Test
-    fun `the moved occurrence is skipped rather than imported as a duplicate`() {
-        // Google writes a RECURRENCE-ID override as its own VEVENT carrying the
-        // master's UID. Importing it would put a second "standup" in the
-        // calendar; Calendula models no overrides, so it is reported instead.
-        assertThat(result.events.map { it.summary }).doesNotContain("Team standup (moved)")
-        assertThat(result.warnings).contains(IcsParseWarning.ModifiedOccurrenceSkipped)
-    }
-
-    @Test
-    fun `a folded DESCRIPTION is unfolded and unescaped`() {
-        assertThat(event("Team standup").description).isEqualTo(
-            "Weekly sync with the team.\nAgenda lives in the shared doc, see the link below.",
-        )
-    }
-
-    @Test
-    fun `an escaped comma in LOCATION comes back as a comma`() {
-        assertThat(event("Team standup").location).isEqualTo("Meeting room 2, 3rd floor")
-    }
-
-    @Test
-    fun `attendees are reported rather than silently dropped`() {
-        assertThat(result.warnings).contains(IcsParseWarning.AttendeesIgnored)
-    }
-
-    @Test
-    fun `a timed VALARM becomes its lead time in minutes`() {
-        assertThat(event("Team standup").semanticReminderMinutes()).containsExactly(30)
-    }
-
-    @Test
-    fun `an all-day event keeps the single day the file gives it`() {
-        val dayOff = event("Day off")
-        assertThat(dayOff.isAllDay).isTrue()
-        assertThat((dayOff.end - dayOff.start).inWholeDays).isEqualTo(1)
-        assertThat(dayOff.availability).isEqualTo(Availability.Free)
-    }
-
-    @Test
-    fun `an all-day alarm comes back as whole days before`() {
-        // Google writes an all-day reminder as a whole-day offset from the
-        // event's UTC midnight; a day has to survive as a day.
-        assertThat(event("Day off").semanticReminderMinutes()).containsExactly(1440)
-    }
-
-    @Test
-    fun `a multi-day all-day event keeps its exclusive DTEND span`() {
-        val christmas = event("Christmas break")
-        assertThat(christmas.isAllDay).isTrue()
-        assertThat((christmas.end - christmas.start).inWholeDays).isEqualTo(3)
-    }
-
-    @Test
-    fun `no recurrence rule is repaired - Google writes them well-formed`() {
-        assertThat(result.warnings).doesNotContain(IcsParseWarning.RecurrenceRuleRepaired)
-    }
-}

app/src/test/java/de/jeanlucmakiola/calendula/ui/calendars/BackupUiStateTest.kt

@@ -1,90 +0,0 @@
-package de.jeanlucmakiola.calendula.ui.calendars
-
-import com.google.common.truth.Truth.assertThat
-import de.jeanlucmakiola.calendula.domain.CalendarSource
-import de.jeanlucmakiola.calendula.domain.FailureReason
-import org.junit.jupiter.api.Test
-
-/** What the Backup & restore screen offers for a given calendar list (#304). */
-class BackupUiStateTest {
-
-    private fun cal(
-        id: Long,
-        local: Boolean = false,
-        writable: Boolean = true,
-        visible: Boolean = true,
-        managed: Boolean = false,
-        syncs: Boolean = true,
-    ) = CalendarSource(
-        id = id,
-        displayName = "Calendar $id",
-        accountName = "acc@example.com",
-        accountType = if (local) "LOCAL" else "com.google",
-        color = 0,
-        isVisibleInSystem = visible,
-        canModifyContents = writable,
-        isLocal = local,
-        isManaged = managed,
-        syncsEvents = syncs,
-    )
-
-    private fun failure(state: BackupUiState) = (state as BackupUiState.Failure).reason
-
-    private fun ready(state: BackupUiState) = state as BackupUiState.Ready
-
-    @Test
-    fun `no calendars at all reports the empty device`() {
-        assertThat(failure(backupUiState(emptyList())))
-            .isEqualTo(FailureReason.NoCalendarsConfigured)
-    }
-
-    @Test
-    fun `a synced writable calendar can receive a restore`() {
-        val state = ready(backupUiState(listOf(cal(1L))))
-        assertThat(state.canImport).isTrue()
-        assertThat(state.exportable).isEmpty()
-    }
-
-    @Test
-    fun `the reported case - only a calendar that cannot take events`() {
-        // #304: a Google account with calendar sync switched off leaves nothing
-        // exportable and nothing importable, which used to render a blank screen.
-        assertThat(failure(backupUiState(listOf(cal(1L, syncs = false)))))
-            .isEqualTo(FailureReason.NoImportTarget)
-    }
-
-    @Test
-    fun `a read-only subscription is no import target either`() {
-        assertThat(failure(backupUiState(listOf(cal(1L, writable = false)))))
-            .isEqualTo(FailureReason.NoImportTarget)
-    }
-
-    @Test
-    fun `everything switched off is reported as hidden, not as a missing target`() {
-        // The remedy differs: a visibility switch fixes this one.
-        assertThat(failure(backupUiState(listOf(cal(1L, visible = false)))))
-            .isEqualTo(FailureReason.AllCalendarsHidden)
-    }
-
-    @Test
-    fun `a hidden local calendar still exports`() {
-        // Export reads the provider directly, so system visibility is irrelevant
-        // to it — calling this a failure would hide a working action.
-        val state = ready(backupUiState(listOf(cal(1L, local = true, visible = false))))
-        assertThat(state.exportable).hasSize(1)
-        assertThat(state.canImport).isFalse()
-    }
-
-    @Test
-    fun `a managed special-dates mirror is neither exportable nor a target`() {
-        assertThat(failure(backupUiState(listOf(cal(1L, local = true, managed = true)))))
-            .isEqualTo(FailureReason.NoImportTarget)
-    }
-
-    @Test
-    fun `a local calendar alongside a synced one offers both halves`() {
-        val state = ready(backupUiState(listOf(cal(1L, local = true), cal(2L))))
-        assertThat(state.exportable.map { it.id }).containsExactly(1L)
-        assertThat(state.canImport).isTrue()
-    }
-}

app/src/test/resources/ics/google-calendar-export.ics

@@ -1,91 +0,0 @@
-BEGIN:VCALENDAR
-PRODID:-//Google Inc//Google Calendar 70.9054//EN
-VERSION:2.0
-CALSCALE:GREGORIAN
-METHOD:PUBLISH
-X-WR-CALNAME:jane@example.com
-X-WR-TIMEZONE:Europe/Berlin
-BEGIN:VTIMEZONE
-TZID:Europe/Berlin
-X-LIC-LOCATION:Europe/Berlin
-BEGIN:DAYLIGHT
-TZOFFSETFROM:+0100
-TZOFFSETTO:+0200
-TZNAME:CEST
-DTSTART:19700329T020000
-RRULE:FREQ=YEARLY;BYMONTH=3;BYDAY=-1SU
-END:DAYLIGHT
-BEGIN:STANDARD
-TZOFFSETFROM:+0200
-TZOFFSETTO:+0100
-TZNAME:CET
-DTSTART:19701025T030000
-RRULE:FREQ=YEARLY;BYMONTH=10;BYDAY=-1SU
-END:STANDARD
-END:VTIMEZONE
-BEGIN:VEVENT
-DTSTART;TZID=Europe/Berlin:20260915T100000
-DTEND;TZID=Europe/Berlin:20260915T113000
-RRULE:FREQ=WEEKLY;BYDAY=TU
-EXDATE;TZID=Europe/Berlin:20260929T100000
-DTSTAMP:20260912T183000Z
-UID:0abcdef1234567890abcdef12345@google.com
-CREATED:20260901T120000Z
-DESCRIPTION:Weekly sync with the team.\nAgenda lives in the shared doc\, see
-  the link below.
-LAST-MODIFIED:20260902T081500Z
-LOCATION:Meeting room 2\, 3rd floor
-SEQUENCE:0
-STATUS:CONFIRMED
-SUMMARY:Team standup
-TRANSP:OPAQUE
-ORGANIZER;CN=Jane Doe:mailto:jane@example.com
-ATTENDEE;CUTYPE=INDIVIDUAL;ROLE=REQ-PARTICIPANT;PARTSTAT=ACCEPTED;CN=John:m
- ailto:john@example.com
-BEGIN:VALARM
-ACTION:DISPLAY
-DESCRIPTION:This is an event reminder
-TRIGGER:-PT30M
-END:VALARM
-END:VEVENT
-BEGIN:VEVENT
-DTSTART;TZID=Europe/Berlin:20260929T140000
-DTEND;TZID=Europe/Berlin:20260929T153000
-DTSTAMP:20260912T183000Z
-UID:0abcdef1234567890abcdef12345@google.com
-RECURRENCE-ID;TZID=Europe/Berlin:20260929T100000
-CREATED:20260901T120000Z
-LAST-MODIFIED:20260910T091500Z
-SEQUENCE:1
-STATUS:CONFIRMED
-SUMMARY:Team standup (moved)
-TRANSP:OPAQUE
-END:VEVENT
-BEGIN:VEVENT
-DTSTART;VALUE=DATE:20261024
-DTEND;VALUE=DATE:20261025
-DTSTAMP:20260912T183000Z
-UID:1bcdef01234567890abcdef23456@google.com
-CREATED:20260820T101500Z
-LAST-MODIFIED:20260820T101500Z
-SEQUENCE:0
-STATUS:CONFIRMED
-SUMMARY:Day off
-TRANSP:TRANSPARENT
-BEGIN:VALARM
-ACTION:DISPLAY
-DESCRIPTION:This is an event reminder
-TRIGGER:-P1D
-END:VALARM
-END:VEVENT
-BEGIN:VEVENT
-DTSTART;VALUE=DATE:20261224
-DTEND;VALUE=DATE:20261227
-DTSTAMP:20260912T183000Z
-UID:2cdef012345678901abcdef34567@google.com
-SEQUENCE:0
-STATUS:CONFIRMED
-SUMMARY:Christmas break
-TRANSP:TRANSPARENT
-END:VEVENT
-END:VCALENDAR

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.5.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.7.1-bin.zip
 distributionSha256Sum=bafc141b619ad6350fd975fc903156dd5c151998cc8b058e8c1044ab5f7b031f
 networkTimeout=10000
 validateDistributionUrl=true