From b28fcdc774810fbdbaef283aaba253a047d4010c Mon Sep 17 00:00:00 2001 From: venture Date: Fri, 25 Sep 2026 19:56:21 +0200 Subject: [PATCH] =?UTF-8?q?V2-5=20:=20r=C3=A9tention=20auto=20(r=C3=A8gle,?= =?UTF-8?q?=20worker=20quotidien,=20r=C3=A9glages=20stockage)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- AGENTS.md | 6 +- CHANGELOG.md | 1 + .../kazier/mobile/data/local/dao/FileDao.kt | 25 ++++ .../java/com/kazier/mobile/domain/PrefKeys.kt | 2 + .../com/kazier/mobile/domain/RetentionRule.kt | 33 +++++ .../kazier/mobile/domain/RetentionStore.kt | 43 ++++++ .../mobile/features/sync/RetentionWorker.kt | 72 ++++++++++ .../mobile/features/sync/SyncViewModel.kt | 2 + .../mobile/ui/settings/SettingsScreen.kt | 134 +++++++++++++++++ .../mobile/ui/settings/SettingsViewModel.kt | 75 ++++++++++ .../app/src/main/res/values-en/strings.xml | 11 ++ .../app/src/main/res/values/strings.xml | 11 ++ .../com/kazier/mobile/domain/RetentionTest.kt | 135 ++++++++++++++++++ 13 files changed, 547 insertions(+), 3 deletions(-) create mode 100644 mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/RetentionRule.kt create mode 100644 mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/RetentionStore.kt create mode 100644 mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/RetentionWorker.kt create mode 100644 mobile-kotlin/app/src/test/java/com/kazier/mobile/domain/RetentionTest.kt diff --git a/AGENTS.md b/AGENTS.md index 7341315..7054981 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -58,11 +58,11 @@ Tests mobiles : JVM unit tests dans `app/src/test` (JUnit + Robolectric + Room i - `features/` — logique descendue côté client : - `sync/DeviceSync.kt` + `SafScanner.kt` — sync device↔SAF : **two-pass walk** (listing hors transaction puis upserts Room dans une seule transaction), réconciliation `exists = 0` (jamais de suppression), single-flight via `Mutex` ; les nouveaux **dossiers** sont journalisés dans l'outbox à la découverte, les **fichiers** uniquement au « garder » de la review (gate `processed`) - `saf/` — `SafUris`, `SafFolderCreator`, `FileMover` (relocalisation SAF `DocumentsContract.moveDocument`, repli métadonnée seule ; le déplacement est poussé en `move_resource`), `SafFileDeleter` (suppression SAF + `delete_resource` atomique), `FileDeleter.releaseLocalCopies` (purge sûre V2-3 : gate `isReleasable`, détachement cloud-only, zéro outbox) - - `sync/OutboxSyncWorker.kt` — worker WorkManager (`enqueueUniqueWork` KEEP, single-flight, `NetworkType.CONNECTED`, backoff 30s) qui draine `pending_operations` vers `POST /sync/ops` (batch 20, dead-letter immédiat `failed` sur erreur 4xx non-idempotente — `attempts` diagnostic, purge synced > 7 jours, **sauf `report_bytes` : dead-letter + suite du batch, jamais bloquant**) ; **schedulé** au login/restauration de session (`AuthViewModel`) et après chaque `syncAll()` (`SyncViewModel`) ; enchaîne `OcrAutoWorker` + `BytesUploadWorker` quand un fichier est promu (`DownloadWorker` sur demande hors-ligne) + - `sync/OutboxSyncWorker.kt` — worker WorkManager (`enqueueUniqueWork` KEEP, single-flight, `NetworkType.CONNECTED`, backoff 30s) qui draine `pending_operations` vers `POST /sync/ops` (batch 20, dead-letter immédiat `failed` sur erreur 4xx non-idempotente — `attempts` diagnostic, purge synced > 7 jours, **sauf `report_bytes` : dead-letter + suite du batch, jamais bloquant**) ; **schedulé** au login/restauration de session (`AuthViewModel`) et après chaque `syncAll()` (`SyncViewModel`) ; enchaîne `OcrAutoWorker` + `BytesUploadWorker` quand un fichier est promu (`DownloadWorker` sur demande hors-ligne) ; `RetentionWorker` (passe quotidienne, purge sûre des copies anciennes selon `RetentionStore`, sans réseau) - `sync/SyncViewModel.kt` — état du sync exposé à l'UI (`SyncStatus` : marche en cours, ops en attente, dernières opérations) via le badge header `ui/components/SyncStatusBadge.kt` + `SyncOperationsDialog.kt` (« liste des sync ») - `auth/` — session (login user + token paseto + **re-login silencieux** sur 401 via identifiants chiffrés persistés, single-flight, événements `Reauthenticated`/`SessionExpired`) : `SessionManager`, `SecureTokenStore`, `TokenProvider`, `TokenStore` (+ `Credentials`) -- `ui/` — écrans Compose : `folderlist`, `folderdetail`, `document` (contenu PDF/image/texte local + streaming distant image/texte/PDF multi-pages via `RemoteDocumentViewer`, autres types non supportés en streaming), `search` (**recherche locale** via Room, sans endpoint serveur), `settings` (URL serveur + thème), `pdfbuilder` (multi-select → génération PDF), `auth` (login, mode local, avis d'expiration), `share` (`ShareBottomSheet` : grants + liens + ouverture de lien + copies V2 ; `OpenLinkScreen` + deep-link `kazier://share/`), `components`, `theme` -- `domain/` — stores de préférences: `DeviceIdentity`, `ActiveUserStore`, `LocalModeStore`, `ServerConfigStore`, `ThemePreferenceStore`, `GenerateId` (identifiants 32-hex) +- `ui/` — écrans Compose : `folderlist`, `folderdetail`, `document` (contenu PDF/image/texte local + streaming distant image/texte/PDF multi-pages via `RemoteDocumentViewer`, autres types non supportés en streaming), `search` (**recherche locale** via Room, sans endpoint serveur), `settings` (URL serveur + thème + stockage/retention), `pdfbuilder` (multi-select → génération PDF), `auth` (login, mode local, avis d'expiration), `share` (`ShareBottomSheet` : grants + liens + ouverture de lien + copies V2 ; `OpenLinkScreen` + deep-link `kazier://share/`), `components`, `theme` +- `domain/` — stores de préférences: `DeviceIdentity`, `ActiveUserStore`, `LocalModeStore`, `ServerConfigStore`, `ThemePreferenceStore`, `RetentionStore` (`all` | `last_months:N`), `GenerateId` (identifiants 32-hex) - `di/` — modules Hilt (`AppModule`, `DatabaseModule`, `NetworkModule`) - Base URL serveur **configurée à l'exécution** dans les Réglages (`ServerConfigStore`, persistée en `user_preferences`), défaut `http://10.0.2.2:8080/api/v1` (pas de variable d'env) - Client **local-first** : lecture via `GET /files/folders`, `GET /files` (+ streaming distant `GET /files/:id/content` pour les fichiers cloud-only, jamais persisté) ; mutations locales poussées via l'outbox `POST /sync/ops` (`create_resource`/`move_resource`/`delete_resource` + ops partage) ; `POST /devices`, `POST /auth/login` ; upload physique limité au pipeline OCR (`POST /files/upload` + `resourceId` ciblé) diff --git a/CHANGELOG.md b/CHANGELOG.md index 234aca1..e79dab4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,7 @@ Le format suit [Keep a Changelog](https://keepachangelog.com/fr/1.1.0/) et le ve - Download V2 hors-ligne : `DownloadWorker` (fichier par fichier, écriture SAF dossier propre sinon racine, rattachement même `resource_id`, walk convergent par URI), marqueurs `has_content_server`/`wanted_offline` (Room v18, migration 17→18), bouton « Rendre disponible hors-ligne » dans le viewer distant. - Purge sûre V2-3 « libérer de l'espace » : gate `isReleasable` (copie serveur connue), détachement cloud-only sans op outbox, bouton viewer + action multi-sélection. - Placements multi-device : tables `storage_locations` + `resource_placements` (migration `000015`), op outbox `report_bytes` (viewer+, nouvel `operation_id` par état, dead-letter sans bloquer la file), `GET /files/:id/placements` (owner-only), reporting auto (upload/download/release/delete locale), section copies dans le sheet de partage. +- Rétention auto : règle `all` | `last_months:N` (`RetentionStore`), passe quotidienne `RetentionWorker` (purge sûre, sans réseau), réglages stockage (stats récupérables + libération manuelle). ### Corrigé - 401 sans session (mode local / jamais connecté) : ignoré sans purge ni événement — un appel égaré n'éjecte plus vers le login. diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FileDao.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FileDao.kt index 5b5b2af..1245795 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FileDao.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/data/local/dao/FileDao.kt @@ -307,4 +307,29 @@ interface FileDao { WHERE resource_id = :resourceId """) suspend fun detachLocalCopy(resourceId: String, now: Long) + + /** + * Candidats rétention V2-5 : copies locales purgeables + * (`isReleasable` en SQL) plus anciennes que `cutoffMs` + * (`COALESCE(last_modified, added_at)`), les plus anciennes d'abord. + */ + @Query(""" + SELECT * FROM files + WHERE "exists" = 1 + AND uri IS NOT NULL + AND (has_content_server = 1 OR bytes_uploaded = 1) + AND COALESCE(last_modified, added_at) < :cutoffMs + ORDER BY COALESCE(last_modified, added_at) ASC + """) + suspend fun releasableOlderThan(cutoffMs: Long): List + + /** Octets récupérables par la rétention (stats UI, même filtre). */ + @Query(""" + SELECT COALESCE(SUM(size), 0) FROM files + WHERE "exists" = 1 + AND uri IS NOT NULL + AND (has_content_server = 1 OR bytes_uploaded = 1) + AND COALESCE(last_modified, added_at) < :cutoffMs + """) + suspend fun sumReleasableBytes(cutoffMs: Long): Long } \ No newline at end of file diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/PrefKeys.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/PrefKeys.kt index 343db8f..4a875d4 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/PrefKeys.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/PrefKeys.kt @@ -10,4 +10,6 @@ object PrefKeys { const val SERVER_URL = "server_url" /** Dernier pull `GET /sync/permissions` réussi, ms epoch (M27 : delta + TTL 24h). */ const val PERMISSIONS_CACHED_AT = "permissions_cached_at" + /** Règle de rétention locale V2-5 : `all` | `last_months:N`. */ + const val RETENTION_RULE = "retention_rule" } \ No newline at end of file diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/RetentionRule.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/RetentionRule.kt new file mode 100644 index 0000000..06baa12 --- /dev/null +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/RetentionRule.kt @@ -0,0 +1,33 @@ +package com.kazier.mobile.domain + +/** + * Règle de rétention locale V2-5 (libération auto d'espace) — syntaxe + * `retention_rule` du modèle V2 (`V2.md` §3.6), sous-ensemble implémenté : + * tout garder, ou N derniers mois. Appliquée par `RetentionWorker` + * (purge sûre : seuls les fichiers dont le serveur a les octets partent). + */ +sealed interface RetentionRule { + data object KeepAll : RetentionRule + data class LastMonths(val months: Int) : RetentionRule + + /** Forme stockée (`user_preferences`) : `all` | `last_months:N`. */ + val stored: String + get() = when (this) { + is KeepAll -> "all" + is LastMonths -> "last_months:$months" + } + + companion object { + val OPTIONS = listOf(KeepAll, LastMonths(3), LastMonths(6), LastMonths(12)) + + fun parse(stored: String?): RetentionRule { + if (stored == null) return KeepAll + if (stored == "all") return KeepAll + val months = stored.removePrefix("last_months:").toIntOrNull() + if (stored.startsWith("last_months:") && months != null && months > 0) { + return LastMonths(months) + } + return KeepAll + } + } +} diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/RetentionStore.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/RetentionStore.kt new file mode 100644 index 0000000..43647f3 --- /dev/null +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/domain/RetentionStore.kt @@ -0,0 +1,43 @@ +package com.kazier.mobile.domain + +import com.kazier.mobile.data.local.dao.UserPreferenceDao +import com.kazier.mobile.data.local.entity.UserPreferenceEntity +import java.util.concurrent.atomic.AtomicBoolean +import javax.inject.Inject +import javax.inject.Singleton +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow + +/** + * Règle de rétention locale (V2-5) : `all` par défaut, chargée une fois + * depuis `user_preferences` puis exposée en [StateFlow] (même discipline + * que [ThemePreferenceStore]). + */ +@Singleton +class RetentionStore @Inject constructor( + private val userPreferenceDao: UserPreferenceDao, +) { + + private val loaded = AtomicBoolean(false) + + private val _rule = MutableStateFlow(RetentionRule.KeepAll) + val rule: StateFlow = _rule.asStateFlow() + + /** Charge la valeur persistée au boot (idempotent). */ + suspend fun load() { + if (!loaded.compareAndSet(false, true)) return + _rule.value = RetentionRule.parse(userPreferenceDao.getValue(PrefKeys.RETENTION_RULE)) + } + + /** Lecture directe (workers hors UI, sans passer par le flow). */ + suspend fun current(): RetentionRule = + RetentionRule.parse(userPreferenceDao.getValue(PrefKeys.RETENTION_RULE)) + + suspend fun set(rule: RetentionRule) { + userPreferenceDao.upsert( + UserPreferenceEntity(PrefKeys.RETENTION_RULE, rule.stored, System.currentTimeMillis()), + ) + _rule.value = rule + } +} diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/RetentionWorker.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/RetentionWorker.kt new file mode 100644 index 0000000..bf97f4d --- /dev/null +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/RetentionWorker.kt @@ -0,0 +1,72 @@ +package com.kazier.mobile.features.sync + +import android.content.Context +import androidx.hilt.work.HiltWorker +import androidx.work.BackoffPolicy +import androidx.work.Constraints +import androidx.work.CoroutineWorker +import androidx.work.ExistingPeriodicWorkPolicy +import androidx.work.NetworkType +import androidx.work.PeriodicWorkRequestBuilder +import androidx.work.WorkManager +import androidx.work.WorkerParameters +import com.kazier.mobile.data.local.dao.FileDao +import com.kazier.mobile.domain.RetentionRule +import com.kazier.mobile.domain.RetentionStore +import com.kazier.mobile.features.saf.FileDeleter +import dagger.assisted.Assisted +import dagger.assisted.AssistedInject +import java.util.concurrent.TimeUnit +import timber.log.Timber + +/** + * Rétention auto V2-5 (1×/jour) : purge sûre des copies locales plus + * anciennes que la règle ([RetentionStore]) via [FileDeleter.releaseLocalCopies] + * (gate `isReleasable` : seuls les fichiers dont le serveur a les octets + * partent — jamais de perte). Opération purement locale : aucune contrainte + * réseau, batterie faible exclue. + */ +@HiltWorker +class RetentionWorker @AssistedInject constructor( + @Assisted appContext: Context, + @Assisted workerParams: WorkerParameters, + private val retentionStore: RetentionStore, + private val fileDeleter: FileDeleter, + private val fileDao: FileDao, +) : CoroutineWorker(appContext, workerParams) { + + override suspend fun doWork(): Result { + val rule = retentionStore.current() + if (rule is RetentionRule.KeepAll) return Result.success() + val months = (rule as RetentionRule.LastMonths).months + val cutoff = System.currentTimeMillis() - months * MONTH_MS + val candidates = fileDao.releasableOlderThan(cutoff) + if (candidates.isEmpty()) return Result.success() + val report = fileDeleter.releaseLocalCopies(candidates) + Timber.d( + "retention: released=%d skipped=%d failed=%d (rule=%s)", + report.released, report.skipped, report.failed, rule.stored, + ) + return Result.success() + } + + companion object { + const val NAME = "retention_daily" + private const val MONTH_MS = 30L * 24 * 60 * 60 * 1000 + + fun cutoffMs(nowMs: Long, months: Int): Long = nowMs - months * MONTH_MS + + fun enqueuePeriodic(context: Context) { + val constraints = Constraints.Builder() + .setRequiredNetworkType(NetworkType.NOT_REQUIRED) + .setRequiresBatteryNotLow(true) + .build() + val request = PeriodicWorkRequestBuilder(24, TimeUnit.HOURS) + .setConstraints(constraints) + .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 30, TimeUnit.MINUTES) + .build() + WorkManager.getInstance(context) + .enqueueUniquePeriodicWork(NAME, ExistingPeriodicWorkPolicy.KEEP, request) + } + } +} diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/SyncViewModel.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/SyncViewModel.kt index f967f33..71efb84 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/SyncViewModel.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/features/sync/SyncViewModel.kt @@ -100,6 +100,8 @@ class SyncViewModel @Inject constructor( /** Démarre la boucle une seule fois (idempotent). */ fun ensureStarted() { if (loopJob?.isActive == true) return + // Rétention auto V2-5 : passe quotidienne périodique (KEEP). + RetentionWorker.enqueuePeriodic(appContext) loopJob = viewModelScope.launch { // Premier cycle différé : laisser le boot et le premier écran // répondre avant de lancer un walk potentiellement long. diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/settings/SettingsScreen.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/settings/SettingsScreen.kt index e0061b0..dbedc70 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/settings/SettingsScreen.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/settings/SettingsScreen.kt @@ -15,6 +15,7 @@ import androidx.compose.foundation.rememberScrollState import androidx.compose.foundation.text.KeyboardOptions import androidx.compose.foundation.verticalScroll import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.CloudOff import androidx.compose.material.icons.filled.DarkMode import androidx.compose.material.icons.filled.Dns import androidx.compose.material.icons.filled.Folder @@ -48,6 +49,7 @@ import androidx.compose.ui.unit.dp import androidx.hilt.navigation.compose.hiltViewModel import androidx.lifecycle.compose.collectAsStateWithLifecycle import com.kazier.mobile.R +import com.kazier.mobile.domain.RetentionRule import com.kazier.mobile.domain.ThemePreference import com.kazier.mobile.features.connection.ConnectionStatusViewModel import com.kazier.mobile.features.sync.SyncViewModel @@ -57,6 +59,7 @@ import com.kazier.mobile.ui.auth.LoginForm import com.kazier.mobile.ui.auth.authErrorResFor import com.kazier.mobile.ui.components.HeaderStatusAction import com.kazier.mobile.ui.components.WatchedFoldersBadge +import com.kazier.mobile.ui.components.formatFileSize import com.kazier.mobile.ui.navigation.FloatingNavBar import com.kazier.mobile.ui.navigation.NavTab @@ -74,6 +77,9 @@ fun SettingsScreen( val theme by viewModel.theme.collectAsStateWithLifecycle() val serverUrl by viewModel.serverUrl.collectAsStateWithLifecycle() val testUiState by viewModel.testUiState.collectAsStateWithLifecycle() + val retention by viewModel.retention.collectAsStateWithLifecycle() + val releasableStats by viewModel.releasableStats.collectAsStateWithLifecycle() + val releaseUiState by viewModel.releaseUiState.collectAsStateWithLifecycle() val authState by authViewModel.authState.collectAsStateWithLifecycle() val loginUi by authViewModel.loginUiState.collectAsStateWithLifecycle() @@ -82,6 +88,12 @@ fun SettingsScreen( var showThemeDialog by rememberSaveable { mutableStateOf(false) } var showServerDialog by rememberSaveable { mutableStateOf(false) } var showAuthDialog by rememberSaveable { mutableStateOf(false) } + var showRetentionDialog by rememberSaveable { mutableStateOf(false) } + + // Stats de purge recalculées à l'ouverture du dialogue rétention. + LaunchedEffect(showRetentionDialog) { + if (showRetentionDialog) viewModel.refreshReleasableStats() + } // Login réussi → refermer le dialogue et purger le mot de passe. LaunchedEffect(authState) { @@ -151,6 +163,14 @@ fun SettingsScreen( onClick = { showServerDialog = true }, ) + HorizontalDivider() + SettingsRow( + icon = { Icon(Icons.Filled.CloudOff, contentDescription = null) }, + title = stringResource(R.string.settings_storage), + subtitle = retentionLabel(retention), + onClick = { showRetentionDialog = true }, + ) + HorizontalDivider() val signedIn = authState as? AuthState.SignedIn SettingsRow( @@ -193,6 +213,20 @@ fun SettingsScreen( ) } + if (showRetentionDialog) { + RetentionDialog( + selected = retention, + stats = releasableStats, + release = releaseUiState, + onSelect = viewModel::setRetention, + onReleaseNow = viewModel::releaseNow, + onDismiss = { + showRetentionDialog = false + viewModel.clearReleaseState() + }, + ) + } + if (showAuthDialog) { when (val state = authState) { is AuthState.SignedIn -> { @@ -294,6 +328,106 @@ private fun ThemeDialog( ) } +@Composable +private fun retentionLabel(rule: RetentionRule): String = when (rule) { + is RetentionRule.KeepAll -> stringResource(R.string.retention_all) + is RetentionRule.LastMonths -> when (rule.months) { + 3 -> stringResource(R.string.retention_3_months) + 6 -> stringResource(R.string.retention_6_months) + 12 -> stringResource(R.string.retention_12_months) + else -> stringResource(R.string.retention_n_months, rule.months) + } +} + +/** + * Rétention locale V2-5 : règle (passe quotidienne + libération manuelle), + * stats récupérables pour la règle courante, bouton « libérer maintenant ». + * Seuls les fichiers dont le serveur a les octets partent (gate sûr). + */ +@Composable +private fun RetentionDialog( + selected: RetentionRule, + stats: ReleasableStats?, + release: ReleaseUiState, + onSelect: (RetentionRule) -> Unit, + onReleaseNow: () -> Unit, + onDismiss: () -> Unit, +) { + val options = listOf( + RetentionRule.KeepAll to null, + RetentionRule.LastMonths(3) to null, + RetentionRule.LastMonths(6) to null, + RetentionRule.LastMonths(12) to null, + ) + AlertDialog( + onDismissRequest = onDismiss, + title = { Text(stringResource(R.string.settings_storage)) }, + text = { + Column(verticalArrangement = Arrangement.spacedBy(4.dp)) { + Text( + text = stringResource(R.string.retention_hint), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + options.forEach { (rule, _) -> + Row( + modifier = Modifier + .fillMaxWidth() + .clickable { onSelect(rule) } + .padding(vertical = 4.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + RadioButton( + selected = selected == rule, + onClick = { onSelect(rule) }, + ) + Text( + text = retentionLabel(rule), + modifier = Modifier.padding(start = 8.dp), + ) + } + } + if (selected !is RetentionRule.KeepAll) { + HorizontalDivider(modifier = Modifier.padding(vertical = 4.dp)) + if (stats != null) { + Text( + text = stringResource( + R.string.retention_releasable, + stats.count, + formatFileSize(stats.bytes), + ), + style = MaterialTheme.typography.bodyMedium, + ) + } + release.released?.let { count -> + Text( + text = stringResource(R.string.release_done, count), + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.primary, + ) + } + OutlinedButton( + onClick = onReleaseNow, + enabled = !release.running, + modifier = Modifier.fillMaxWidth(), + ) { + if (release.running) { + CircularProgressIndicator(modifier = Modifier.size(20.dp), strokeWidth = 2.dp) + } else { + Text(stringResource(R.string.retention_release_now)) + } + } + } + } + }, + confirmButton = { + TextButton(onClick = onDismiss) { + Text(stringResource(R.string.settings_close)) + } + }, + ) +} + @Composable private fun ServerDialog( serverUrl: String, diff --git a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/settings/SettingsViewModel.kt b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/settings/SettingsViewModel.kt index bbbde3f..7bf55d1 100644 --- a/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/settings/SettingsViewModel.kt +++ b/mobile-kotlin/app/src/main/java/com/kazier/mobile/ui/settings/SettingsViewModel.kt @@ -2,9 +2,14 @@ package com.kazier.mobile.ui.settings import androidx.lifecycle.ViewModel import androidx.lifecycle.viewModelScope +import com.kazier.mobile.data.local.dao.FileDao +import com.kazier.mobile.domain.RetentionRule +import com.kazier.mobile.domain.RetentionStore import com.kazier.mobile.domain.ServerConfigStore import com.kazier.mobile.domain.ThemePreference import com.kazier.mobile.domain.ThemePreferenceStore +import com.kazier.mobile.features.saf.FileDeleter +import com.kazier.mobile.features.sync.RetentionWorker import dagger.hilt.android.lifecycle.HiltViewModel import javax.inject.Inject import kotlinx.coroutines.Job @@ -19,9 +24,13 @@ import timber.log.Timber class SettingsViewModel @Inject constructor( private val themePreferenceStore: ThemePreferenceStore, private val serverConfigStore: ServerConfigStore, + private val retentionStore: RetentionStore, + private val fileDao: FileDao, + private val fileDeleter: FileDeleter, ) : ViewModel() { val theme: StateFlow = themePreferenceStore.theme + val retention: StateFlow = retentionStore.rule private val _serverUrl = MutableStateFlow(serverConfigStore.current) val serverUrl: StateFlow = _serverUrl.asStateFlow() @@ -40,6 +49,7 @@ class SettingsViewModel @Inject constructor( viewModelScope.launch { themePreferenceStore.load() serverConfigStore.load() + retentionStore.load() if (!dirty) _serverUrl.value = serverConfigStore.current } } @@ -48,6 +58,59 @@ class SettingsViewModel @Inject constructor( viewModelScope.launch { themePreferenceStore.set(theme) } } + /** Change la règle de rétention (appliquée à la prochaine passe + manuelle). */ + fun setRetention(rule: RetentionRule) { + viewModelScope.launch { + retentionStore.set(rule) + refreshReleasableStats() + } + } + + private val _releasableStats = MutableStateFlow(null) + val releasableStats: StateFlow = _releasableStats.asStateFlow() + + private val _releaseUiState = MutableStateFlow(ReleaseUiState()) + val releaseUiState: StateFlow = _releaseUiState.asStateFlow() + + /** Recompte les octets récupérables pour la règle courante. */ + fun refreshReleasableStats() { + viewModelScope.launch { + val rule = retentionStore.rule.value + if (rule is RetentionRule.KeepAll) { + _releasableStats.value = null + return@launch + } + val months = (rule as RetentionRule.LastMonths).months + val cutoff = RetentionWorker.cutoffMs(System.currentTimeMillis(), months) + val candidates = fileDao.releasableOlderThan(cutoff) + _releasableStats.value = ReleasableStats( + count = candidates.size, + bytes = candidates.sumOf { it.size }, + ) + } + } + + /** Libération immédiate selon la règle courante (même gate que le worker). */ + fun releaseNow() { + viewModelScope.launch { + _releaseUiState.value = ReleaseUiState(running = true) + val rule = retentionStore.rule.value + if (rule is RetentionRule.KeepAll) { + _releaseUiState.value = ReleaseUiState() + return@launch + } + val months = (rule as RetentionRule.LastMonths).months + val cutoff = RetentionWorker.cutoffMs(System.currentTimeMillis(), months) + val report = fileDeleter.releaseLocalCopies(fileDao.releasableOlderThan(cutoff)) + _releaseUiState.value = ReleaseUiState(released = report.released) + refreshReleasableStats() + } + } + + fun clearReleaseState() { + _releaseUiState.value = ReleaseUiState() + } + /** * Affichage = saisie brute immédiate ; persistance debouncée (m36 : une * écriture prefs par frappe = churn IO, une par pause suffit). @@ -89,4 +152,16 @@ data class ServerTestUiState( val success: Boolean? = null, ) +/** Octets récupérables par la règle de rétention courante. */ +data class ReleasableStats( + val count: Int, + val bytes: Long, +) + +data class ReleaseUiState( + val running: Boolean = false, + /** Nombre libéré par la dernière passe manuelle (null = aucune). */ + val released: Int? = null, +) + private const val SAVE_DEBOUNCE_MS = 500L \ No newline at end of file diff --git a/mobile-kotlin/app/src/main/res/values-en/strings.xml b/mobile-kotlin/app/src/main/res/values-en/strings.xml index f641bc2..5e9fde6 100644 --- a/mobile-kotlin/app/src/main/res/values-en/strings.xml +++ b/mobile-kotlin/app/src/main/res/values-en/strings.xml @@ -355,6 +355,17 @@ You do not own this resource. Retry Confirm + + + Local storage + Keep everything on device + Keep last 3 months + Keep last 6 months + Keep last 12 months + Keep last %1$d months + Local copies older than this are auto-deleted (daily) only if the server keeps the bytes — never any loss. + %1$d file(s) — %2$s reclaimable. + Free up now Share this folder Share More actions diff --git a/mobile-kotlin/app/src/main/res/values/strings.xml b/mobile-kotlin/app/src/main/res/values/strings.xml index 41de9c2..b1a1294 100644 --- a/mobile-kotlin/app/src/main/res/values/strings.xml +++ b/mobile-kotlin/app/src/main/res/values/strings.xml @@ -356,6 +356,17 @@ Vous ne possédez pas cette ressource. Réessayer Confirmer + + + Stockage local + Tout garder sur l\'appareil + Garder les 3 derniers mois + Garder les 6 derniers mois + Garder les 12 derniers mois + Garder les %1$d derniers mois + Les copies locales plus anciennes sont supprimées automatiquement (1×/jour) uniquement si le serveur en garde les octets — jamais de perte. + %1$d fichier(s) — %2$s récupérables. + Libérer maintenant Partager ce dossier Partager Plus d\'actions diff --git a/mobile-kotlin/app/src/test/java/com/kazier/mobile/domain/RetentionTest.kt b/mobile-kotlin/app/src/test/java/com/kazier/mobile/domain/RetentionTest.kt new file mode 100644 index 0000000..5fcbef0 --- /dev/null +++ b/mobile-kotlin/app/src/test/java/com/kazier/mobile/domain/RetentionTest.kt @@ -0,0 +1,135 @@ +package com.kazier.mobile.domain + +import android.content.Context +import androidx.room.Room +import androidx.test.core.app.ApplicationProvider +import com.kazier.mobile.data.local.AppDatabase +import com.kazier.mobile.data.local.entity.FileEntity +import com.kazier.mobile.data.local.entity.FileStatus +import com.kazier.mobile.features.sync.RetentionWorker +import kotlinx.coroutines.test.runTest +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +/** + * Rétention auto V2-5 : parsing des règles, persistance, candidats SQL + * (purgeables + anciens) et somme récupérable. + */ +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [34]) +class RetentionTest { + + private lateinit var db: AppDatabase + private lateinit var store: RetentionStore + + @Before + fun setUp() { + val context = ApplicationProvider.getApplicationContext() + db = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java) + .allowMainThreadQueries() + .build() + store = RetentionStore(db.userPreferenceDao()) + } + + @After + fun tearDown() { + db.close() + } + + @Test + fun parse_all_et_mois_et_repli() { + assertEquals(RetentionRule.KeepAll, RetentionRule.parse(null)) + assertEquals(RetentionRule.KeepAll, RetentionRule.parse("all")) + assertEquals(RetentionRule.LastMonths(3), RetentionRule.parse("last_months:3")) + assertEquals(RetentionRule.LastMonths(12), RetentionRule.parse("last_months:12")) + assertEquals(RetentionRule.KeepAll, RetentionRule.parse("last_months:0")) + assertEquals(RetentionRule.KeepAll, RetentionRule.parse("favorites_only")) + assertEquals("last_months:6", RetentionRule.LastMonths(6).stored) + } + + @Test + fun store_persiste_et_relit() = runTest { + store.load() + assertEquals(RetentionRule.KeepAll, store.rule.value) + + store.set(RetentionRule.LastMonths(6)) + assertEquals(RetentionRule.LastMonths(6), store.rule.value) + assertEquals(RetentionRule.LastMonths(6), store.current()) + } + + @Test + fun candidats_purgeables_anciens_seulement() = runTest { + val now = 1_700_000_000_000L + val cutoff = RetentionWorker.cutoffMs(now, 3) + // Vieux + copie serveur → candidat (100 + 200 o). + insertFile("a".repeat(32), date = cutoff - 1, size = 100L, hasContent = true) + insertFile("b".repeat(32), date = cutoff - 1_000, size = 200L, bytesUploaded = 1) + // Récent → gardé. + insertFile("c".repeat(32), date = cutoff + 1_000, size = 300L, hasContent = true) + // Vieux mais sans copie serveur → gardé (gate sûr). + insertFile("d".repeat(32), date = cutoff - 1, size = 400L) + // Vieux + copie serveur mais déjà cloud-only → pas de copie locale. + db.fileDao().upsert( + file("e".repeat(32), date = cutoff - 1, size = 500L, hasContent = true) + .copy(uri = null, syncStatus = FileStatus.CLOUD), + ) + + val candidates = db.fileDao().releasableOlderThan(cutoff) + assertEquals( + listOf("a".repeat(32), "b".repeat(32)), + candidates.map { it.resourceId }.sorted(), + ) + assertEquals(300L, db.fileDao().sumReleasableBytes(cutoff)) + } + + private suspend fun insertFile( + resourceId: String, + date: Long, + size: Long, + hasContent: Boolean = false, + bytesUploaded: Int = 0, + ) { + db.fileDao().upsert(file(resourceId, date, size, hasContent, bytesUploaded)) + } + + private fun file( + resourceId: String, + date: Long, + size: Long, + hasContent: Boolean = false, + bytesUploaded: Int = 0, + ) = FileEntity( + resourceId = resourceId, + uri = "content://x/$resourceId", + name = "doc.txt", + folderResourceId = "f".repeat(32), + size = size, + mimeType = "text/plain", + exists = 1, + lastModified = date, + syncStatus = FileStatus.LOCAL_CLOUD, + processed = true, + hasContentServer = hasContent, + bytesUploaded = bytesUploaded, + addedAt = date, + updatedAt = date, + ) + + @Test + fun cutoff_mois_calendaires_30_jours() { + val now = 1_700_000_000_000L + assertEquals(now - 3 * 30L * 24 * 60 * 60 * 1000, RetentionWorker.cutoffMs(now, 3)) + } + + @Test + fun store_defaut_keep_all() = runTest { + store.load() + assertTrue(store.rule.value is RetentionRule.KeepAll) + } +}