fix 1 to 6

This commit is contained in:
venture
2026-09-22 23:55:49 +02:00
parent c642adb85b
commit d89c0d03c9
90 changed files with 5033 additions and 927 deletions
@@ -24,12 +24,15 @@ class MainActivity : ComponentActivity() {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
lifecycleScope.launch { themePreferenceStore.load() }
setContent {
val theme by themePreferenceStore.theme.collectAsStateWithLifecycle()
KazierTheme(theme = theme) {
KazierApp()
// m37 : le contenu n'est posé qu'une fois le thème persisté chargé —
// avant, le défaut SYSTEM flashait aux premières frames.
lifecycleScope.launch {
themePreferenceStore.load()
setContent {
val theme by themePreferenceStore.theme.collectAsStateWithLifecycle()
KazierTheme(theme = theme) {
KazierApp()
}
}
}
}
@@ -15,16 +15,20 @@ import javax.inject.Singleton
* Persistance chiffrée du token paseto et du profil compte (Keystore + AES).
* Miroir de `services/secureStore.ts` (expo-secure-store). Le token n'est
* JAMAIS écrit en clair dans SQLite.
*
* L'init Keystore/`EncryptedSharedPreferences` est paresseuse (m28) : aucun
* I/O au construct Hilt — le premier accès a lieu sur le thread de l'appelant
* ([SessionManager] bascule sur `Dispatchers.IO`).
*/
@Singleton
class SecureTokenStore @Inject constructor(
@ApplicationContext context: Context,
@ApplicationContext private val context: Context,
moshi: Moshi,
) {
) : TokenStore {
private val userAdapter: JsonAdapter<UserDto> = moshi.adapter(UserDto::class.java)
private val prefs: SharedPreferences = run {
private val prefs: SharedPreferences by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
val masterKeyAlias = MasterKeys.getOrCreate(MasterKeys.AES256_GCM_SPEC)
EncryptedSharedPreferences.create(
FILE_NAME,
@@ -35,29 +39,36 @@ class SecureTokenStore @Inject constructor(
)
}
fun getToken(): String? = prefs.getString(KEY_TOKEN, null)
override fun getToken(): String? = prefs.getString(KEY_TOKEN, null)
fun getUser(): UserDto? {
override fun getUser(): UserDto? {
val raw = prefs.getString(KEY_ACCOUNT, null) ?: return null
return runCatching { userAdapter.fromJson(raw) }
.getOrNull()
?.takeIf { it.id.isNotEmpty() && it.username.isNotEmpty() }
}
fun save(token: String, user: UserDto) {
override fun getExpiresAt(): Long? =
prefs.getLong(KEY_EXPIRES_AT, -1L).takeIf { it >= 0L }
override fun save(token: String, user: UserDto, expiresAt: Long?) {
prefs.edit()
.putString(KEY_TOKEN, token)
.putString(KEY_ACCOUNT, userAdapter.toJson(user))
.apply {
if (expiresAt != null) putLong(KEY_EXPIRES_AT, expiresAt) else remove(KEY_EXPIRES_AT)
}
.apply()
}
fun clear() {
prefs.edit().remove(KEY_TOKEN).remove(KEY_ACCOUNT).apply()
override fun clear() {
prefs.edit().remove(KEY_TOKEN).remove(KEY_ACCOUNT).remove(KEY_EXPIRES_AT).apply()
}
companion object {
private const val FILE_NAME = "kazier_secure"
private const val KEY_TOKEN = "kazier.auth_token"
private const val KEY_ACCOUNT = "kazier.account"
private const val KEY_EXPIRES_AT = "kazier.expires_at"
}
}
@@ -1,48 +1,91 @@
package com.kazier.mobile.auth
import com.kazier.mobile.data.remote.ApiClient
import com.kazier.mobile.data.remote.dto.LoginResponseDto
import com.kazier.mobile.data.remote.dto.UserDto
import com.kazier.mobile.domain.ActiveUserStore
import com.kazier.mobile.domain.DeviceIdentity
import com.kazier.mobile.domain.LocalModeStore
import javax.inject.Inject
import javax.inject.Singleton
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
/**
* Orchestration de la session (restauration/sauvegarde/purge) : relie le store
* sécurisé, le miroir `active_user_id` et le token en mémoire lu par
* `AuthInterceptor`. Le drapeau « mode local » est persisté à part
* ([LocalModeStore]) pour survivre aux redémarrages.
*
* Le callback 401 est possédé ici (singleton, M25) — jamais par un ViewModel :
* après `onCleared`, un token expiré/révoqué continue de purger la session
* (le worker cesse alors de rejouer l'outbox sous un token mort).
*/
@Singleton
class SessionManager @Inject constructor(
private val secureTokenStore: SecureTokenStore,
private val tokenStore: TokenStore,
private val activeUserStore: ActiveUserStore,
private val tokenProvider: TokenProvider,
private val localModeStore: LocalModeStore,
private val apiClient: ApiClient,
) {
private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
init {
// 401 sur un endpoint protégé (token expiré/révoqué, compte supprimé)
// → purge de la session. Le 401 du login et des routes publiques est
// exonéré côté ApiClient (skipUnauthorizedHandling).
apiClient.onUnauthorized = { handleUnauthorized() }
}
/** Restaure la session persistée (si présente), sinon null. */
suspend fun restore(): AuthSession? {
val token = secureTokenStore.getToken() ?: return null
val user = secureTokenStore.getUser() ?: return null
suspend fun restore(): AuthSession? = withContext(Dispatchers.IO) {
val token = tokenStore.getToken() ?: return@withContext null
val user = tokenStore.getUser() ?: return@withContext null
tokenProvider.current = token
return AuthSession(token = token, user = user)
AuthSession(token = token, user = user, expiresAt = tokenStore.getExpiresAt())
}
suspend fun save(token: String, user: com.kazier.mobile.data.remote.dto.UserDto) {
secureTokenStore.save(token, user)
activeUserStore.set(user.id)
localModeStore.clear()
tokenProvider.current = token
}
suspend fun save(token: String, user: UserDto, expiresAt: Long? = null) =
withContext(Dispatchers.IO) {
tokenStore.save(token, user, expiresAt)
activeUserStore.set(user.id)
localModeStore.clear()
tokenProvider.current = token
}
suspend fun clear() {
secureTokenStore.clear()
suspend fun clear() = withContext(Dispatchers.IO) {
tokenStore.clear()
activeUserStore.clear()
tokenProvider.current = null
}
/**
* Purge fire-and-forget sur 401 (appelée depuis le thread OkHttp via
* `ApiClient`) : le token en mémoire tombe synchronement pour ne plus
* émettre de requêtes authentifiées, la persistance suit en IO.
*/
fun handleUnauthorized() {
tokenProvider.current = null
scope.launch {
runCatching { tokenStore.clear() }
runCatching { activeUserStore.clear() }
}
}
/**
* Pré-relogin : vrai si l'`expires_at` persistée du login est atteinte
* (marge anti-course d'1 min par défaut). L'appelant peut alors reloginer
* avant de subir le 401 brutal (tokens 7 j, m27).
*/
suspend fun isTokenExpired(nowMs: Long = System.currentTimeMillis(), marginMs: Long = 60_000L): Boolean =
withContext(Dispatchers.IO) {
val expiresAt = tokenStore.getExpiresAt() ?: return@withContext false
nowMs + marginMs >= expiresAt
}
suspend fun isLocalMode(): Boolean = localModeStore.get()
suspend fun setLocalMode() = localModeStore.set()
@@ -52,5 +95,7 @@ class SessionManager @Inject constructor(
data class AuthSession(
val token: String,
val user: com.kazier.mobile.data.remote.dto.UserDto,
)
val user: UserDto,
/** Expiration persistée du token (ms epoch) — null si inconnue. */
val expiresAt: Long? = null,
)
@@ -0,0 +1,22 @@
package com.kazier.mobile.auth
import com.kazier.mobile.data.remote.dto.UserDto
/**
* Persistance du token paseto, du profil compte et de l'expiration du token
* (claim `expires_at` du login, TTL 7 j). Implémentation : [SecureTokenStore]
* (Keystore + AES, jamais en clair dans SQLite).
*/
interface TokenStore {
fun getToken(): String?
fun getUser(): UserDto?
/** Expiration du token (ms epoch, `expires_at` du login) — null si inconnue. */
fun getExpiresAt(): Long?
fun save(token: String, user: UserDto, expiresAt: Long?)
fun clear()
}
@@ -23,13 +23,17 @@ import com.kazier.mobile.data.local.entity.UserPreferenceEntity
* v10: ocr_text sur files (extrait OCR serveur persisté localement) ;
* v11: ocr_attempts + ocr_queued_at sur files (driver OCR auto côté client —
* compteur d'échecs terminaux ≤ 3, marqueur « en cours » de l'upload).
* v12: device_id sur pending_operations + unicité UNIQUE(device_id,
* operation_id) (contrat outbox docs/api-v1.md §6.1).
* v13: index composites files(exists, processed, sync_status) et
* pending_operations(resource_id, operation, status) (requêtes review/OCR/gates).
*/
@Database(
entities = [
FolderEntity::class, UserPreferenceEntity::class, FileEntity::class,
PendingOperationEntity::class, ScanSessionEntity::class, ScanPageEntity::class,
],
version = 11,
version = 13,
exportSchema = false,
)
abstract class AppDatabase : RoomDatabase() {
@@ -4,8 +4,11 @@ import com.kazier.mobile.data.local.entity.FileEntity
/** Date de référence d'un fichier : modification SAF quand dispo, sinon ajout local. */
val FileEntity.referenceDate: Long
get() = lastModified ?: addedAt
get() {
val modified = lastModified
return if (modified != null && modified > 0L) modified else addedAt
}
/** Tri documents : même ordre que la grille d'accueil, du plus récent au plus vieux. */
fun List<FileEntity>.orderedByReferenceDateDesc(): List<FileEntity> =
sortedByDescending { it.referenceDate }
sortedWith(compareByDescending<FileEntity> { it.referenceDate }.thenBy { it.name })
@@ -1,7 +1,10 @@
package com.kazier.mobile.data.local.dao
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import androidx.room.Update
import androidx.room.Upsert
import com.kazier.mobile.data.local.entity.FileEntity
import kotlinx.coroutines.flow.Flow
@@ -48,6 +51,19 @@ interface FileDao {
@Upsert
suspend fun upsert(file: FileEntity)
/**
* Insert sans écrasement, résolu sur TOUTES les contraintes uniques
* (`resource_id`, `uri`) — pas seulement la PK. Retourne le rowId, ou -1
* si une ligne existe déjà : le repository relit alors le gagnant et
* applique [update]. Deux walks/refresh concurrents ne lèvent jamais
* `SQLiteConstraintException`.
*/
@Insert(onConflict = OnConflictStrategy.IGNORE)
suspend fun insertIgnore(file: FileEntity): Long
@Update
suspend fun update(file: FileEntity)
@Query("UPDATE files SET \"exists\" = 0, updated_at = :updatedAt WHERE resource_id = :resourceId")
suspend fun markMissing(resourceId: String, updatedAt: Long)
@@ -86,8 +102,8 @@ interface FileDao {
@Query("UPDATE files SET folder_resource_id = :folderId, updated_at = :updatedAt WHERE resource_id IN (:resourceIds)")
suspend fun moveToFolder(resourceIds: List<String>, folderId: String, updatedAt: Long)
@Query("UPDATE files SET uri = :uri WHERE resource_id = :resourceId")
suspend fun updateUri(resourceId: String, uri: String?)
@Query("UPDATE files SET uri = :uri, updated_at = :updatedAt WHERE resource_id = :resourceId")
suspend fun updateUri(resourceId: String, uri: String?, updatedAt: Long)
@Query("DELETE FROM files WHERE resource_id = :resourceId")
suspend fun remove(resourceId: String)
@@ -129,7 +145,10 @@ interface FileDao {
/** Candidate OCR auto : fichier `processed`, `local-cloud`, avec copie
* locale, format potentiellement extractible, jamais extrait, pas en cours
* et pas épuisé (< 3 échecs terminaux). Trié par dernier upload. */
* et pas épuisé (< 3 échecs terminaux). Trié par dernier upload.
*
* Les lignes pré-v4 sans `category` (NULL) restent éligibles sur la base
* de leur `mime_type`/`extension` (backfill logique, sans migration). */
@Query("""
SELECT * FROM files
WHERE "exists" = 1
@@ -139,7 +158,16 @@ interface FileDao {
AND ocr_text IS NULL
AND ocr_attempts < 3
AND ocr_queued_at IS NULL
AND category IN ('PDF', 'IMAGE', 'TEXT')
AND (
category IN ('PDF', 'IMAGE', 'TEXT')
OR (category IS NULL AND (
mime_type = 'application/pdf'
OR mime_type LIKE 'image/%'
OR mime_type LIKE 'text/%'
OR extension IN ('pdf', 'png', 'jpg', 'jpeg', 'webp', 'gif', 'bmp',
'txt', 'md', 'html', 'xml', 'json')
))
)
ORDER BY COALESCE(last_modified, added_at) DESC, name ASC
""")
suspend fun getOcrAutoCandidates(): List<FileEntity>
@@ -148,8 +176,10 @@ interface FileDao {
@Query("UPDATE files SET ocr_queued_at = :queuedAt, updated_at = :now WHERE resource_id = :resourceId")
suspend fun markOcrQueued(resourceId: String, queuedAt: Long, now: Long)
/** Levé du marqueur + reset du compteur d'échecs (succès / erreur transitoire). */
@Query("UPDATE files SET ocr_queued_at = NULL, ocr_attempts = 0, updated_at = :now WHERE resource_id = :resourceId")
/** Levé du marqueur « en cours » (succès / erreur transitoire). Le
* compteur d'échecs est préservé : seul [markOcrFailure] l'incrémente,
* un succès durable passe par `updateOcrText` + `markOcrQueued` réarmé. */
@Query("UPDATE files SET ocr_queued_at = NULL, updated_at = :now WHERE resource_id = :resourceId")
suspend fun clearOcrQueued(resourceId: String, now: Long)
/** Échec terminal : +1 tentative, marqueur levé (ne rejoue pas à l'infini). */
@@ -4,6 +4,7 @@ import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import androidx.room.Update
import androidx.room.Upsert
import com.kazier.mobile.data.local.entity.FolderEntity
import kotlinx.coroutines.flow.Flow
@@ -50,6 +51,19 @@ interface FolderDao {
@Upsert
suspend fun upsert(folder: FolderEntity)
/**
* Insert sans écrasement, résolu sur TOUTES les contraintes uniques
* (`resource_id`, `uri`) — pas seulement la PK. Retourne le rowId, ou -1
* si une ligne existe déjà : le repository relit alors le gagnant et
* applique [update]. Deux walks concurrents ne lèvent jamais
* `SQLiteConstraintException`.
*/
@Insert(onConflict = OnConflictStrategy.IGNORE)
suspend fun insertIgnore(folder: FolderEntity): Long
@Update
suspend fun update(folder: FolderEntity)
@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun upsertAll(folders: List<FolderEntity>)
@@ -27,19 +27,45 @@ interface PendingOperationDao {
@Query("UPDATE pending_operations SET status = 'synced', updated_at = :now WHERE id = :id")
suspend fun markSynced(id: Long, now: Long)
/** Échec avec bump du compteur de tentatives (dead-letter après MAX_PENDING_ATTEMPTS). */
/**
* Échec définitif (dead-letter immédiate) ; `attempts` est un compteur
* diagnostic (bump), pas un seuil — il n'y a aucun `MAX_PENDING_ATTEMPTS` :
* une op `failed` n'est plus resélectionnée.
*/
@Query("UPDATE pending_operations SET status = 'failed', attempts = attempts + 1, updated_at = :now WHERE id = :id")
suspend fun markFailed(id: Long, now: Long)
/**
* Invalidation en cascade : un `create_resource` définitivement échoué rend
* fautives toutes les ops en attente qui ciblent la même ressource (filles).
* fautives toutes les ops en attente qui ciblent la même ressource, ainsi
* que les creates enfants (autre `resource_id`, liés via
* `payload.parentResourceId` — le walk émet parent avant enfant, cf. C6).
*/
@Query("UPDATE pending_operations SET status = 'failed', updated_at = :now WHERE resource_id = :resourceId AND status = 'pending'")
@Query("""
UPDATE pending_operations SET status = 'failed', updated_at = :now
WHERE status = 'pending' AND (
resource_id = :resourceId
OR payload LIKE '%"parentResourceId":"' || :resourceId || '"%'
)
""")
suspend fun failDescendants(resourceId: String, now: Long)
/** Rétention : purge des ops synchronisées plus anciennes que `cutoff`. */
@Query("DELETE FROM pending_operations WHERE status = 'synced' AND updated_at < :cutoff")
/**
* Rétention : purge des ops synchronisées plus anciennes que `cutoff`.
*
* Décision C3 — les `create_resource` synced ne sont JAMAIS purgés
* (tombstones) : les gates delete/create (`hasCreateOperation`,
* `countCreateOperations…`) et le backfill de placement sont fondés sur
* `pending+synced`. Purger un create casserait le gate delete (fantôme
* serveur indélébile) et ré-enqueue un create dupliqué au prochain
* `markProcessed`. Les autres ops synced (> 7j) sont purgées normalement.
*/
@Query("""
DELETE FROM pending_operations
WHERE status = 'synced'
AND updated_at < :cutoff
AND operation != 'create_resource'
""")
suspend fun purgeSynced(cutoff: Long)
/**
@@ -69,6 +95,45 @@ interface PendingOperationDao {
""")
suspend fun countCreateOperationsAnyType(resourceId: String): Int
/**
* Annulation (M19) : supprime les `create_resource` encore `pending` pour
* cette ressource. Appelé quand la ressource disparaît localement
* (suppression, réconciliation du walk) AVANT que le serveur l'ait connue :
* pousser un create puis un delete serait du bruit — le serveur n'a rien
* à oublier. Les creates `synced` sont conservés (tombstones C3) : le gate
* delete reste fondé dessus.
*/
@Query("""
DELETE FROM pending_operations
WHERE resource_id = :resourceId
AND operation = 'create_resource'
AND status = 'pending'
""")
suspend fun deletePendingCreates(resourceId: String): Int
/**
* Un `create_resource` a-t-il déjà été POUSSÉ (synced) pour ce fichier ?
* Gate delete précis : après [deletePendingCreates], `hasCreateOperation`
* (pending+synced) y est équivalent — ce compteur l'exprime directement.
*/
@Query("""
SELECT COUNT(*) FROM pending_operations
WHERE resource_id = :resourceId
AND operation = 'create_resource'
AND resource_type = 'file'
AND status = 'synced'
""")
suspend fun countSyncedCreateOperations(resourceId: String): Int
/** Variante sans filtre `resource_type` (dossiers) de [countSyncedCreateOperations]. */
@Query("""
SELECT COUNT(*) FROM pending_operations
WHERE resource_id = :resourceId
AND operation = 'create_resource'
AND status = 'synced'
""")
suspend fun countSyncedCreateOperationsAnyType(resourceId: String): Int
@Query("SELECT COUNT(*) FROM pending_operations WHERE status = 'pending'")
suspend fun countPending(): Int
@@ -45,6 +45,9 @@ interface ScanDao {
@Query("DELETE FROM scan_pages WHERE id = :pageId AND session_id = :sessionId")
suspend fun deletePage(pageId: Long, sessionId: Long)
@Query("DELETE FROM scan_sessions WHERE id = :sessionId")
suspend fun deleteSession(sessionId: Long)
@Query(
"""
UPDATE scan_pages SET sort_order = CASE id
@@ -61,4 +64,12 @@ interface ScanDao {
@Query("SELECT COUNT(*) FROM scan_pages WHERE session_id = :sessionId")
suspend fun pageCount(sessionId: Long): Int
/**
* Plus grand `sort_order` de la session (NULL si vide) : l'ordre d'une
* nouvelle page est `MAX + 1`, jamais `COUNT` (qui collisionne après
* suppression : A,B → del A → C réutiliserait l'ordre de B).
*/
@Query("SELECT MAX(sort_order) FROM scan_pages WHERE session_id = :sessionId")
suspend fun maxSortOrder(sessionId: Long): Int?
}
@@ -22,6 +22,7 @@ import androidx.room.PrimaryKey
Index(value = ["uri"], unique = true),
Index(value = ["folder_resource_id"]),
Index(value = ["category"]),
Index(value = ["exists", "processed", "sync_status"]),
],
)
data class FileEntity(
@@ -20,14 +20,17 @@ import androidx.room.PrimaryKey
@Entity(
tableName = "pending_operations",
indices = [
Index(value = ["operation_id"], unique = true),
Index(value = ["device_id", "operation_id"], unique = true),
Index(value = ["status"]),
Index(value = ["resource_id"]),
Index(value = ["resource_id", "operation", "status"]),
],
)
data class PendingOperationEntity(
@PrimaryKey(autoGenerate = true)
val id: Long = 0L,
@ColumnInfo(name = "device_id")
val deviceId: String? = null,
@ColumnInfo(name = "operation_id")
val operationId: String,
@ColumnInfo(name = "ref_type")
@@ -26,6 +26,13 @@ import androidx.sqlite.db.SupportSQLiteDatabase
* l'app (fichier cloud-only, uri = NULL). Null pour les fichiers importés.
* v10 : ajout colonne `ocr_text` sur `files` — extrait OCR serveur persisté
* localement (résultat d'un job `POST /ocr/jobs`, réaffichable sans relance).
* v11 : `ocr_attempts` + `ocr_queued_at` sur `files` (driver OCR auto).
* v12 : ajout colonne `device_id` sur `pending_operations` + unicité
* composite `UNIQUE(device_id, operation_id)` (contrat docs/api-v1.md §6.1) ;
* backfill depuis `user_preferences.device_user_id` pour les lignes existantes.
* v13 : index composites `files(exists, processed, sync_status)` (review +
* candidats OCR auto) et `pending_operations(resource_id, operation, status)`
* (gates outbox create/move) — requêtes à chaud sans full-table scan.
*/
object Migrations {
@@ -181,7 +188,41 @@ object Migrations {
}
}
private val MIGRATION_11_12 = object : Migration(11, 12) {
override fun migrate(db: SupportSQLiteDatabase) {
db.execSQL("ALTER TABLE `pending_operations` ADD COLUMN `device_id` TEXT")
// Backfill : les ops pré-v12 héritent du device courant (une seule
// identité device par base en pratique).
db.execSQL(
"""
UPDATE `pending_operations` SET `device_id` =
(SELECT `value` FROM `user_preferences` WHERE `key` = 'device_user_id')
WHERE `device_id` IS NULL
""".trimIndent(),
)
db.execSQL("DROP INDEX IF EXISTS `index_pending_operations_operation_id`")
db.execSQL(
"CREATE UNIQUE INDEX IF NOT EXISTS " +
"`index_pending_operations_device_id_operation_id` " +
"ON `pending_operations` (`device_id`, `operation_id`)",
)
}
}
private val MIGRATION_12_13 = object : Migration(12, 13) {
override fun migrate(db: SupportSQLiteDatabase) {
db.execSQL(
"CREATE INDEX IF NOT EXISTS `index_files_exists_processed_sync_status` " +
"ON `files` (`exists`, `processed`, `sync_status`)",
)
db.execSQL(
"CREATE INDEX IF NOT EXISTS `index_pending_operations_resource_id_operation_status` " +
"ON `pending_operations` (`resource_id`, `operation`, `status`)",
)
}
}
val ALL: Array<Migration> = arrayOf(
MIGRATION_1_2, MIGRATION_2_3, MIGRATION_3_4, MIGRATION_4_5, MIGRATION_5_6, MIGRATION_6_7, MIGRATION_7_8, MIGRATION_8_9, MIGRATION_9_10, MIGRATION_10_11,
MIGRATION_1_2, MIGRATION_2_3, MIGRATION_3_4, MIGRATION_4_5, MIGRATION_5_6, MIGRATION_6_7, MIGRATION_7_8, MIGRATION_8_9, MIGRATION_9_10, MIGRATION_10_11, MIGRATION_11_12, MIGRATION_12_13,
)
}
@@ -1,22 +1,29 @@
package com.kazier.mobile.data.remote
import com.squareup.moshi.JsonAdapter
import com.squareup.moshi.JsonDataException
import com.squareup.moshi.JsonEncodingException
import com.squareup.moshi.Moshi
import com.kazier.mobile.data.remote.dto.ApiEnvelope
import com.kazier.mobile.data.remote.dto.ApiErrorEnvelope
import com.kazier.mobile.data.remote.dto.ApiMeta
import com.kazier.mobile.data.remote.dto.ChangePasswordDto
import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto
import com.kazier.mobile.data.remote.dto.FileDto
import com.kazier.mobile.data.remote.dto.FileOcrDto
import com.kazier.mobile.data.remote.dto.FolderDto
import com.kazier.mobile.data.remote.dto.IdResultDto
import com.kazier.mobile.data.remote.dto.LoginRequestDto
import com.kazier.mobile.data.remote.dto.LoginResponseDto
import com.kazier.mobile.data.remote.dto.OcrJobDto
import com.kazier.mobile.data.remote.dto.OcrSubmitDto
import com.kazier.mobile.data.remote.dto.ResolvedUserDto
import com.kazier.mobile.data.remote.dto.ResourcePermissionDto
import com.kazier.mobile.data.remote.dto.ShareLinkDto
import com.kazier.mobile.data.remote.dto.SyncOpDto
import com.kazier.mobile.data.remote.dto.SyncOpsRequest
import com.kazier.mobile.data.remote.dto.SyncOpsResult
import kotlin.coroutines.cancellation.CancellationException
import okhttp3.MultipartBody
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody
@@ -44,7 +51,12 @@ class ApiException(
* - non-2xx → `ApiException` (code du body si présent, sinon `HTTP_<status>`),
* et un 401 sur un endpoint protégé déclenche `onUnauthorized` (sauf si
* `skipUnauthorizedHandling` — cas du login, où 401 = identifiants erronés) ;
* - 2xx sans `data` (ou corps illisible) → `INVALID_RESPONSE`.
* - 2xx sans `data` (ou corps illisible) → `INVALID_RESPONSE` ;
* - un corps non parsable (Moshi) → `INVALID_RESPONSE`, jamais
* `NETWORK_ERROR` (pas de `retry()` infini sur contrat cassé) ;
* - `CancellationException` n'est jamais avalée (scopes/Worker sains).
* Les routes publiques (`/devices`, `/auth/login`, `/shares/links/:token`)
* désactivent le handling 401 : y purger la session serait faux.
*/
@Singleton
class ApiClient @Inject constructor(
@@ -55,7 +67,7 @@ class ApiClient @Inject constructor(
private val errorEnvelopeAdapter: JsonAdapter<ApiErrorEnvelope> =
moshi.adapter(ApiErrorEnvelope::class.java)
/** Callback 401 (expiration/révocation) — branché par AuthViewModel. */
/** Callback 401 (expiration/révocation) — branché par SessionManager. */
@Volatile
var onUnauthorized: (() -> Unit)? = null
@@ -64,8 +76,20 @@ class ApiClient @Inject constructor(
suspend fun listFiles(folderId: String? = null, page: Int? = null, pageSize: Int? = null): List<FileDto> =
unwrap({ apiService.listFiles(folderId, page, pageSize) })
/**
* Variante paginée exposant `meta` (page/pageSize/total) — seule base
* saine pour drainer un dossier au-delà de la 1re page (M21).
*/
suspend fun listFilesPaged(
folderId: String? = null,
page: Int? = null,
pageSize: Int? = null,
): Pair<List<FileDto>, ApiMeta?> =
unwrapWithMeta({ apiService.listFiles(folderId, page, pageSize) })
suspend fun registerDevice(deviceId: String): String =
unwrap({ apiService.registerDevice(DeviceRegistrationDto(deviceId)) }).deviceId
unwrap({ apiService.registerDevice(DeviceRegistrationDto(deviceId)) },
skipUnauthorizedHandling = true).deviceId
suspend fun login(username: String, password: String, deviceId: String): LoginResponseDto =
unwrap({ apiService.login(LoginRequestDto(username, password, deviceId)) },
@@ -110,16 +134,59 @@ class ApiClient @Inject constructor(
suspend fun getFileOcr(fileId: String): FileOcrDto =
unwrap({ apiService.getFileOcr(fileId) })
/** Détail serveur d'un fichier visible — `GET /files/:id`. */
suspend fun getFile(fileId: String): FileDto =
unwrap({ apiService.getFile(fileId) })
/** Suppression serveur — `DELETE /files/:id`, retourne l'id supprimé. */
suspend fun deleteFile(fileId: String): String =
unwrap({ apiService.deleteFile(fileId) }).id
/** Recherche serveur paginée — `GET /files/search?q=…` (+ `meta`). */
suspend fun searchFilesPaged(
query: String,
page: Int? = null,
pageSize: Int? = null,
): Pair<List<FileDto>, ApiMeta?> =
unwrapWithMeta({ apiService.searchFiles(query, page, pageSize) })
/** Rotation du mot de passe — `PATCH /users/me/password`. */
suspend fun changePassword(currentPassword: String, newPassword: String): String =
unwrap({ apiService.changePassword(ChangePasswordDto(currentPassword, newPassword)) }).id
/**
* Résolution anonyme d'un lien de partage — `GET /shares/links/:token`
* (route publique : le 401 n'a aucun sens ici, handling désactivé).
*/
suspend fun getShareLink(token: String): ShareLinkDto =
unwrap({ apiService.getShareLink(token) }, skipUnauthorizedHandling = true)
private suspend fun <T> unwrap(
call: suspend () -> Response<ApiEnvelope<T>>,
skipUnauthorizedHandling: Boolean = false,
): T {
): T = unwrapWithMeta(call, skipUnauthorizedHandling).first
private suspend fun <T> unwrapWithMeta(
call: suspend () -> Response<ApiEnvelope<T>>,
skipUnauthorizedHandling: Boolean = false,
): Pair<T, ApiMeta?> {
val response = try {
call()
} catch (e: CancellationException) {
// Ne jamais avaler l'annulation : la convertir en ApiException
// corromprait les scopes et le WorkManager (M22).
throw e
} catch (e: JsonDataException) {
Timber.w(e, "api: corps inattendu (parsing)")
throw ApiException("INVALID_RESPONSE", "Réponse serveur invalide", 0)
} catch (e: JsonEncodingException) {
Timber.w(e, "api: corps inencodable (parsing)")
throw ApiException("INVALID_RESPONSE", "Réponse serveur invalide", 0)
} catch (e: IOException) {
Timber.d(e, "api: transport error")
throw ApiException("NETWORK_ERROR", "Serveur injoignable", 0)
} catch (e: Exception) {
if (e is CancellationException) throw e
Timber.d(e, "api: unexpected error")
throw ApiException("NETWORK_ERROR", "Serveur injoignable", 0)
}
@@ -151,6 +218,6 @@ class ApiClient @Inject constructor(
httpCode = response.code(),
)
}
return data
return data to envelope.meta
}
}
@@ -1,24 +1,29 @@
package com.kazier.mobile.data.remote
import com.kazier.mobile.data.remote.dto.ApiEnvelope
import com.kazier.mobile.data.remote.dto.ChangePasswordDto
import com.kazier.mobile.data.remote.dto.DeviceRegistrationDto
import com.kazier.mobile.data.remote.dto.FileDto
import com.kazier.mobile.data.remote.dto.FileOcrDto
import com.kazier.mobile.data.remote.dto.FolderDto
import com.kazier.mobile.data.remote.dto.IdResultDto
import com.kazier.mobile.data.remote.dto.LoginRequestDto
import com.kazier.mobile.data.remote.dto.LoginResponseDto
import com.kazier.mobile.data.remote.dto.OcrJobDto
import com.kazier.mobile.data.remote.dto.OcrSubmitDto
import com.kazier.mobile.data.remote.dto.ResolvedUserDto
import com.kazier.mobile.data.remote.dto.ResourcePermissionDto
import com.kazier.mobile.data.remote.dto.ShareLinkDto
import com.kazier.mobile.data.remote.dto.SyncOpsRequest
import com.kazier.mobile.data.remote.dto.SyncOpsResult
import okhttp3.MultipartBody
import okhttp3.RequestBody
import retrofit2.Response
import retrofit2.http.Body
import retrofit2.http.DELETE
import retrofit2.http.GET
import retrofit2.http.Multipart
import retrofit2.http.PATCH
import retrofit2.http.POST
import retrofit2.http.Part
import retrofit2.http.Path
@@ -107,4 +112,46 @@ interface ApiService {
suspend fun getFileOcr(
@Path("id") fileId: String,
): Response<ApiEnvelope<FileOcrDto>>
/** Détail d'un fichier visible (own ou shared) — `GET /files/:id`. */
@GET("files/{id}")
suspend fun getFile(
@Path("id") fileId: String,
): Response<ApiEnvelope<FileDto>>
/** Suppression serveur d'un fichier possédé — `DELETE /files/:id`. */
@DELETE("files/{id}")
suspend fun deleteFile(
@Path("id") fileId: String,
): Response<ApiEnvelope<IdResultDto>>
/**
* Recherche serveur (`GET /files/search?q=…`, paginé `meta`). Non consommée
* en V1 (recherche 100 % locale via Room) — exposée pour parité contrat.
*/
@GET("files/search")
suspend fun searchFiles(
@Query("q") query: String,
@Query("page") page: Int?,
@Query("pageSize") pageSize: Int?,
): Response<ApiEnvelope<List<FileDto>>>
/**
* Rotation du mot de passe du compte connecté (`PATCH /users/me/password`,
* `current_password` requis). Limite V1 : les tokens déjà émis restent
* valides jusqu'à expiration (7 j, pas de révocation).
*/
@PATCH("users/me/password")
suspend fun changePassword(
@Body body: ChangePasswordDto,
): Response<ApiEnvelope<IdResultDto>>
/**
* Résolution anonyme d'un lien de partage (`GET /shares/links/:token`,
* route publique — jamais de `Bearer`, cf. `AuthInterceptor`).
*/
@GET("shares/links/{token}")
suspend fun getShareLink(
@Path("token") token: String,
): Response<ApiEnvelope<ShareLinkDto>>
}
@@ -7,9 +7,12 @@ import javax.inject.Singleton
import com.kazier.mobile.auth.TokenProvider
/**
* Injecte `Authorization: Bearer <token>` sur chaque requête si un token est
* disponible. Sans token (mode local / non connecté), aucune entête n'est posée
* — le serveur répondra 401, géré proprement par `ApiClient`.
* Injecte `Authorization: Bearer <token>` sur chaque requête protégée si un
* token est disponible. Les routes publiques (`POST /devices`,
* `POST /auth/login`, `GET /shares/links/:token`, `/health`) ne reçoivent
* jamais de `Bearer` (hygiène + pas d'amplification de fuite, cf. M26/m26).
* Sans token (mode local / non connecté), aucune entête n'est posée — le
* serveur répondra 401, géré proprement par `ApiClient`.
*/
@Singleton
class AuthInterceptor @Inject constructor(
@@ -17,11 +20,31 @@ class AuthInterceptor @Inject constructor(
) : Interceptor {
override fun intercept(chain: Interceptor.Chain): Response {
val request = chain.request()
val requestBuilder = request.newBuilder()
val token = tokenProvider.current
val requestBuilder = chain.request().newBuilder()
if (token != null) {
if (token != null && !isPublic(request.url.encodedPath)) {
requestBuilder.header("Authorization", "Bearer $token")
}
return chain.proceed(requestBuilder.build())
}
companion object {
/**
* Segments terminaux des routes publiques V1 (après réécriture par
* `ServerUrlInterceptor`, la base inclut `/api/v1` — on matche en
* suffixe pour rester indépendant du préfixe configuré).
*/
private val PUBLIC_SUFFIXES = listOf(
"/devices",
"/auth/login",
"/health",
)
fun isPublic(encodedPath: String): Boolean {
if (PUBLIC_SUFFIXES.any { encodedPath.endsWith(it) }) return true
// Lien de partage anonyme : /api/v1/shares/links/:token.
return encodedPath.contains("/shares/links/")
}
}
}
@@ -3,6 +3,7 @@ package com.kazier.mobile.data.remote
import com.kazier.mobile.domain.ServerConfigStore
import javax.inject.Inject
import javax.inject.Singleton
import kotlinx.coroutines.runBlocking
import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.Interceptor
import okhttp3.Response
@@ -13,6 +14,11 @@ import timber.log.Timber
* La base Retrofit n'est qu'un placeholder ; c'est cet interceptor qui décide
* du schéma/host/port réels, en préservant le préfixe de chemin de la base
* configurée (ex. `/api/v1`) ainsi que la query d'origine.
*
* Garde M26 : si le `load()` du cold start n'a pas encore restauré l'URL
* persistée, l'interceptor le fait lui-même (bloquant, thread OkHttp — jamais
* le Main) au lieu de laisser partir la requête vers l'hôte par défaut
* (avec le `Bearer` restauré — fuite).
*/
@Singleton
class ServerUrlInterceptor @Inject constructor(
@@ -22,6 +28,10 @@ class ServerUrlInterceptor @Inject constructor(
override fun intercept(chain: Interceptor.Chain): Response {
val request = chain.request()
if (!serverConfigStore.isLoaded) {
runBlocking { serverConfigStore.load() }
}
val targetUrl = runCatching {
(serverConfigStore.current.trimEnd('/') + "/").toHttpUrl()
}.getOrNull()
@@ -32,8 +42,17 @@ class ServerUrlInterceptor @Inject constructor(
}
val original = request.url
// La base Retrofit placeholder contient déjà le préfixe de chemin
// (`/api/v1`) : ne pas le dupliquer quand le chemin d'origine le porte.
val basePath = targetUrl.encodedPath.trimEnd('/')
val origPath = original.encodedPath
val mergedPath = if (basePath.isNotEmpty() && (origPath == basePath || origPath.startsWith("$basePath/"))) {
origPath
} else {
basePath + "/" + origPath.trimStart('/')
}
val rewritten = targetUrl.newBuilder()
.encodedPath(targetUrl.encodedPath.trimEnd('/') + "/" + original.encodedPath.trimStart('/'))
.encodedPath(mergedPath)
.encodedQuery(original.encodedQuery)
.build()
@@ -88,6 +88,30 @@ data class LoginResponseDto(
@Json(name = "user") val user: UserDto,
)
/** Requête `PATCH /users/me/password` — `{ current_password, new_password }`. */
data class ChangePasswordDto(
@Json(name = "current_password") val currentPassword: String,
@Json(name = "new_password") val newPassword: String,
)
/** Réponse `PATCH /users/me/password` et `DELETE /files/:id` — `{ id }`. */
data class IdResultDto(
@Json(name = "id") val id: String,
)
/**
* Réponse `GET /shares/links/:token` — métadonnées publiques du lien
* (jamais d'identité du propriétaire au-delà du contrat).
*/
data class ShareLinkDto(
@Json(name = "token") val token: String,
@Json(name = "resource_id") val resourceId: String,
@Json(name = "resourceType") val resourceType: String,
@Json(name = "name") val name: String,
@Json(name = "access") val access: String,
@Json(name = "expiresAt") val expiresAt: String? = null,
)
/** Outbox — une op du batch `POST /sync/ops` (docs/api-v1.md §6.1). */
data class SyncOpDto(
@Json(name = "operation_id") val operationId: String,
@@ -1,8 +1,10 @@
package com.kazier.mobile.data.repository
import com.kazier.mobile.data.remote.ApiClient
import com.kazier.mobile.data.remote.ApiException
import com.kazier.mobile.data.remote.dto.LoginResponseDto
import com.kazier.mobile.domain.DeviceIdentity
import kotlin.coroutines.cancellation.CancellationException
import timber.log.Timber
import javax.inject.Inject
import javax.inject.Singleton
@@ -17,11 +19,25 @@ class AuthRepository @Inject constructor(
private val deviceIdentity: DeviceIdentity,
) {
/** Enregistrement best-effort du device (offline → ignoré). */
/**
* Enregistrement best-effort du device : seules les erreurs réseau et 5xx
* sont ignorées (offline → retry au prochain tick/login). Une 4xx
* (400 `INVALID_DEVICE_ID`, 429 `RATE_LIMITED`, …) est remontée — l'avaler
* rendrait le 401 du login incompréhensible (m23).
*/
suspend fun registerDevice(): String {
val deviceId = deviceIdentity.getOrCreate()
runCatching { apiClient.registerDevice(deviceId) }
.onFailure { Timber.d(it, "auth: device registration failed (offline?)") }
try {
apiClient.registerDevice(deviceId)
} catch (e: CancellationException) {
throw e
} catch (e: ApiException) {
if (e.httpCode == 0 || e.httpCode >= 500) {
Timber.d(e, "auth: device registration failed (offline?)")
} else {
throw e
}
}
return deviceId
}
@@ -29,8 +45,18 @@ class AuthRepository @Inject constructor(
val deviceId = deviceIdentity.getOrCreate()
// Re-registration idempotente juste avant le login : un device inconnu
// du serveur (ex. restart de la base) répondrait INVALID_DEVICE_ID.
runCatching { apiClient.registerDevice(deviceId) }
.onFailure { Timber.d(it, "auth: pre-login registration failed") }
// Même politique que registerDevice : 4xx remontée, réseau/5xx ignorés.
try {
apiClient.registerDevice(deviceId)
} catch (e: CancellationException) {
throw e
} catch (e: ApiException) {
if (e.httpCode == 0 || e.httpCode >= 500) {
Timber.d(e, "auth: pre-login registration failed")
} else {
throw e
}
}
return apiClient.login(username.trim(), password, deviceId)
}
}
}
@@ -3,6 +3,7 @@ package com.kazier.mobile.data.repository
import androidx.room.withTransaction
import com.kazier.mobile.data.local.AppDatabase
import com.kazier.mobile.data.local.dao.FileDao
import com.kazier.mobile.data.local.dao.FolderDao
import com.kazier.mobile.data.local.entity.FileEntity
import com.kazier.mobile.data.local.entity.FileStatus
import com.kazier.mobile.data.remote.ApiClient
@@ -27,6 +28,7 @@ import javax.inject.Singleton
@Singleton
class FileRepository @Inject constructor(
private val fileDao: FileDao,
private val folderDao: FolderDao,
private val apiClient: ApiClient,
private val generateId: GenerateId,
private val appDatabase: AppDatabase,
@@ -154,7 +156,7 @@ class FileRepository @Inject constructor(
updatedAt = now,
)
appDatabase.withTransaction {
fileDao.upsert(entity)
upsertTolerant(entity)
outboxRepository.enqueueCreateResource(
resourceId = entity.resourceId,
resourceType = "file",
@@ -189,6 +191,19 @@ class FileRepository @Inject constructor(
// avant le move) ne doit pas ré-attribuer le dossier à l'ancien parent.
val movePending = existing != null && outboxRepository.hasPendingMoveOperation(existing.resourceId)
val effectiveFolder = if (movePending) existing.folderResourceId else folderResourceId
// Pas de FK `files → folders` : le parent est validé ici (orphelin
// refusé au lieu d'une ligne fantôme jamais affichable).
require(folderDao.getByResourceId(effectiveFolder) != null) {
"unknown parent folder: $effectiveFolder"
}
// Un fichier cloud-only (snapshot serveur) réimporté en SAF devient
// `local-cloud` : le serveur le connaît déjà, la copie physique aussi.
val placement = if (existing != null && existing.uri == null && existing.syncStatus == FileStatus.CLOUD) {
SyncPlacement.confirmed(hasLocalUri = true)
} else {
existing?.syncStatus ?: input.syncStatus ?: FileStatus.LOCAL
}
val entity = FileEntity(
id = existing?.id ?: 0L,
@@ -203,7 +218,7 @@ class FileRepository @Inject constructor(
exists = if (input.exists) 1 else 0,
lastModified = input.lastModified,
ownerId = ownerId ?: existing?.ownerId,
syncStatus = existing?.syncStatus ?: input.syncStatus ?: FileStatus.LOCAL,
syncStatus = placement,
// Une ligne existante liée reste à son état ; une nouvelle ligne est
// « traitée » si la source l'a demandé (ex. scan), sinon à traiter.
processed = existing?.processed ?: input.processed,
@@ -211,7 +226,7 @@ class FileRepository @Inject constructor(
updatedAt = now,
)
appDatabase.withTransaction {
fileDao.upsert(entity)
upsertTolerant(entity)
if (existing == null && entity.processed) {
// Nouveau fichier physique déjà « traité » (ex. scan export) :
// poussé immédiatement. Un fichier SAF tout juste découvert
@@ -234,24 +249,35 @@ class FileRepository @Inject constructor(
suspend fun markMissing(resourceId: String, updatedAt: Long) =
fileDao.markMissing(resourceId, updatedAt)
/** Met à jour la cible dossier d'un fichier (déplacement local / cloud-only). */
/** Met à jour la cible dossier d'un fichier (déplacement local / cloud-only).
*
* Le `move_resource` n'est journalisé que si le serveur connaît déjà la
* ressource (gate `create`) : déplacer un fichier jamais poussé est une
* opération purement locale, un move serveur serait `NOT_FOUND`/no-op et
* figerait la ligne derrière `hasPendingMoveOperation`. */
suspend fun applyMove(resourceId: String, folderId: String, newUri: String?) {
require(folderDao.getByResourceId(folderId) != null) {
"unknown target folder: $folderId"
}
val now = System.currentTimeMillis()
appDatabase.withTransaction {
fileDao.moveToFolder(listOf(resourceId), folderId, now)
if (newUri != null) fileDao.updateUri(resourceId, newUri)
if (newUri != null) fileDao.updateUri(resourceId, newUri, now)
// Déplacement reflété localement ←→ poussé vers le serveur.
outboxRepository.enqueueMoveResource(
resourceId = resourceId,
resourceType = "file",
toFolderResourceId = folderId,
)
if (outboxRepository.hasCreateOperation(resourceId)) {
outboxRepository.enqueueMoveResource(
resourceId = resourceId,
resourceType = "file",
toFolderResourceId = folderId,
)
}
}
}
/**
* `GET /files?folderId=...` (1re page, tri serveur) puis upsert cloud de
* chaque fichier. Ne supprime jamais de lignes locales.
* `GET /files?folderId=...` drainé page par page en suivant `meta`
* (page/pageSize/total), puis upsert cloud de chaque fichier. Ne supprime
* jamais de lignes locales.
*
* Garde-fou outbox : un fichier dont le `move_resource` n'a pas encore été
* poussé garde son placement local. Le serveur renvoie encore l'ancien
@@ -259,15 +285,47 @@ class FileRepository @Inject constructor(
* du dossier cible (et réapparaître dans l'ancien).
*/
suspend fun refreshFromServer(folderResourceId: String) {
val files = apiClient.listFiles(folderId = folderResourceId, pageSize = PAGE_SIZE)
if (files.isEmpty()) return
val now = System.currentTimeMillis()
files.forEach { dto ->
if (outboxRepository.hasPendingMoveOperation(dto.id)) {
// L'antichambre outbox fait foi tant que le move n'est pas synced.
return@forEach
var page = 1
while (page <= MAX_PAGES) {
val (files, meta) = apiClient.listFilesPaged(
folderId = folderResourceId,
page = page,
pageSize = PAGE_SIZE,
)
files.forEach { dto ->
if (outboxRepository.hasPendingMoveOperation(dto.id)) {
// L'antichambre outbox fait foi tant que le move n'est pas synced.
return@forEach
}
upsertTolerant(toEntity(dto, folderResourceId, now))
}
fileDao.upsert(toEntity(dto, folderResourceId, now))
if (files.isEmpty()) break
val total = meta?.total
if (total != null) {
// `total` contractuel : arrêter dès la couverture atteinte.
if (page * PAGE_SIZE >= total) break
} else if (files.size < PAGE_SIZE) {
// Sans `meta` (vieux serveur) : dernière page partielle.
break
}
page++
}
}
/**
* Upsert résolu sur les contraintes uniques (`resource_id`, `uri`), pas
* sur la PK : insert-or-ignore puis update du gagnant en cas de conflit.
* Les courses walk/refresh ne lèvent jamais `SQLiteConstraintException`.
*/
private suspend fun upsertTolerant(entity: FileEntity) {
if (fileDao.insertIgnore(entity) != -1L) return
val winner = entity.uri?.let { fileDao.getByUri(it) }
?: fileDao.getByResourceId(entity.resourceId)
if (winner != null) {
fileDao.update(entity.copy(id = winner.id, resourceId = winner.resourceId))
} else {
fileDao.upsert(entity)
}
}
@@ -301,6 +359,8 @@ class FileRepository @Inject constructor(
companion object {
private const val PAGE_SIZE = 50
private const val RECENT_LIMIT = 5
/** Garde anti-boucle si le serveur renvoie un `total` incohérent. */
private const val MAX_PAGES = 2000
}
}
@@ -7,7 +7,7 @@ import com.kazier.mobile.data.local.entity.FolderEntity
import com.kazier.mobile.data.local.entity.FolderStatus
import com.kazier.mobile.data.remote.ApiClient
import com.kazier.mobile.data.remote.dto.FolderDto
import com.kazier.mobile.domain.DeviceIdentity
import com.kazier.mobile.domain.ActiveUserStore
import com.kazier.mobile.domain.GenerateId
import com.kazier.mobile.domain.SyncPlacement
import kotlinx.coroutines.flow.Flow
@@ -26,7 +26,7 @@ class FolderRepository @Inject constructor(
private val folderDao: FolderDao,
private val apiClient: ApiClient,
private val generateId: GenerateId,
private val deviceIdentity: DeviceIdentity,
private val activeUserStore: ActiveUserStore,
private val appDatabase: AppDatabase,
private val outboxRepository: OutboxRepository,
) {
@@ -66,7 +66,14 @@ class FolderRepository @Inject constructor(
val folders = apiClient.listFolders()
if (folders.isEmpty()) return
val now = System.currentTimeMillis()
folderDao.upsertAll(folders.map { toEntity(it, now) })
val rows = folders
.filterNot { dto ->
// L'antichambre outbox fait foi tant que le move n'est pas
// synced : le serveur renvoie encore l'ancien parent.
outboxRepository.hasPendingMoveOperation(dto.id)
}
.map { toEntity(it, now) }
if (rows.isNotEmpty()) folderDao.upsertAll(rows)
}
private suspend fun toEntity(dto: FolderDto, now: Long): FolderEntity {
@@ -93,8 +100,10 @@ class FolderRepository @Inject constructor(
* ajoute une ligne avec sa `uri` si absente, ou met à jour ses champs.
*
* `parentResourceId` non-null écrase le parent existant (un déplacement dans
* l'arborescence SAF est reflété) ; null préserve le parent courant. `ownerId`
* optionnel évite de relire l'identité device à chaque ligne d'un walk.
* l'arborescence SAF est reflété) ; null préserve le parent courant — sauf
* `move_resource` en attente, qui fait de la cible outbox la source de
* vérité du placement (miroir du garde fichiers). `ownerId`
* optionnel évite de relire le compte actif à chaque ligne d'un walk.
*/
suspend fun saveFolder(
input: SaveFolderInput,
@@ -105,21 +114,41 @@ class FolderRepository @Inject constructor(
val existing = input.resourceId?.let { folderDao.getByResourceId(it) }
?: input.uri?.let { folderDao.getByUri(it) }
// Garde pending-move (M1) : un snapshot SAF périmé ne revert jamais un
// reparent/merge en cours de push.
val movePending = existing != null && outboxRepository.hasPendingMoveOperation(existing.resourceId)
val effectiveParent = if (movePending) existing.parentResourceId else (parentResourceId ?: existing?.parentResourceId)
// Pas de FK `files → folders` : le parent est validé ici (orphelin
// refusé au lieu d'une ligne fantôme jamais affichable).
if (effectiveParent != null && folderDao.getByResourceId(effectiveParent) == null) {
throw IllegalArgumentException("unknown parent folder: $effectiveParent")
}
// Un dossier cloud-only réimporté en SAF devient `local-cloud`.
val placement = if (existing != null && existing.uri == null && input.uri != null &&
existing.syncStatus == FolderStatus.CLOUD
) {
SyncPlacement.confirmed(hasLocalUri = true)
} else {
existing?.syncStatus ?: FolderStatus.LOCAL
}
val entity = FolderEntity(
id = existing?.id ?: 0L,
resourceId = existing?.resourceId ?: input.resourceId ?: generateId.newResourceId(),
uri = input.uri,
name = input.name,
exists = input.exists?.let { if (it) 1 else 0 },
parentResourceId = parentResourceId ?: existing?.parentResourceId,
ownerId = ownerId ?: existing?.ownerId ?: deviceIdentity.getOrCreate(),
syncStatus = existing?.syncStatus ?: FolderStatus.LOCAL,
parentResourceId = effectiveParent,
// `owner_id` Room = user_id du compte actif, jamais l'identité device.
ownerId = ownerId ?: existing?.ownerId ?: activeUserStore.get(),
syncStatus = placement,
createdInApp = existing?.createdInApp ?: input.createdInApp,
addedAt = existing?.addedAt ?: now,
updatedAt = now,
)
appDatabase.withTransaction {
folderDao.upsert(entity)
upsertTolerant(entity)
if (existing == null) {
// Nouvelle ressource physique → la pousser vers le serveur.
outboxRepository.enqueueCreateResource(
@@ -140,21 +169,45 @@ class FolderRepository @Inject constructor(
/**
* Re-parente des sous-dossiers vers un nouveau parent (fusion de dossiers).
* Transaction atomique : reparent Room + outbox `move_resource` par dossier.
*
* Le `move_resource` n'est journalisé que si le serveur connaît déjà le
* dossier (gate `create`, miroir fichiers) : sinon le move serait
* `NOT_FOUND` et figerait la ligne derrière `hasPendingMoveOperation`.
*/
suspend fun reparentSubFolders(resourceIds: List<String>, newParentId: String) {
if (resourceIds.isEmpty()) return
require(folderDao.getByResourceId(newParentId) != null) {
"unknown target folder: $newParentId"
}
val now = System.currentTimeMillis()
appDatabase.withTransaction {
folderDao.reparent(resourceIds, newParentId, now)
for (resourceId in resourceIds) {
outboxRepository.enqueueMoveResource(
resourceId = resourceId,
resourceType = "folder",
toFolderResourceId = newParentId,
)
if (outboxRepository.hasCreateOperationAnyType(resourceId)) {
outboxRepository.enqueueMoveResource(
resourceId = resourceId,
resourceType = "folder",
toFolderResourceId = newParentId,
)
}
}
}
}
/**
* Upsert résolu sur les contraintes uniques (`resource_id`, `uri`), pas
* sur la PK : insert-or-ignore puis update du gagnant en cas de conflit.
*/
private suspend fun upsertTolerant(entity: FolderEntity) {
if (folderDao.insertIgnore(entity) != -1L) return
val winner = entity.uri?.let { folderDao.getByUri(it) }
?: folderDao.getByResourceId(entity.resourceId)
if (winner != null) {
folderDao.update(entity.copy(id = winner.id, resourceId = winner.resourceId))
} else {
folderDao.upsert(entity)
}
}
}
data class SaveFolderInput(
@@ -7,6 +7,7 @@ import com.kazier.mobile.data.local.dao.PendingOperationDao
import com.kazier.mobile.data.local.entity.PendingOpStatus
import com.kazier.mobile.data.local.entity.PendingOperationEntity
import com.kazier.mobile.data.local.entity.PendingOperationType
import com.kazier.mobile.domain.DeviceIdentity
import com.kazier.mobile.domain.GenerateId
import javax.inject.Inject
import javax.inject.Singleton
@@ -23,6 +24,7 @@ import javax.inject.Singleton
class OutboxRepository @Inject constructor(
private val pendingOperationDao: PendingOperationDao,
private val generateId: GenerateId,
private val deviceIdentity: DeviceIdentity,
moshi: Moshi,
) {
@@ -46,6 +48,9 @@ class OutboxRepository @Inject constructor(
val now = System.currentTimeMillis()
pendingOperationDao.insert(
PendingOperationEntity(
// Clé d'idempotence locale UNIQUE(device_id, operation_id)
// (contrat docs/api-v1.md §6.1).
deviceId = deviceIdentity.getOrCreate(),
operationId = operationId,
refType = refType,
refId = refId,
@@ -9,6 +9,8 @@ import com.kazier.mobile.data.local.entity.ScanSessionEntity
import com.kazier.mobile.data.local.entity.ScanSessionStatus
import com.kazier.mobile.domain.GenerateId
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import javax.inject.Inject
import javax.inject.Singleton
@@ -24,20 +26,28 @@ class ScanRepository @Inject constructor(
private val generateId: GenerateId,
) {
suspend fun getOrCreateActiveSession(rootFolderId: String?): ScanSessionEntity {
scanDao.getActiveSession()?.let { return it }
val now = System.currentTimeMillis()
val sessionId = scanDao.insertSession(
ScanSessionEntity(
resourceId = generateId.newResourceId(),
rootFolderId = rootFolderId,
status = ScanSessionStatus.ACTIVE,
createdAt = now,
updatedAt = now,
),
)
return checkNotNull(scanDao.getSession(sessionId))
}
/**
* Single-flight de création de session : sans garde, deux appels
* concurrents créent deux sessions `active` (aucune unicité partielle
* côté Room) et orphelinent les pages de l'une d'elles.
*/
private val sessionMutex = Mutex()
suspend fun getOrCreateActiveSession(rootFolderId: String?): ScanSessionEntity =
sessionMutex.withLock {
scanDao.getActiveSession()?.let { return@withLock it }
val now = System.currentTimeMillis()
val sessionId = scanDao.insertSession(
ScanSessionEntity(
resourceId = generateId.newResourceId(),
rootFolderId = rootFolderId,
status = ScanSessionStatus.ACTIVE,
createdAt = now,
updatedAt = now,
),
)
checkNotNull(scanDao.getSession(sessionId))
}
suspend fun setRootFolder(sessionId: Long, rootFolderId: String) {
appDatabase.withTransaction {
@@ -61,7 +71,10 @@ class ScanRepository @Inject constructor(
height: Int,
): ScanPageEntity {
val now = System.currentTimeMillis()
val order = scanDao.pageCount(session.id)
// MAX + 1, jamais COUNT : après suppression, COUNT réutilise un ordre
// existant (doublons → `ORDER BY sort_order` instable, `swapOrder`
// ambigu), MAX + 1 reste strictement unique et croissant.
val order = (scanDao.maxSortOrder(session.id) ?: -1) + 1
val page = ScanPageEntity(
resourceId = generateId.newResourceId(),
sessionId = session.id,
@@ -73,8 +86,10 @@ class ScanRepository @Inject constructor(
status = ScanPageStatus.PENDING,
createdAt = now,
)
scanDao.insertPage(page)
return page
// L'id auto-généré est indispensable : sans lui, deletePage/movePage
// ciblent l'id 0 et ne touchent aucune ligne.
val rowId = scanDao.insertPage(page)
return page.copy(id = rowId)
}
suspend fun deletePage(pageId: Long, sessionId: Long) {
@@ -83,6 +98,13 @@ class ScanRepository @Inject constructor(
}
}
/** Supprime une session abandonnée vide (jamais de session orpheline). */
suspend fun deleteSession(sessionId: Long) {
appDatabase.withTransaction {
scanDao.deleteSession(sessionId)
}
}
suspend fun movePage(sessionId: Long, pages: List<ScanPageEntity>, pageId: Long, delta: Int) {
val index = pages.indexOfFirst { it.id == pageId }
val target = index + delta
@@ -8,7 +8,7 @@ import com.kazier.mobile.data.local.entity.FileEntity
import com.kazier.mobile.data.local.entity.FolderEntity
import com.kazier.mobile.data.remote.ApiClient
import com.kazier.mobile.data.remote.dto.ResourcePermissionDto
import com.kazier.mobile.domain.DeviceIdentity
import com.kazier.mobile.domain.ActiveUserStore
import com.kazier.mobile.domain.SyncPlacement
import timber.log.Timber
import javax.inject.Inject
@@ -28,7 +28,7 @@ import javax.inject.Singleton
class ShareRepository @Inject constructor(
private val apiClient: ApiClient,
private val appDatabase: AppDatabase,
private val deviceIdentity: DeviceIdentity,
private val activeUserStore: ActiveUserStore,
) {
/**
@@ -42,7 +42,8 @@ class ShareRepository @Inject constructor(
* marquées `exists = 0`.
*/
suspend fun syncSnapshot() {
val currentUserId = deviceIdentity.getOrCreate()
// `ownerId` serveur = user_id : comparer au compte actif, jamais au device.
val currentUserId = activeUserStore.get()
val permissions = apiClient.syncPermissions()
val now = System.currentTimeMillis()
@@ -67,18 +68,23 @@ class ShareRepository @Inject constructor(
}
}
// Convergence : marquer les lignes cloud-only absentes du snapshot
// comme disparues (révocation / expiration côté serveur).
// Convergence : marquer les lignes cloud-only d'autrui absentes du
// snapshot comme disparues (révocation / expiration côté serveur).
// Sans compte actif, impossible d'attribuer : ne rien masquer. Le
// snapshot exclut les ressources possédées → une ligne cloud-only
// au vrai ownerId=user ne doit jamais être markMissing.
for (folder in folderDao.getAll()) {
if (isCloudOnlyForOtherUser(folder.uri, folder.ownerId, currentUserId, folder.exists)
&& folder.resourceId !in snapshotFolderIds
if (currentUserId != null &&
isCloudOnlyForOtherUser(folder.uri, folder.ownerId, currentUserId, folder.exists) &&
folder.resourceId !in snapshotFolderIds
) {
folderDao.markMissing(folder.resourceId, now)
}
}
for (file in fileDao.getAll()) {
if (isCloudOnlyForOtherUser(file.uri, file.ownerId, currentUserId, file.exists)
&& file.resourceId !in snapshotFileIds
if (currentUserId != null &&
isCloudOnlyForOtherUser(file.uri, file.ownerId, currentUserId, file.exists) &&
file.resourceId !in snapshotFileIds
) {
fileDao.markMissing(file.resourceId, now)
}
@@ -99,9 +105,9 @@ class ShareRepository @Inject constructor(
private fun isCloudOnlyForOtherUser(
uri: String?,
ownerId: String?,
currentNodeId: String,
currentUserId: String,
exists: Int?,
): Boolean = uri == null && ownerId != null && ownerId != currentNodeId && exists != 0
): Boolean = uri == null && ownerId != null && ownerId != currentUserId && exists != 0
private suspend fun upsertSharedFolder(
perm: ResourcePermissionDto,
@@ -1,5 +1,8 @@
package com.kazier.mobile.di
import com.kazier.mobile.auth.SecureTokenStore
import com.kazier.mobile.auth.TokenStore
import dagger.Binds
import dagger.Module
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
@@ -9,4 +12,8 @@ import dagger.hilt.components.SingletonComponent
*/
@Module
@InstallIn(SingletonComponent::class)
object AppModule
abstract class AppModule {
@Binds
abstract fun bindTokenStore(impl: SecureTokenStore): TokenStore
}
@@ -2,7 +2,6 @@ package com.kazier.mobile.di
import com.squareup.moshi.Moshi
import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory
import com.kazier.mobile.BuildConfig
import com.kazier.mobile.data.remote.ApiService
import com.kazier.mobile.data.remote.AuthInterceptor
import com.kazier.mobile.data.remote.ServerUrlInterceptor
@@ -34,12 +33,10 @@ object NetworkModule {
serverUrlInterceptor: ServerUrlInterceptor,
authInterceptor: AuthInterceptor,
): OkHttpClient {
// Logging désactivé même en DEBUG : BASIC loggue les lignes de requête
// avec query PII (`GET /users/resolve?username=…`) dans logcat (m25).
val logging = HttpLoggingInterceptor().apply {
level = if (BuildConfig.DEBUG) {
HttpLoggingInterceptor.Level.BASIC
} else {
HttpLoggingInterceptor.Level.NONE
}
level = HttpLoggingInterceptor.Level.NONE
}
return OkHttpClient.Builder()
.addInterceptor(serverUrlInterceptor)
@@ -4,6 +4,8 @@ import com.kazier.mobile.data.local.dao.UserPreferenceDao
import com.kazier.mobile.data.local.entity.UserPreferenceEntity
import javax.inject.Inject
import javax.inject.Singleton
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
/**
* Identité locale du device : 32-hex généré une seule fois à la première
@@ -15,13 +17,22 @@ class DeviceIdentity @Inject constructor(
private val generateId: GenerateId,
) {
suspend fun getOrCreate(): String {
/**
* Single-flight intra-processus : deux `getOrCreate()` concurrents ne
* génèrent/inserent qu'une seule fois (`insertIgnore` tranche, le perdant
* relit la valeur gagnante).
*/
private val mutex = Mutex()
suspend fun getOrCreate(): String = mutex.withLock {
userPreferenceDao.getValue(PrefKeys.DEVICE_USER_ID)?.let { return it }
val id = generateId.newResourceId()
userPreferenceDao.insertIgnore(
UserPreferenceEntity(PrefKeys.DEVICE_USER_ID, id, System.currentTimeMillis()),
)
return userPreferenceDao.getValue(PrefKeys.DEVICE_USER_ID)
?: generateId.newResourceId()
// Jamais de fallback fantôme : si la rellecture échoue, échouer
// proprement plutôt que de renvoyer un ID non persisté.
userPreferenceDao.getValue(PrefKeys.DEVICE_USER_ID)
?: error("device identity not persisted")
}
}
@@ -13,6 +13,8 @@ enum class FileCategory {
}
fun computeCategory(mimeType: String?, extension: String?): FileCategory {
// Le CSV est toujours TEXT (MIME `text/csv` comme extension `csv`) :
// un même fichier ne change jamais de catégorie selon le chemin d'entrée.
val mime = mimeType?.lowercase().orEmpty()
val ext = extension?.lowercase().orEmpty()
@@ -41,11 +43,11 @@ private val OFFICE_MIMES = setOf(
private val OFFICE_EXTENSIONS = setOf(
"doc", "docx", "odt", "rtf",
"xls", "xlsx", "ods", "csv",
"xls", "xlsx", "ods",
"ppt", "pptx", "odp",
)
private val TEXT_EXTENSIONS = setOf(
"txt", "md", "html", "xml", "json", "css", "js", "kt", "py", "java",
"log", "ini", "cfg", "yaml", "yml", "toml",
"log", "ini", "cfg", "yaml", "yml", "toml", "csv",
)
@@ -16,6 +16,6 @@ class GenerateId @Inject constructor() {
fun newResourceId(): String {
val bytes = ByteArray(16)
random.nextBytes(bytes)
return bytes.joinToString("") { "%02x".format(it) }
return bytes.joinToString("") { "%02x".format(it.toInt() and 0xFF) }
}
}
@@ -21,7 +21,7 @@ class LocalModeStore @Inject constructor(
)
}
suspend fun get(): Boolean = userPreferenceDao.getValue(PrefKeys.LOCAL_MODE) != null
suspend fun get(): Boolean = userPreferenceDao.getValue(PrefKeys.LOCAL_MODE) == "1"
suspend fun clear() = userPreferenceDao.delete(PrefKeys.LOCAL_MODE)
}
@@ -32,6 +32,10 @@ class ServerConfigStore @Inject constructor(
private val _baseUrl = MutableStateFlow(DEFAULT_BASE_URL)
val baseUrl: StateFlow<String> = _baseUrl.asStateFlow()
/** Vrai une fois [load] passé — lu par `ServerUrlInterceptor` (garde M26). */
val isLoaded: Boolean
get() = loaded.get()
/** Dernière base effective — lu par `ServerUrlInterceptor` (filaire, volatile). */
val current: String
get() = _baseUrl.value
@@ -43,12 +47,48 @@ class ServerConfigStore @Inject constructor(
_baseUrl.value = stored?.takeIf { it.isNotBlank() }?.let(::normalize) ?: DEFAULT_BASE_URL
}
suspend fun set(url: String) {
val normalized = normalize(url).ifEmpty { DEFAULT_BASE_URL }
_baseUrl.value = normalized
/**
* Réarme le garde once-only pour permettre un rechargement (ex. après
* wipe/logout où la valeur en mémoire est périmée).
*/
fun invalidate() {
loaded.set(false)
}
/** Recharge depuis la DB même si déjà chargé (ex. après wipe/logout). */
suspend fun reload() {
loaded.set(false)
load()
}
/**
* Persiste la base serveur après validation (M28). Retourne `false` —
* sans rien persister ni publier — si l'URL est invalide (schéma non
* http/https, host vide, illisible par OkHttp) : l'appelant par frappe
* ([com.kazier.mobile.ui.settings.SettingsViewModel.onServerUrlChange])
* ne brique jamais l'app sur une saisie intermédiaire.
*/
suspend fun set(url: String): Boolean {
val normalized = validate(url) ?: return false
userPreferenceDao.upsert(
UserPreferenceEntity(PrefKeys.SERVER_URL, normalized, System.currentTimeMillis()),
)
// Publier après succès DB pour ne jamais diverger UI/DB si l'upsert échoue.
_baseUrl.value = normalized
return true
}
/**
* Normalise puis valide : schéma http/https et host non vide exigés.
* Retourne la base normalisée, ou `null` si invalide.
*/
fun validate(url: String): String? {
val normalized = normalize(url)
if (normalized.isEmpty()) return null
val parsed = runCatching { normalized.toHttpUrl() }.getOrNull() ?: return null
if (parsed.scheme != "http" && parsed.scheme != "https") return null
if (parsed.host.isBlank()) return null
return normalized
}
/** Trim, ajoute `http://` si le schéma est absent, retire les `/` finaux. */
@@ -31,10 +31,25 @@ class ThemePreferenceStore @Inject constructor(
_theme.value = ThemePreference.fromStored(stored)
}
/**
* Réarme le garde once-only pour permettre un rechargement (ex. après
* wipe/logout où la valeur en mémoire est périmée).
*/
fun invalidate() {
loaded.set(false)
}
/** Recharge depuis la DB même si déjà chargé (ex. après wipe/logout). */
suspend fun reload() {
loaded.set(false)
load()
}
suspend fun set(theme: ThemePreference) {
_theme.value = theme
userPreferenceDao.upsert(
UserPreferenceEntity(PrefKeys.THEME, theme.storedValue, System.currentTimeMillis()),
)
// Publier après succès DB pour ne jamais diverger UI/DB si l'upsert échoue.
_theme.value = theme
}
}
@@ -18,11 +18,13 @@ import javax.inject.Singleton
*
* - fichier physique (uri ≠ null) + dossier cible physique → relocation SAF
* réelle via `DocumentsContract.moveDocument` (l'arborescence locale reste
* cohérente avec Room) ; en cas d'échec (permission/edge provider), repli
* bas de gamme : métadonnée seule (`folderResourceId`), la marche suivante
* re-réconciliera.
* cohérente avec Room) ; en cas d'échec (permission/edge provider), Room
* est laissée INCHANGÉE — le repli « métadonnée seule » mentirait
* durablement (nouveau parent + ancienne uri), et le garde pending-move
* bloquerait le walk. L'utilisateur peut réessayer, le walk réconciliera.
* - fichier cloud-only → mise à jour de la métadonnée de dossier uniquement
* (`applyMove` journalise aussi un `move_resource` dans l'outbox).
* (`applyMove` journalise aussi un `move_resource` dans l'outbox, sous gate
* `create`).
*/
@Singleton
class FileMover @Inject constructor(
@@ -42,21 +44,24 @@ class FileMover @Inject constructor(
withContext(Dispatchers.IO) {
for (resourceId in resourceIds) {
val file = fileRepository.getFile(resourceId) ?: continue
val physicalTarget = file.uri != null && targetDoc != null
val newUri = if (physicalTarget) {
tryMove(file.uri, file.folderResourceId, targetDoc)
if (file.uri != null && targetDoc != null) {
// Refus du provider → on ne touche pas à Room (cohérence
// disque/Room/serveur préservée, nouvel essai possible).
val movedUri = tryMove(file.uri, file.folderResourceId, targetDoc)
?: continue
fileRepository.applyMove(resourceId, targetFolderId, movedUri)
} else {
null
fileRepository.applyMove(resourceId, targetFolderId, file.uri)
}
fileRepository.applyMove(resourceId, targetFolderId, newUri ?: file.uri)
}
}
}
/**
* Tente la relocation SAF. Retourne le nouvel uri du document (peut être
* identique à l'ancien), ou null en échec → repli métadonnée seule.
* Tente la relocation SAF. Retourne le nouvel uri du document, ou null en
* échec (exception, retour null, ou uri identique à la source — certains
* providers renvoient la source quand ils refusent ou déplacent sur place :
* sans preuve d'un nouvel emplacement, on ne touche pas à Room).
*/
private suspend fun tryMove(fileUri: String?, sourceFolderId: String, targetDoc: Uri): String? {
if (fileUri == null) return null
@@ -71,7 +76,8 @@ class FileMover @Inject constructor(
targetDoc,
)
}.onSuccess { moved -> Timber.d("moved %s -> %s (%s)", fileUri, targetDoc, moved) }
.onFailure { Timber.w(it, "physical move failed for %s (metadata-only)", fileUri) }
.onFailure { Timber.w(it, "physical move failed for %s (Room unchanged)", fileUri) }
.getOrNull()?.toString()
.takeIf { it != fileUri }
}
}
@@ -1,9 +1,12 @@
package com.kazier.mobile.features.saf
import android.content.Context
import android.provider.DocumentsContract
import com.kazier.mobile.data.local.entity.FolderEntity
import com.kazier.mobile.data.repository.FileRepository
import com.kazier.mobile.data.repository.FolderRepository
import com.kazier.mobile.data.repository.SaveFolderInput
import dagger.hilt.android.qualifiers.ApplicationContext
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import timber.log.Timber
@@ -14,17 +17,22 @@ import javax.inject.Singleton
* Fusion de dossiers en mode multi-sélection.
*
* 1. Crée un nouveau dossier nommé `newName` au même niveau que les dossiers
* sélectionnés (même parent).
* sélectionnés (même parent) — ou réutilise celui d'une tentative
* précédente (idempotence : un crash à mi-fusion ne duplique jamais le
* dossier fusionné à la relance).
* 2. Déplace tout le contenu de chaque dossier source (fichiers + sous-dossiers)
* vers le dossier fusionné — relocation SAF quand les deux côtés sont
* physiques, repli métadonnée seule sinon (`move_resource` outbox quand même).
* 3. Supprime les dossiers sources désormais vides (physique + outbox).
* physiques (fichiers via [FileMover], sous-dossiers via `moveDocument`),
* métadonnée seule sinon (`move_resource` outbox sous gate `create`).
* Un refus SAF laisse la source en place (ni reparent ni suppression).
* 3. Supprime les dossiers sources vidés avec succès (physique + outbox).
*
* L'ordre outbox est garanti par l'insertion séquentielle : `create_resource`
* du dossier fusionné avant les `move_resource`, avant les `delete_resource`.
*/
@Singleton
class FolderMerger @Inject constructor(
@ApplicationContext private val context: Context,
private val folderRepository: FolderRepository,
private val fileRepository: FileRepository,
private val fileMover: FileMover,
@@ -45,13 +53,15 @@ class FolderMerger @Inject constructor(
suspend fun mergeSelectedFolders(folders: List<FolderEntity>, newName: String): MergeReport {
require(folders.size >= 2) { "merge requires at least 2 folders" }
// 1. Dossier fusionné au même niveau que les sources.
// 1. Dossier fusionné au même niveau que les sources (réutilisé si une
// tentative précédente l'a déjà créé — relance idempotente).
val parentId = folders.first().parentResourceId
val merged = createMergedFolder(parentId, newName)
// 2. Déplacement du contenu de chaque dossier source.
var movedFiles = 0
var stepFailures = 0
val readyToDelete = ArrayList<FolderEntity>()
withContext(Dispatchers.IO) {
for (src in folders) {
val ok = runCatching {
@@ -62,18 +72,29 @@ class FolderMerger @Inject constructor(
}
val subFolders = folderRepository.getChildren(src.resourceId)
if (subFolders.isNotEmpty()) {
folderRepository.reparentSubFolders(subFolders.map { it.resourceId }, merged.resourceId)
val movable = subFolders.filter { moveSubFolderPhysically(it, src, merged) }
if (movable.size < subFolders.size) {
error("refus SAF : ${subFolders.size - movable.size} sous-dossier(s) non déplaçables")
}
if (movable.isNotEmpty()) {
folderRepository.reparentSubFolders(movable.map { it.resourceId }, merged.resourceId)
}
}
}.isSuccess
if (!ok) stepFailures++
if (ok) {
readyToDelete += src
} else {
stepFailures++
}
}
}
// 3. Suppression des dossiers sources (désormais sans contenu).
// 3. Suppression des dossiers sources vidés avec succès (jamais ceux
// dont le contenu n'a pas pu être déplacé).
var deletedFolders = 0
var failed = 0
withContext(Dispatchers.IO) {
for (src in folders) {
for (src in readyToDelete) {
val report = folderDeleter.deleteFolders(listOf(src), FileDeleter.DeleteMode.FULL)
if (report.failed == 0) deletedFolders++ else failed++
}
@@ -84,12 +105,38 @@ class FolderMerger @Inject constructor(
return MergeReport(movedFiles = movedFiles, deletedFolders = deletedFolders, failed = failed)
}
/**
* Déplace physiquement un sous-dossier vers le dossier fusionné.
* Retourne `true` si le reparent Room peut suivre : rien à déplacer
* (cloud-only) ou `moveDocument` accepté. `false` (refus SAF) → la source
* reste en place, ni reparentée ni supprimée (cohérence disque/Room).
*/
private fun moveSubFolderPhysically(sub: FolderEntity, src: FolderEntity, merged: FolderEntity): Boolean {
val subUri = SafUris.toDocumentUri(sub.uri) ?: return true
val mergedDoc = SafUris.toDocumentUri(merged.uri) ?: return true
val srcDoc = SafUris.toDocumentUri(src.uri) ?: return false
return runCatching {
DocumentsContract.moveDocument(
context.contentResolver,
subUri,
srcDoc,
mergedDoc,
)
}.onSuccess { moved -> Timber.d("moved folder %s -> %s (%s)", subUri, mergedDoc, moved) }
.onFailure { Timber.w(it, "physical folder move failed for %s", subUri) }
.getOrNull() != null
}
/**
* Crée (physique si le parent l'est, cloud-only sinon) et enregistre en Room
* le dossier fusionné. Retourne l'entité Room. La sauvegarde enqueue le
* `create_resource` dans la même transaction.
*
* Idempotence : si un frère du même nom existe déjà (crash à mi-fusion puis
* relance), il est réutilisé — aucun doublon, aucun `create_resource` bis.
*/
private suspend fun createMergedFolder(parentId: String?, newName: String): FolderEntity {
findExistingMerged(parentId, newName)?.let { return it }
val parent = parentId?.let { folderRepository.getFolder(it) }
val createdUri = parent?.uri?.let { safFolderCreator.createFolder(it, newName) }?.toString()
return folderRepository.saveFolder(
@@ -102,4 +149,14 @@ class FolderMerger @Inject constructor(
parentResourceId = parentId,
)
}
/** Frère existant du même nom (visible), ou null si première tentative. */
private suspend fun findExistingMerged(parentId: String?, newName: String): FolderEntity? {
val siblings = if (parentId == null) {
folderRepository.getRootFolders().filter { it.exists != 0 }
} else {
folderRepository.getChildren(parentId)
}
return siblings.firstOrNull { it.name == newName }
}
}
@@ -36,11 +36,28 @@ object CornerGeometry {
return abs(sum) / 2f
}
/** Dimensions du document redressé (moyenne des côtés opposés). */
/** Dimensions du document redressé (plus grand des côtés opposés). */
fun outputSize(points: List<PointF>): Pair<Int, Int> {
val (tl, tr, br, bl) = orderPoints(points)
val w = max(distance(tl, tr), distance(bl, br))
val h = max(distance(tl, bl), distance(tr, br))
return w.roundToInt() to h.roundToInt()
}
/**
* Quad inexploitable (coins dupliqués, aire nulle, aplati) : le warp
* produirait une page blanche 1×1 validée par erreur — l'appelant doit
* refuser la page au lieu de la persister.
*/
fun isDegenerate(points: List<PointF>, epsilon: Float = 0.5f): Boolean {
if (points.size != 4) return true
for (i in points.indices) {
for (j in i + 1 until points.size) {
if (distance(points[i], points[j]) <= epsilon) return true
}
}
if (area(points) <= epsilon) return true
val (w, h) = outputSize(points)
return w <= 0 || h <= 0
}
}
@@ -0,0 +1,30 @@
package com.kazier.mobile.features.scan
import com.kazier.mobile.data.local.entity.ScanPageEntity
import com.kazier.mobile.data.local.entity.ScanPageStatus
/**
* Décisions pures de l'export d'une session de scan (aucune IO) :
* - **retry idempotent** : seul le `PENDING` est (ré)exporté, jamais le
* `EXPORTED` (chaque retry créait sinon un nouvel URI SAF + ligne Room +
* op outbox en double) ;
* - **pas de DONE partiel** : la session ne passe `DONE` que si tout a
* réussi ; un temp manquant ou une page en échec reste `PENDING` pour
* reprise, la session reste active avec un message d'erreur.
*/
object ScanExport {
/** Pages à (ré)exporter : les `PENDING` dans l'ordre de la session. */
fun pendingForExport(pages: List<ScanPageEntity>): List<ScanPageEntity> =
pages.filter { it.status == ScanPageStatus.PENDING }
/** Pages effectivement embarquées (succès seuls, jamais les échecs). */
fun succeeded(
pages: List<ScanPageEntity>,
failedIds: Set<String>,
): List<ScanPageEntity> =
pages.filterNot { it.resourceId in failedIds }
/** La session ne se termine que si aucune page n'a échoué. */
fun shouldFinishSession(failedCount: Int): Boolean = failedCount == 0
}
@@ -39,7 +39,7 @@ class ScanImageProcessor @Inject constructor() {
fun isAvailable(): Boolean {
if (!loaded) {
loaded = OpenCVLoader.initLocal()
loaded = runCatching { OpenCVLoader.initLocal() }.getOrDefault(false)
}
return loaded
}
@@ -83,9 +83,14 @@ class ScanImageProcessor @Inject constructor() {
/**
* Redresse (`warpPerspective`) selon `quad` puis applique le mode de rendu.
* Sortie plafonnée à [MAX_OUTPUT_SIDE] px sur le grand côté.
*
* Contrat alias : si OpenCV est indisponible, retourne l'instance d'entrée
* elle-même — l'appelant ne doit la recycler que s'il a reçu une nouvelle
* instance (`processed !== input`), jamais un alias du bitmap affiché.
*/
fun process(bitmap: Bitmap, quad: ScanQuad, mode: ScanRenderMode): Bitmap {
if (!isAvailable()) return bitmap
require(!CornerGeometry.isDegenerate(quad.points)) { "degenerate quad" }
val (targetW, targetH) = CornerGeometry.outputSize(quad.points)
val maxSide = max(targetW, targetH)
val outScale = min(1f, MAX_OUTPUT_SIDE.toFloat() / maxSide)
@@ -177,6 +182,9 @@ class ScanImageProcessor @Inject constructor() {
blur.release()
edges.release()
hierarchy.release()
// Contours non consommés (exception à mi-boucle) : `release()` est
// idempotent côté OpenCV, les déjà-libérés sont des no-ops.
contours.forEach { runCatching { it.release() } }
}
}
@@ -9,7 +9,7 @@ import com.kazier.mobile.data.repository.FolderRepository
import com.kazier.mobile.data.repository.OutboxRepository
import com.kazier.mobile.data.repository.SaveFileInput
import com.kazier.mobile.data.repository.SaveFolderInput
import com.kazier.mobile.domain.DeviceIdentity
import com.kazier.mobile.domain.ActiveUserStore
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import timber.log.Timber
@@ -36,7 +36,7 @@ class DeviceSync @Inject constructor(
private val folderRepository: FolderRepository,
private val fileRepository: FileRepository,
private val outboxRepository: OutboxRepository,
private val deviceIdentity: DeviceIdentity,
private val activeUserStore: ActiveUserStore,
) {
data class SyncResult(
@@ -66,7 +66,8 @@ class DeviceSync @Inject constructor(
private suspend fun doSyncRoot(root: FolderEntity): SyncResult {
val rootUri = checkNotNull(root.uri) { "root '${root.name}' has no physical uri" }
val ownerId = deviceIdentity.getOrCreate()
// `owner_id` Room = user_id du compte actif, jamais l'identité device.
val ownerId = activeUserStore.get()
// Phase 1 — listing SAF (I/O disque, HORS transaction).
val folders = scanner.scanTree(Uri.parse(rootUri))
@@ -79,9 +80,22 @@ class DeviceSync @Inject constructor(
for (folder in folders) {
seen += folder.uri
val parentResourceId =
if (folder.parentUri == null) null
else resourceIdByUri[folder.parentUri] ?: root.resourceId
val parentResourceId = if (folder.parentUri == null) {
null
} else {
resourceIdByUri[folder.parentUri]
}
if (folder.parentUri != null && parentResourceId == null) {
// Violation parent-avant-enfant (snapshot incohérent) : on
// n'attache JAMAIS à la racine par défaut — le dossier est
// ignoré et journalisé, le prochain walk convergera.
Timber.w(
"walk: parent SAF inconnu, dossier ignoré (uri=%s parent=%s)",
folder.uri,
folder.parentUri,
)
continue
}
val saved = folderRepository.saveFolder(
SaveFolderInput(uri = folder.uri, name = folder.name, exists = true),
parentResourceId = parentResourceId,
@@ -91,7 +105,9 @@ class DeviceSync @Inject constructor(
}
for (folder in folders) {
val folderResourceId = resourceIdByUri[folder.uri] ?: root.resourceId
// Dossier ignoré plus haut (parent manquant) : ses fichiers ne
// sont pas rattachés à la racine, ils attendent le walk suivant.
val folderResourceId = resourceIdByUri[folder.uri] ?: continue
for (file in folder.files) {
seen += file.uri
fileRepository.saveLocalFile(
@@ -17,6 +17,7 @@ import com.kazier.mobile.auth.TokenProvider
import com.kazier.mobile.data.local.dao.FileDao
import com.kazier.mobile.data.local.dao.FolderDao
import com.kazier.mobile.data.local.dao.PendingOperationDao
import com.kazier.mobile.data.local.entity.PendingOpStatus
import com.kazier.mobile.data.local.entity.PendingOperationEntity
import com.kazier.mobile.data.local.entity.PendingOperationType
import com.kazier.mobile.data.remote.ApiClient
@@ -25,9 +26,43 @@ import com.kazier.mobile.data.remote.dto.SyncOpDto
import com.kazier.mobile.features.ocr.OcrAutoWorker
import dagger.assisted.Assisted
import dagger.assisted.AssistedInject
import java.util.ArrayDeque
import java.util.concurrent.TimeUnit
import timber.log.Timber
/**
* Normalise les nombres d'un payload décodé : Moshi parse tout nombre JSON
* en `Double` dans un `Map<String, Any?>` — les entiers (ex. `expiresAt` en
* ms) doivent repartir comme entiers exacts, sinon le serveur refuse
* `1.7E12` (M24). Récursif (maps/listes imbriquées).
*/
internal fun normalizePayloadNumbers(payload: Map<String, Any?>): Map<String, Any?> =
payload.mapValues { (_, value) -> normalizePayloadValue(value) }
private fun normalizePayloadValue(value: Any?): Any? = when (value) {
is Double ->
if (value % 1.0 == 0.0 && value >= Long.MIN_VALUE.toDouble() &&
value <= Long.MAX_VALUE.toDouble()
) {
value.toLong()
} else {
value
}
is Float ->
if (value % 1f == 0f && value >= Long.MIN_VALUE.toFloat() &&
value <= Long.MAX_VALUE.toFloat()
) {
value.toLong()
} else {
value
}
is Map<*, *> ->
@Suppress("UNCHECKED_CAST")
normalizePayloadNumbers(value as Map<String, Any?>)
is List<*> -> value.map { normalizePayloadValue(it) }
else -> value
}
/**
* Worker de push de l'outbox : applique les batchs `pending_operations` vers
* `POST /sync/ops`, séquentiellement et dans l'ordre d'entrée en file.
@@ -36,12 +71,16 @@ import timber.log.Timber
* - **single-flight** : enregistré via `enqueueUniqueWork(KEEP)` — jamais deux
* workers parallèles (ordonnancement chronologique préservé) ;
* - **no-op sans token** : mode local, rien à pousser (contrat syncOutbox) ;
* - **retry transient** : `NETWORK_ERROR`/5xx/timeout → `Result.retry()`
* (backoff exponentiel) sans bump du compteur d'attempts ;
* - **dead-letter permanent** : erreur 4xx non-idempotente → op passée en
* `failed` immédiatement (évite d'affamer la queue : le serveur s'arrête à
* la 1re erreur), et cascade si `create_resource` a échoué (toutes les ops
* filles en attente sur la même resource passent `failed`) ;
* - **retry transient ou non-attribuable** : `NETWORK_ERROR`/5xx/429/408,
* `INVALID_RESPONSE` et toute erreur batch-level non-401 → `Result.retry()`
* (backoff exponentiel) sans toucher aux ops — la faute ne peut pas être
* imputée à une op du batch, le rejeu est sûr (idempotence serveur) ;
* - **dead-letter permanente** : seule l'erreur par-op (`failed` dans le
* `200`) passe l'op en `failed` immédiatement (évite d'affamer la queue :
* le serveur s'arrête à la 1re erreur) puis **stoppe le run** — jamais de
* batch suivant dans le même run ; si un `create_resource` a échoué, les
* ops filles en attente (même ressource + enfants via
* `payload.parentResourceId`, transitif) passent `failed` ;
* - `attempts` est un compteur diagnostic (incrémenté à chaque dead-letter),
* pas un seuil : une op `failed` n'est plus resélectionnée.
* - push **avant** pull : le pull `GET /sync/permissions` (V2) s'appliquera
@@ -90,26 +129,35 @@ class OutboxSyncWorker @AssistedInject constructor(
apiClient.syncOps(ops)
} catch (e: ApiException) {
when {
e.code == "NETWORK_ERROR" || e.httpCode >= 500 -> {
// Transitoire : on retentera avec backoff, sans bump d'attempts.
return Result.retry()
}
e.httpCode == 401 -> {
// Token expiré/révoqué : le re-login se fera via l'UI.
// Token expiré/révoqué : `onUnauthorized` (scope
// applicatif) a purgé la session. Succès : le re-login
// ré-enqueue le drain (m3).
return Result.success()
}
else -> {
// Erreur permanente : dead-letter la 1re op du batch.
val now = System.currentTimeMillis()
pendingOperationDao.markFailed(pending.first().id, now)
continue
// Transitoire (NETWORK_ERROR/5xx/429/408) ou
// non-attribuable (INVALID_RESPONSE, 4xx batch-level) :
// rejouer avec backoff SANS toucher aux ops. La faute
// ne peut pas être imputée à la 1re op du batch (C2) —
// le rejeu est sûr (idempotence serveur).
return Result.retry()
}
}
}
val now = System.currentTimeMillis()
// Garde C7 : `applied` incohérent → clamp, jamais de crash.
val appliedCount = result.applied.coerceIn(0, pending.size)
if (appliedCount != result.applied) {
Timber.w(
"outbox applied incohérent (%d pour %d ops), clamp",
result.applied,
pending.size,
)
}
// Ops appliquées par le serveur (indices < applied).
for (i in 0 until result.applied) {
for (i in 0 until appliedCount) {
pendingOperationDao.markSynced(pending[i].id, now)
promotePlacement(pending[i])
Timber.d("outbox synced %s", pending[i].operationId)
@@ -118,16 +166,32 @@ class OutboxSyncWorker @AssistedInject constructor(
// Première erreur non-idempotente → dead-letter + cascade éventuelle.
result.failed?.let { fail ->
val failedIndex = pending.indexOfFirst { it.operationId == fail.operationId }
if (failedIndex >= 0) {
val failedOp = pending[failedIndex]
pendingOperationDao.markFailed(failedOp.id, now)
Timber.w("outbox failed %s (%s: %s)", fail.operationId, fail.code, fail.message)
if (failedOp.operation == PendingOperationType.CREATE_RESOURCE) {
failedOp.resourceId?.let { resourceId ->
pendingOperationDao.failDescendants(resourceId, now)
}
if (failedIndex < 0) {
// Garde C7 : `operation_id` inconnu → stop, pas de boucle
// serrée sur le même batch.
Timber.w("outbox failed inconnu %s, arrêt du run", fail.operationId)
return Result.success()
}
val failedOp = pending[failedIndex]
pendingOperationDao.markFailed(failedOp.id, now)
Timber.w("outbox failed %s (%s: %s)", fail.operationId, fail.code, fail.message)
if (failedOp.operation == PendingOperationType.CREATE_RESOURCE) {
failedOp.resourceId?.let { resourceId ->
pendingOperationDao.failDescendants(resourceId, now)
cascadeCreateFailure(resourceId, now)
}
}
// C6 : stop au 1er échec — le serveur s'est arrêté là, tout ce
// qui suit reste pending pour le prochain run (jamais de
// `continue` vers le batch suivant).
return Result.success()
}
// Garde C7 : aucun progrès (`applied == 0`, `failed == null`) →
// sortie, sinon busy-loop sans backoff.
if (appliedCount == 0) {
Timber.w("outbox aucun progrès (applied=0, failed=null), arrêt du run")
return Result.success()
}
// Boucle : d'autres batchs attendent → traité dans le même run.
@@ -158,6 +222,7 @@ class OutboxSyncWorker @AssistedInject constructor(
private fun PendingOperationEntity.toSyncOpDto(): SyncOpDto {
val payloadMap = runCatching { payloadAdapter.fromJson(payload) }.getOrNull()
?.let { normalizePayloadNumbers(it) }
return SyncOpDto(
operationId = operationId,
refType = refType,
@@ -169,10 +234,52 @@ class OutboxSyncWorker @AssistedInject constructor(
)
}
/**
* Invalidation transitive après l'échec d'un `create_resource` : les
* enfants portent un autre `resource_id`, liés via
* `payload.parentResourceId` (le walk émet parent avant enfant). Parcours
* en largeur depuis la ressource fautive sur l'ensemble des ops en
* attente — chaque niveau est invalidé via `failDescendants`.
*/
private suspend fun cascadeCreateFailure(failedResourceId: String, now: Long) {
val visited = mutableSetOf(failedResourceId)
val frontier = ArrayDeque<String>().apply { add(failedResourceId) }
while (frontier.isNotEmpty()) {
val current = frontier.removeFirst()
val children = pendingOperationDao.selectPending(CASCADE_SCAN_LIMIT)
.mapNotNull { op ->
val childId = op.resourceId
if (op.status == PendingOpStatus.PENDING && childId != null &&
childId !in visited && parentResourceIdOf(op) == current
) {
childId
} else {
null
}
}
.distinct()
for (child in children) {
if (visited.add(child)) {
pendingOperationDao.failDescendants(child, now)
frontier.add(child)
}
}
}
}
/** Lien parent→enfant porté par le payload (`create_resource` avec parent). */
private fun parentResourceIdOf(op: PendingOperationEntity): String? =
runCatching { payloadAdapter.fromJson(op.payload) }
.getOrNull()?.get(PARENT_RESOURCE_ID_KEY) as? String
companion object {
const val NAME = "outbox_sync"
private const val BATCH_SIZE = 20
private const val PURGE_AGE_MS = 7 * 24 * 60 * 60 * 1000L
/** Fenêtre de balayage de la cascade (au-delà, convergence au run suivant). */
private const val CASCADE_SCAN_LIMIT = 10_000
/** Clé du lien parent→enfant dans le payload `create_resource`. */
private const val PARENT_RESOURCE_ID_KEY = "parentResourceId"
/**
* Enregistre (idempotent) le worker avec contrainte réseau + backoff.
@@ -9,6 +9,7 @@ import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ensureActive
import kotlinx.coroutines.withContext
import kotlinx.coroutines.yield
import timber.log.Timber
import javax.inject.Inject
import javax.inject.Singleton
@@ -51,7 +52,9 @@ class SafScanner @Inject constructor(
/** Marche la racine `treeUri` ; renvoie tous les dossiers en ordre préfixe (DFS). */
suspend fun scanTree(treeUri: Uri): List<FolderNode> = withContext(Dispatchers.IO) {
val rootDocId = DocumentsContract.getTreeDocumentId(treeUri)
val rootDocId = runCatching { DocumentsContract.getTreeDocumentId(treeUri) }
.onFailure { Timber.w(it, "scanTree: treeUri illisible %s", treeUri) }
.getOrNull() ?: return@withContext emptyList()
val root = ScanFolder(
uri = treeUri.toString(),
docId = rootDocId,
@@ -110,52 +113,64 @@ class SafScanner @Inject constructor(
val folders = ArrayList<ChildDir>()
val files = ArrayList<FileNode>()
resolver.query(
childrenUri,
arrayOf(
DocumentsContract.Document.COLUMN_DOCUMENT_ID,
DocumentsContract.Document.COLUMN_DISPLAY_NAME,
DocumentsContract.Document.COLUMN_MIME_TYPE,
DocumentsContract.Document.COLUMN_SIZE,
DocumentsContract.Document.COLUMN_LAST_MODIFIED,
),
null,
null,
"${DocumentsContract.Document.COLUMN_DISPLAY_NAME} ASC",
)?.use { cursor ->
val iDoc = cursor.getColumnIndex(DocumentsContract.Document.COLUMN_DOCUMENT_ID)
val iName = cursor.getColumnIndex(DocumentsContract.Document.COLUMN_DISPLAY_NAME)
val iMime = cursor.getColumnIndex(DocumentsContract.Document.COLUMN_MIME_TYPE)
val iSize = cursor.getColumnIndex(DocumentsContract.Document.COLUMN_SIZE)
val iLast = cursor.getColumnIndex(DocumentsContract.Document.COLUMN_LAST_MODIFIED)
// Permission révoquée / provider KO : dossier vu vide, jamais de crash
// (le walk réessaiera au prochain tick, la réconciliation ne supprime rien).
runCatching {
resolver.query(
childrenUri,
arrayOf(
DocumentsContract.Document.COLUMN_DOCUMENT_ID,
DocumentsContract.Document.COLUMN_DISPLAY_NAME,
DocumentsContract.Document.COLUMN_MIME_TYPE,
DocumentsContract.Document.COLUMN_SIZE,
DocumentsContract.Document.COLUMN_LAST_MODIFIED,
),
null,
null,
"${DocumentsContract.Document.COLUMN_DISPLAY_NAME} ASC",
)?.use { cursor ->
val iDoc = cursor.getColumnIndex(DocumentsContract.Document.COLUMN_DOCUMENT_ID)
// Curseur dégénéré (colonne DOCUMENT_ID absente) : dossier vu
// vide plutôt que crash de tout le walk.
if (iDoc < 0) return@use
val iName = cursor.getColumnIndex(DocumentsContract.Document.COLUMN_DISPLAY_NAME)
val iMime = cursor.getColumnIndex(DocumentsContract.Document.COLUMN_MIME_TYPE)
val iSize = cursor.getColumnIndex(DocumentsContract.Document.COLUMN_SIZE)
val iLast = cursor.getColumnIndex(DocumentsContract.Document.COLUMN_LAST_MODIFIED)
while (cursor.moveToNext()) {
val docId = cursor.getString(iDoc)
if (docId == dirDocId) continue // certains providers renvoient le dossier lui-même
val name = if (iName >= 0) cursor.getString(iName)
else docId.substringAfterLast('/')
val mime = if (iMime >= 0) cursor.getString(iMime) else null
while (cursor.moveToNext()) {
val docId = if (!cursor.isNull(iDoc)) cursor.getString(iDoc) else null
if (docId.isNullOrEmpty()) continue
if (docId == dirDocId) continue // certains providers renvoient le dossier lui-même
var name = if (iName >= 0 && !cursor.isNull(iName)) cursor.getString(iName) else null
if (name.isNullOrEmpty()) name = docId.substringAfterLast('/')
if (name.isNullOrEmpty()) continue
val mime = if (iMime >= 0 && !cursor.isNull(iMime)) cursor.getString(iMime) else null
if (name.startsWith(".")) continue
if (name.startsWith(".")) continue
if (mime == DocumentsContract.Document.MIME_TYPE_DIR) {
val uri = DocumentsContract.buildDocumentUriUsingTree(treeUri, docId).toString()
folders += ChildDir(docId, uri, name)
} else {
val size = if (iSize >= 0 && !cursor.isNull(iSize)) cursor.getLong(iSize) else 0L
if (size == 0L) continue
if (KNOWN_NOISE_EXTENSIONS.any { name.endsWith(it, ignoreCase = true) }) continue
if (mime == DocumentsContract.Document.MIME_TYPE_DIR) {
val uri = DocumentsContract.buildDocumentUriUsingTree(treeUri, docId).toString()
folders += ChildDir(docId, uri, name)
} else {
val size = if (iSize >= 0 && !cursor.isNull(iSize)) cursor.getLong(iSize) else 0L
// Les fichiers 0-octet sont des documents légitimes
// (notes vides, exports) : importés et reviewés comme les autres.
if (KNOWN_NOISE_EXTENSIONS.any { name.endsWith(it, ignoreCase = true) }) continue
val uri = DocumentsContract.buildDocumentUriUsingTree(treeUri, docId).toString()
files += FileNode(
uri = uri,
name = name,
size = size,
mimeType = mime,
lastModified = if (iLast >= 0 && !cursor.isNull(iLast)) cursor.getLong(iLast) else null,
)
val uri = DocumentsContract.buildDocumentUriUsingTree(treeUri, docId).toString()
files += FileNode(
uri = uri,
name = name,
size = size,
mimeType = mime,
lastModified = if (iLast >= 0 && !cursor.isNull(iLast)) cursor.getLong(iLast) else null,
)
}
}
}
}.onFailure { e ->
Timber.w(e, "scanTree: listing impossible pour %s", dirDocId)
}
return DirContents(folders, files)
}
@@ -54,6 +54,19 @@ class ThumbnailStore @Inject constructor(
internal fun thumbnailFile(resourceId: String): File =
File(dir(), "$resourceId.webp")
/**
* Fichier cible versionné `mtime + taille` de la source : après une
* édition rapide (mtime SAF à la seconde près), la taille différente
* invalide l'ancien fichier même si les mtime coïncident.
*/
internal fun thumbnailFile(resourceId: String, lastModified: Long?, size: Long?): File {
if (lastModified == null || size == null) return thumbnailFile(resourceId)
return File(dir(), "${resourceId}_${lastModified}_${size}.webp")
}
/** Nombre de verrous single-flight en cours (diagnostic/tests). */
internal fun lockCount(): Int = locks.size
/**
* Vignette du fichier, générée si absente ou périmée. `null` si le fichier
* n'est ni image ni PDF, n'a pas d'uri, ou si la génération échoue
@@ -64,24 +77,57 @@ class ThumbnailStore @Inject constructor(
val category = file.categoryValue()
if (category != FileCategory.IMAGE && category != FileCategory.PDF) return null
val target = thumbnailFile(file.resourceId)
val target = thumbnailFile(file.resourceId, file.lastModified, file.size)
if (isUpToDate(target, file.lastModified)) return target
// Ancienne version (legacy ou mtime/taille précédents) encore fraîche.
val legacy = thumbnailFile(file.resourceId)
if (legacy != target && isUpToDate(legacy, file.lastModified)) return legacy
val lock = locks.getOrPut(file.resourceId) { Mutex() }
return lock.withLock {
if (isUpToDate(target, file.lastModified)) target
else generateInto(context.contentResolver, uri, category, target)
try {
return lock.withLock {
if (isUpToDate(target, file.lastModified)) {
target
} else if (legacy != target && isUpToDate(legacy, file.lastModified)) {
legacy
} else {
generateInto(context.contentResolver, uri, category, target)?.also { generated ->
pruneSiblings(file.resourceId, keep = generated)
}
}
}
} finally {
// Pas de fuite lente : le Mutex est retiré dès la fin (un appelant
// arrivé entre-temps garde sa propre référence, toujours valide).
locks.remove(file.resourceId, lock)
}
}
/** Purge la vignette d'une resource (delete physique) — best-effort. */
/** Purge toutes les vignettes d'une resource (toutes versions + tmp). */
fun delete(resourceId: String) {
runCatching { thumbnailFile(resourceId).delete() }
runCatching {
dir().listFiles { f -> isOwnedThumb(resourceId, f.name) }
?.forEach { it.delete() }
}
}
/** Cache-hit : fichier présent et au moins aussi récent que la source. */
/** Fichier possédé par une resource : version courante, legacy ou tmp. */
private fun isOwnedThumb(resourceId: String, name: String): Boolean {
if (name == "$resourceId.webp") return true
if (name.startsWith(resourceId + "_") && name.endsWith(".webp")) return true
if (name.startsWith(resourceId) && name.endsWith(".tmp")) return true
return false
}
/** Supprime les versions périmées et les `.tmp` orphelins (génération OK). */
private fun pruneSiblings(resourceId: String, keep: File) {
dir().listFiles { f -> f != keep && isOwnedThumb(resourceId, f.name) }
?.forEach { runCatching { it.delete() } }
}
/** Cache-hit : fichier présent, non vide, et au moins aussi récent que la source. */
internal fun isUpToDate(target: File, lastModified: Long?): Boolean {
if (!target.isFile) return false
if (!target.isFile || target.length() == 0L) return false
if (lastModified == null) return true
return target.lastModified() >= lastModified
}
@@ -99,9 +145,9 @@ class ThumbnailStore @Inject constructor(
else -> null
}
bitmap ?: return@withContext null
val tmp = File(target.parentFile, "${target.name}.tmp")
try {
dir().mkdirs()
val tmp = File(target.parentFile, "${target.name}.tmp")
val ok = tmp.outputStream().use { out ->
bitmap.compress(Bitmap.CompressFormat.WEBP, WEBP_QUALITY, out)
}
@@ -109,10 +155,15 @@ class ThumbnailStore @Inject constructor(
// La source a bougé pendant notre génération : on garde la dernière.
target.delete()
}
if (ok && tmp.renameTo(target)) target else null
// Échec de renommage : pas de `.tmp` orphelin, pas de cible
// touchée (une version concurrente fraîche reste en place).
if (ok && tmp.renameTo(target)) target else {
runCatching { tmp.delete() }
null
}
} catch (e: Exception) {
Timber.w(e, "thumbnail write failed for $uri")
runCatching { target.delete() }
runCatching { tmp.delete() }
null
} finally {
bitmap.recycle()
@@ -121,7 +172,11 @@ class ThumbnailStore @Inject constructor(
/** Image : décodage en `inSampleSize` pour ne jamais matérialiser le full-res. */
private fun decodeImage(resolver: ContentResolver, uri: String): Bitmap? {
val stream = DocumentContent.openInputStream(resolver, uri) ?: return null
// Le provider peut lever à l'ouverture (permission révoquée, fichier
// absent) : échec de génération, jamais de crash (même contrat que le
// walk SAF face aux providers dégénérés).
val stream = runCatching { DocumentContent.openInputStream(resolver, uri) }.getOrNull()
?: return null
return try {
// Première passe : dimensions seulement, sans décodage pixels.
val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
@@ -4,7 +4,6 @@ import android.content.Context
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.kazier.mobile.auth.SessionManager
import com.kazier.mobile.data.remote.ApiClient
import com.kazier.mobile.data.remote.ApiException
import com.kazier.mobile.data.repository.AuthRepository
import com.kazier.mobile.data.repository.ShareRepository
@@ -26,7 +25,6 @@ import javax.inject.Inject
class AuthViewModel @Inject constructor(
private val authRepository: AuthRepository,
private val sessionManager: SessionManager,
private val apiClient: ApiClient,
private val shareRepository: ShareRepository,
@ApplicationContext private val appContext: Context,
) : ViewModel() {
@@ -38,10 +36,8 @@ class AuthViewModel @Inject constructor(
val loginUiState: StateFlow<LoginUiState> = _loginUiState.asStateFlow()
init {
// 401 sur un endpoint protégé (token expiré/révoqué, compte supprimé)
// → purge de la session. Le 401 du login est exonéré (skip dans ApiClient).
apiClient.onUnauthorized = { signOut() }
// Le 401 est géré par SessionManager (singleton) — jamais ici (M25) :
// ce callback survivrait sinon à onCleared et figerait l'outbox.
viewModelScope.launch {
val session = sessionManager.restore()
_authState.value = when {
@@ -70,7 +66,7 @@ class AuthViewModel @Inject constructor(
_loginUiState.update { LoginUiState(isSubmitting = true) }
runCatching { authRepository.login(username, password) }
.onSuccess { response ->
sessionManager.save(response.token, response.user)
sessionManager.save(response.token, response.user, response.expiresAt)
_loginUiState.value = LoginUiState()
_authState.value = AuthState.SignedIn(response.user)
// Connexion réussie → pousser les mutations locales en attente.
@@ -119,8 +115,4 @@ class AuthViewModel @Inject constructor(
_authState.value = AuthState.SignedOut
}
}
override fun onCleared() {
apiClient.onUnauthorized = null
}
}
@@ -18,7 +18,7 @@ import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
@@ -126,7 +126,7 @@ fun SyncStatusAction(
modifier: Modifier = Modifier,
) {
val status by syncViewModel.syncStatus.collectAsStateWithLifecycle()
var showList by remember { mutableStateOf(false) }
var showList by rememberSaveable { mutableStateOf(false) }
SyncStatusBadge(
status = status,
@@ -126,20 +126,38 @@ fun DocumentViewerScreen(
val connectionStatus by connectionStatusViewModel.status.collectAsStateWithLifecycle()
val pagerState = rememberPagerState(pageCount = { documents.size })
// Démarre une seule fois sur le document demandé, dès que la liste est chargée.
var jumpPending by remember { mutableStateOf(true) }
// M30 : survit à la rotation (`rememberSaveable`) — `savedPage` mémorise
// l'index courant pour y revenir au lieu de retomber sur le document initial.
var jumpPending by rememberSaveable { mutableStateOf(true) }
var savedPage by rememberSaveable { mutableIntStateOf(-1) }
// Vrai dès qu'une liste non vide a été vue dans cette composition : garde
// contre un `onBack` intempestif pendant le (re)chargement initial.
var hadDocuments by remember { mutableStateOf(false) }
LaunchedEffect(documents) {
if (documents.isNotEmpty()) hadDocuments = true
if (jumpPending) {
// Démarre une seule fois sur le document demandé, dès que la liste est chargée.
val index = documents.indexOfFirst { it.resourceId == initialResourceId }
if (index >= 0) {
pagerState.scrollToPage(index)
savedPage = index
jumpPending = false
}
} else if (documents.isEmpty()) {
// Dernier document supprimé : plus rien à afficher → retour.
onBack()
if (shouldExitViewer(jumpPending, hadDocuments, documents.isEmpty())) onBack()
} else {
// M35 : clamp après suppression (ex. page 2/2 supprimée) +
// restauration de la page mémorisée après rotation.
val target = resolveViewerPage(pagerState.currentPage, savedPage, documents.size)
savedPage = target
if (target != pagerState.currentPage) pagerState.scrollToPage(target)
}
}
// Suit le swipe utilisateur pour mémoriser la page courante (rotation).
LaunchedEffect(pagerState.currentPage) {
if (!jumpPending) savedPage = pagerState.currentPage
}
val currentFile = documents.getOrNull(pagerState.currentPage)
@@ -180,7 +198,7 @@ fun DocumentViewerScreen(
// Confirmation avant suppression d'un document déjà traité.
var pendingDeleteMode by remember { mutableStateOf<FileDeleter.DeleteMode?>(null) }
var showDeleteConfirm by remember { mutableStateOf(false) }
var showDeleteConfirm by rememberSaveable { mutableStateOf(false) }
var fullscreen by rememberSaveable { mutableStateOf(false) }
val canFullscreen = currentFile?.canFocus() == true
@@ -894,6 +912,29 @@ private fun fileTypeLabel(file: FileEntity): String =
?: file.mimeType?.uppercase(Locale.getDefault())
?: "—"
/**
* Page cible du pager après évolution de la liste (rotation, suppression).
*
* - `restoredPage` (mémorisée, `rememberSaveable`) prime si elle reste valide
* → retour à la page lue avant rotation (M30) ;
* - sinon la page courante est clampée aux bornes (M35 : suppression du
* dernier document → retombe sur le précédent au lieu d'une page vide).
*/
internal fun resolveViewerPage(currentPage: Int, restoredPage: Int, itemCount: Int): Int {
if (itemCount <= 0) return 0
val lastIndex = itemCount - 1
if (restoredPage in 0..lastIndex) return restoredPage
return currentPage.coerceIn(0, lastIndex)
}
/**
* Retour arrière uniquement quand une liste a déjà été vue dans cette
* composition puis vidée hors saut initial : le vide transitoire du
* (re)chargement — y compris après rotation — ne quitte jamais l'écran.
*/
internal fun shouldExitViewer(jumpPending: Boolean, hadDocuments: Boolean, isEmpty: Boolean): Boolean =
!jumpPending && hadDocuments && isEmpty
/** Vrai si le fichier est local et appartient à une catégorie consultable en mode focus. */
private fun FileEntity.canFocus(): Boolean =
uri != null && categoryValue() in FOCUS_CATEGORIES
@@ -39,6 +39,7 @@ import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
@@ -69,6 +70,8 @@ import com.kazier.mobile.ui.components.DeleteReview
import com.kazier.mobile.ui.components.DeleteWarningDialog
import com.kazier.mobile.ui.components.reviewDelete
import com.kazier.mobile.ui.navigation.SelectionNavBar
import com.kazier.mobile.ui.auth.AuthState
import com.kazier.mobile.ui.auth.AuthViewModel
import com.kazier.mobile.ui.share.ShareBottomSheet
import com.kazier.mobile.ui.share.ShareViewModel
import java.util.Locale
@@ -83,24 +86,31 @@ fun FolderDetailScreen(
onBuildPdf: (List<String>) -> Unit,
connectionStatusViewModel: ConnectionStatusViewModel,
syncViewModel: SyncViewModel,
authViewModel: AuthViewModel,
viewModel: FolderDetailViewModel = hiltViewModel(),
shareViewModel: ShareViewModel = hiltViewModel(),
) {
val uiState by viewModel.uiState.collectAsStateWithLifecycle()
val authState by authViewModel.authState.collectAsStateWithLifecycle()
val connectionStatus by connectionStatusViewModel.status.collectAsStateWithLifecycle()
val shareState by shareViewModel.uiState.collectAsStateWithLifecycle()
val selection = rememberSelectionState()
var showCreateDialog by remember { mutableStateOf(false) }
var showMoveDialog by remember { mutableStateOf(false) }
var showDeleteWarning by remember { mutableStateOf(false) }
var showDeleteConfirm by remember { mutableStateOf(false) }
var showShareSheet by remember { mutableStateOf(false) }
var showMoreMenu by remember { mutableStateOf(false) }
var showCreateDialog by rememberSaveable { mutableStateOf(false) }
var showMoveDialog by rememberSaveable { mutableStateOf(false) }
var showDeleteWarning by rememberSaveable { mutableStateOf(false) }
var showDeleteConfirm by rememberSaveable { mutableStateOf(false) }
var showShareSheet by rememberSaveable { mutableStateOf(false) }
var showMoreMenu by rememberSaveable { mutableStateOf(false) }
var pendingDeleteMode by remember { mutableStateOf<FileDeleter.DeleteMode?>(null) }
var pendingDeleteReview by remember { mutableStateOf<DeleteReview?>(null) }
val snackbarHostState = remember { SnackbarHostState() }
val deletedLabel = stringResource(R.string.delete)
// M33 : le gate `canShare` dépend du token — recalculé au login/logout.
LaunchedEffect(authState) {
if (authState != AuthState.Loading) viewModel.refreshShareGate()
}
LaunchedEffect(uiState.folderMissing) {
if (uiState.folderMissing) onBack()
}
@@ -195,6 +205,10 @@ fun FolderDetailScreen(
) {
DropdownMenuItem(
text = { Text(stringResource(R.string.share_action)) },
// M32 : même gate que FolderList — un dossier
// local-only/reçu partage sans ce gate voue
// l'op `share` au dead-letter NOT_FOUND.
enabled = uiState.canShare,
onClick = {
showMoreMenu = false
showShareSheet = true
@@ -11,6 +11,7 @@ import com.kazier.mobile.data.local.entity.FolderEntity
import com.kazier.mobile.data.repository.FileRepository
import com.kazier.mobile.data.repository.FolderRepository
import com.kazier.mobile.data.repository.SaveFolderInput
import com.kazier.mobile.domain.DeviceIdentity
import com.kazier.mobile.features.saf.FileDeleter
import com.kazier.mobile.features.saf.FileMover
import com.kazier.mobile.features.saf.SafFolderCreator
@@ -40,6 +41,8 @@ data class FolderDetailUiState(
val deleteError: String? = null,
/** Succès transitoire de suppression — affiché en Snackbar puis effacé. */
val deleteSuccess: Boolean = false,
/** Le dossier courant peut être partagé (connecté + possédé, cf. FolderList). */
val canShare: Boolean = false,
)
@HiltViewModel
@@ -51,6 +54,7 @@ class FolderDetailViewModel @Inject constructor(
private val safFolderCreator: SafFolderCreator,
private val fileMover: FileMover,
private val fileDeleter: FileDeleter,
private val deviceIdentity: DeviceIdentity,
@ApplicationContext private val context: Context,
) : ViewModel() {
@@ -70,6 +74,7 @@ class FolderDetailViewModel @Inject constructor(
return@launch
}
_uiState.value = _uiState.value.copy(folder = folder)
refreshShareGate()
}
viewModelScope.launch {
@@ -141,6 +146,21 @@ class FolderDetailViewModel @Inject constructor(
_uiState.update { it.copy(createError = null) }
}
/**
* Gate de partage du dossier courant (M32, même règle que FolderList) :
* connecté et dossier possédé (pas une ressource reçue en partage), sinon
* l'op `share` serait dead-letter `NOT_FOUND` côté serveur.
*/
fun refreshShareGate() {
viewModelScope.launch {
val folder = _uiState.value.folder
val shareable = folder != null &&
tokenProvider.current != null &&
(folder.ownerId == null || folder.ownerId == deviceIdentity.getOrCreate())
_uiState.update { it.copy(canShare = shareable) }
}
}
/** Charge les dossiers éligibles à recevoir les fichiers sélectionnés. */
fun loadMoveFolders() {
viewModelScope.launch {
@@ -62,6 +62,7 @@ import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
@@ -105,6 +106,8 @@ import com.kazier.mobile.ui.navigation.FolderSelectionNavBar
import com.kazier.mobile.ui.navigation.MoveTargetBar
import com.kazier.mobile.ui.navigation.NavTab
import com.kazier.mobile.ui.navigation.SelectionNavBar
import com.kazier.mobile.ui.auth.AuthState
import com.kazier.mobile.ui.auth.AuthViewModel
import com.kazier.mobile.ui.share.ShareBottomSheet
import com.kazier.mobile.ui.share.ShareViewModel
import kotlinx.coroutines.delay
@@ -127,9 +130,11 @@ fun FolderListScreen(
onOpenScan: () -> Unit,
syncViewModel: SyncViewModel,
connectionStatusViewModel: ConnectionStatusViewModel,
authViewModel: AuthViewModel,
viewModel: FolderListViewModel = hiltViewModel(),
) {
val uiState by viewModel.uiState.collectAsStateWithLifecycle()
val authState by authViewModel.authState.collectAsStateWithLifecycle()
val shareViewModel: ShareViewModel = hiltViewModel()
val shareState by shareViewModel.uiState.collectAsStateWithLifecycle()
val importState by syncViewModel.importState.collectAsStateWithLifecycle()
@@ -137,20 +142,27 @@ fun FolderListScreen(
val defaultRootId by viewModel.defaultRootId.collectAsStateWithLifecycle()
val context = LocalContext.current
val selection = rememberSelectionState()
var showCreateDialog by remember { mutableStateOf(false) }
var showDeleteWarning by remember { mutableStateOf(false) }
var showDeleteConfirm by remember { mutableStateOf(false) }
var showCreateDialog by rememberSaveable { mutableStateOf(false) }
var showDeleteWarning by rememberSaveable { mutableStateOf(false) }
var showDeleteConfirm by rememberSaveable { mutableStateOf(false) }
var pendingDeleteMode by remember { mutableStateOf<FileDeleter.DeleteMode?>(null) }
var pendingDeleteReview by remember { mutableStateOf<DeleteReview?>(null) }
var pendingFolderIds by remember { mutableStateOf<List<String>>(emptyList()) }
var pendingFileIds by remember { mutableStateOf<List<String>>(emptyList()) }
var shareTarget by remember { mutableStateOf<ShareTarget?>(null) }
var showShareMenu by remember { mutableStateOf(false) }
var showShareMenu by rememberSaveable { mutableStateOf(false) }
var shareEnabled by remember { mutableStateOf(false) }
var showCreateMenu by remember { mutableStateOf(false) }
var showNoteDialog by remember { mutableStateOf(false) }
var showCreateMenu by rememberSaveable { mutableStateOf(false) }
var showNoteDialog by rememberSaveable { mutableStateOf(false) }
val snackbarHostState = remember { SnackbarHostState() }
// Le gate `canShare` est calculé côté VM sur la cible courante ; le token
// n'y est lu qu'à ce moment-là (M33) : le login/logout depuis les Réglages
// doit donc le recalculer explicitement.
LaunchedEffect(authState) {
if (authState != AuthState.Loading) viewModel.refreshShareGate()
}
// Le partage multi-sélection ne vaut que pour un dossier unique sélectionné,
// possédé et déjà poussé au serveur (sinon dead-letter NOT_FOUND côté serveur).
LaunchedEffect(uiState.browseSubFolders, selection.ids) {
@@ -197,9 +209,11 @@ fun FolderListScreen(
}
// Racine par défaut : dossier Kazier choisi au premier lancement.
// `rememberSaveable` (M29) : après rotation, le polling reprend au lieu de
// rester figé sur l'onboarding pendant que l'import continue en fond.
val defaultRootLabel = stringResource(R.string.default_root_folder_label)
val folderLabel = stringResource(R.string.folder)
var pendingDefaultPick by remember { mutableStateOf<Uri?>(null) }
var pendingDefaultPick by rememberSaveable { mutableStateOf<Uri?>(null) }
val pickDefaultRootLauncher = rememberLauncherForActivityResult(
ActivityResultContracts.OpenDocumentTree(),
) { uri: Uri? ->
@@ -387,6 +401,8 @@ fun FolderListScreen(
val allFiles = uiState.sections.flatMap { section ->
section.rows.flatMap { row -> listOfNotNull(row.left, row.right) }
}
// M34 : on ne supprime que les fichiers visibles —
// la sélection ne survit pas à la navigation.
val selectedFiles = allFiles.filter { it.resourceId in selection.ids }
pendingFolderIds = emptyList()
pendingFileIds = selectedFiles.map { it.resourceId }
@@ -467,8 +483,14 @@ fun FolderListScreen(
isImporting = importState.isImporting,
error = uiState.error ?: importState.error,
selection = selection,
onBrowseUp = viewModel::browseUp,
onOpenBrowseFolder = viewModel::openBrowseFolder,
// M34 : la sélection ne suit pas la navigation — changer de
// dossier l'abandonne (sauf en mode déplacement où la sélection
// est justement ce qu'on déplace).
onBrowseUp = { if (!uiState.moveMode) selection.clear(); viewModel.browseUp() },
onOpenBrowseFolder = { id ->
if (!uiState.moveMode) selection.clear()
viewModel.openBrowseFolder(id)
},
onCreateFolder = { showCreateDialog = true },
onOpenDocument = onOpenDocument,
modifier = Modifier.weight(1f),
@@ -519,7 +541,6 @@ fun FolderListScreen(
count = pendingFolderIds.size + pendingFileIds.size,
onConfirm = {
val mode = pendingDeleteMode!!
val fileIds = selection.ids.toList()
selection.clear()
showDeleteConfirm = false
pendingDeleteMode = null
@@ -527,7 +548,7 @@ fun FolderListScreen(
if (uiState.view == HomeView.FOLDERS) {
viewModel.deleteFolderSelection(pendingFolderIds, pendingFileIds, mode)
} else {
viewModel.deleteSelectedFiles(fileIds, mode)
viewModel.deleteSelectedFiles(pendingFileIds, mode)
}
pendingFolderIds = emptyList()
pendingFileIds = emptyList()
@@ -1172,8 +1193,8 @@ private fun NoteDialog(
onDismiss: () -> Unit,
onConfirm: (title: String, body: String) -> Unit,
) {
var title by remember { mutableStateOf("") }
var body by remember { mutableStateOf("") }
var title by rememberSaveable { mutableStateOf("") }
var body by rememberSaveable { mutableStateOf("") }
AlertDialog(
onDismissRequest = onDismiss,
title = { Text(stringResource(R.string.note_dialog_title)) },
@@ -165,14 +165,29 @@ class FolderListViewModel @Inject constructor(
viewModelScope.launch {
_defaultRootId.combine(_browseFolderId) { root, browse -> browse ?: root }
.collect { targetId ->
val shareable = targetId != null &&
tokenProvider.current != null &&
folderRepository.getFolder(targetId)?.let { isShareable(it) } == true
_uiState.update { it.copy(canShare = shareable) }
_uiState.update { it.copy(canShare = isShareableTarget(targetId)) }
}
}
}
/**
* Recalcule le gate de partage du dossier courant (M33) : le token est lu
* à l'appel, mais le collect ci-dessus ne se réveille qu'au changement de
* cible — le login/logout depuis les Réglages doit donc déclencher ce
* rafraîchissement explicite (appelé par l'écran sur changement d'auth).
*/
fun refreshShareGate() {
viewModelScope.launch {
val targetId = _browseFolderId.value ?: _defaultRootId.value
_uiState.update { it.copy(canShare = isShareableTarget(targetId)) }
}
}
private suspend fun isShareableTarget(targetId: String?): Boolean =
targetId != null &&
tokenProvider.current != null &&
folderRepository.getFolder(targetId)?.let { isShareable(it) } == true
/**
* Un dossier est partageable quand l'utilisateur est connecté et que ce
* n'est pas une ressource reçue en partage : `ownerId` absent ou égal à
@@ -11,6 +11,7 @@ import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.hilt.navigation.compose.hiltViewModel
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.navigation.compose.rememberNavController
import com.kazier.mobile.features.connection.ConnectionStatusViewModel
import com.kazier.mobile.features.sync.SyncViewModel
import com.kazier.mobile.ui.auth.AuthState
@@ -40,6 +41,10 @@ fun KazierApp(
) {
val authState by authViewModel.authState.collectAsStateWithLifecycle()
// m31 : un seul controller pour les deux branches — `signOutToLocal()`
// ne perd plus la position d'exploration.
val navController = rememberNavController()
// Une fois la session résolue, lancer les boucles de fond (idempotentes).
LaunchedEffect(authState) {
if (authState != AuthState.Loading) {
@@ -55,11 +60,13 @@ fun KazierApp(
authViewModel = authViewModel,
syncViewModel = syncViewModel,
connectionStatusViewModel = connectionStatusViewModel,
navController = navController,
)
is AuthState.SignedIn -> NavGraph(
authViewModel = authViewModel,
syncViewModel = syncViewModel,
connectionStatusViewModel = connectionStatusViewModel,
navController = navController,
)
}
}
@@ -2,20 +2,17 @@ package com.kazier.mobile.ui.navigation
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.material3.LinearProgressIndicator
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.navigation.NavGraph.Companion.findStartDestination
import androidx.navigation.NavHostController
import androidx.navigation.NavType
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.currentBackStackEntryAsState
import androidx.navigation.compose.rememberNavController
import androidx.navigation.navArgument
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import com.kazier.mobile.features.connection.ConnectionStatusViewModel
import com.kazier.mobile.features.sync.SyncViewModel
import com.kazier.mobile.ui.auth.AuthViewModel
@@ -47,7 +44,25 @@ object Routes {
fun folder(folderResourceId: String): String = "folder/$folderResourceId"
fun document(documentResourceId: String): String = "document/$documentResourceId"
fun pdfBuilder(resourceIds: List<String>): String = "pdfbuilder/${resourceIds.joinToString(",")}"
/**
* m29 : jamais de route `"pdfbuilder/"` vide (ne matche pas
* `"pdfbuilder/{ids}"`) — une sélection vide donne le sentinelle
* `"empty"`, re-parsé en liste vide par [parseBuilderIds].
*/
fun pdfBuilder(resourceIds: List<String>): String {
val ids = resourceIds.filter { it.isNotBlank() }
if (ids.isEmpty()) return "pdfbuilder/$BUILDER_EMPTY"
return "pdfbuilder/${ids.joinToString(",")}"
}
internal const val BUILDER_EMPTY = "empty"
/** Inverse de [pdfBuilder] : sentinelle et blancs → liste vide. */
fun parseBuilderIds(arg: String?): List<String> {
if (arg.isNullOrBlank() || arg == BUILDER_EMPTY) return emptyList()
return arg.split(",").filter { it.isNotBlank() }
}
}
private fun String?.toNavTab(): NavTab = when (this) {
@@ -63,14 +78,13 @@ fun NavGraph(
authViewModel: AuthViewModel,
syncViewModel: SyncViewModel,
connectionStatusViewModel: ConnectionStatusViewModel,
// m31 : controller hoisté par KazierApp — une seule instance pour les
// branches SignedIn↔Local, la position d'exploration survit au sign-out.
navController: NavHostController = rememberNavController(),
) {
val navController = rememberNavController()
val backStackEntry by navController.currentBackStackEntryAsState()
val selectedTab = backStackEntry?.destination?.route.toNavTab()
val importState by syncViewModel.importState.collectAsStateWithLifecycle()
val onOpenWatchedFolders = { navController.navigate(Routes.WATCHED_FOLDERS) }
val onTabSelected: (NavTab) -> Unit = { tab ->
@@ -100,6 +114,7 @@ fun NavGraph(
onOpenScan = { navController.navigate(Routes.SCAN) },
syncViewModel = syncViewModel,
connectionStatusViewModel = connectionStatusViewModel,
authViewModel = authViewModel,
)
}
composable(Routes.SEARCH) {
@@ -162,11 +177,17 @@ fun NavGraph(
FolderDetailScreen(
folderResourceId = folderId,
onBack = { navController.popBackStack() },
onOpenFolder = { id -> navController.navigate(Routes.folder(id)) },
// m30 : launchSingleTop — un double-tap ne duplique plus la pile.
onOpenFolder = { id ->
navController.navigate(Routes.folder(id)) {
launchSingleTop = true
}
},
onOpenDocument = { id -> navController.navigate(Routes.document(id)) },
onBuildPdf = { ids -> navController.navigate(Routes.pdfBuilder(ids)) },
connectionStatusViewModel = connectionStatusViewModel,
syncViewModel = syncViewModel,
authViewModel = authViewModel,
)
}
composable(
@@ -191,11 +212,9 @@ fun NavGraph(
navArgument(Routes.ARG_BUILDER_IDS) { type = NavType.StringType },
),
) { backStackEntry ->
val ids = backStackEntry.arguments
?.getString(Routes.ARG_BUILDER_IDS)
.orEmpty()
.split(",")
.filter { it.isNotBlank() }
val ids = Routes.parseBuilderIds(
backStackEntry.arguments?.getString(Routes.ARG_BUILDER_IDS),
)
PdfBuilderScreen(
initialResourceIds = ids,
onBack = { navController.popBackStack() },
@@ -207,15 +226,5 @@ fun NavGraph(
)
}
}
// Bandeau global : visible sur tous les onglets tant qu'un import SAF
// est en cours (indique que la marche continue hors écran Fichiers).
if (importState.isImporting) {
LinearProgressIndicator(
modifier = Modifier
.align(Alignment.BottomCenter)
.fillMaxWidth(),
)
}
}
}
@@ -101,8 +101,11 @@ class PdfBuilderEngine @Inject constructor() {
val srcH = page.height.toFloat()
if (srcW <= 0f || srcH <= 0f) return@repeat
// Format source conservé, borné mémoire à MAX_IMAGE_PX
// (pas de plafond en points : une page A3 restait
// pixellisée par l'ancien cap à 1200 pt).
val maxDim = maxOf(srcW, srcH)
val scale = minOf(1f, MAX_PAGE_POINTS / maxDim, MAX_IMAGE_PX / maxDim)
val scale = minOf(1f, MAX_IMAGE_PX / maxDim)
val pageW = (srcW * scale).toInt().coerceAtLeast(1)
val pageH = (srcH * scale).toInt().coerceAtLeast(1)
@@ -119,8 +122,10 @@ class PdfBuilderEngine @Inject constructor() {
} catch (_: Exception) {
return appended
} finally {
renderer?.close()
pfd.close()
// `close()` protégés séparément : si le renderer lève, le fd doit
// quand même être refermé (sinon fd leak).
runCatching { renderer?.close() }
runCatching { pfd.close() }
}
}
@@ -333,7 +338,6 @@ class PdfBuilderEngine @Inject constructor() {
private const val IMAGE_MARGIN = 40f
/** Bornes mémoire : pages et bitmaps jamais au-delà. */
private const val MAX_PAGE_POINTS = 1200f
private const val MAX_IMAGE_PX = 3000
private const val MAX_NOTE_CHARS = 100_000
private const val MAX_NOTE_PAGES = 30
@@ -51,6 +51,7 @@ import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
@@ -87,9 +88,9 @@ fun PdfBuilderScreen(
val snackbarHostState = remember { SnackbarHostState() }
var showNoteDialog by remember { mutableStateOf(false) }
var showFileSheet by remember { mutableStateOf(false) }
var showNameDialog by remember { mutableStateOf(false) }
var showNoteDialog by rememberSaveable { mutableStateOf(false) }
var showFileSheet by rememberSaveable { mutableStateOf(false) }
var showNameDialog by rememberSaveable { mutableStateOf(false) }
var previewFile by remember { mutableStateOf<FileEntity?>(null) }
// Nom suggéré par défaut : date du jour au format jour-mois-année.
@@ -101,15 +102,22 @@ fun PdfBuilderScreen(
viewModel.loadInitial(initialResourceIds)
}
LaunchedEffect(buildPhase) {
when (buildPhase) {
is BuildPhase.Ready -> showNameDialog = true
is BuildPhase.Saved -> onOpenDocument((buildPhase as BuildPhase.Saved).resourceId)
is BuildPhase.Failed -> {
snackbarHostState.showSnackbar((buildPhase as BuildPhase.Failed).message)
viewModel.acknowledgeFailure()
}
else -> Unit
// m33 : clés précises — `LaunchedEffect(buildPhase)` rejouait les
// side-effects à chaque recomposition racine (rotation → Failed
// re-snackbar, Saved re-`onOpenDocument` = double navigation possible).
val isReady = buildPhase is BuildPhase.Ready
val savedResourceId = (buildPhase as? BuildPhase.Saved)?.resourceId
val failureMessage = (buildPhase as? BuildPhase.Failed)?.message
LaunchedEffect(isReady) {
if (isReady) showNameDialog = true
}
LaunchedEffect(savedResourceId) {
if (savedResourceId != null) onOpenDocument(savedResourceId)
}
LaunchedEffect(failureMessage) {
if (failureMessage != null) {
snackbarHostState.showSnackbar(failureMessage)
viewModel.acknowledgeFailure()
}
}
@@ -245,7 +253,10 @@ private fun SelectFilesSheet(
onDismiss: () -> Unit,
onConfirm: (Set<String>) -> Unit,
) {
var selected by remember(files) { mutableStateOf(existingIds.toMutableSet()) }
// Clé stable (items du panier), jamais la liste Room des fichiers : avec
// `remember(files)`, chaque update Room recréait la sélection et effaçait
// les cases cochées en cours.
var selected by remember(existingIds) { mutableStateOf(existingIds.toMutableSet()) }
val sheetState = rememberModalBottomSheetState()
ModalBottomSheet(
@@ -10,6 +10,7 @@ import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.kazier.mobile.R
import com.kazier.mobile.data.local.entity.FileEntity
import com.kazier.mobile.data.local.entity.FileStatus
import com.kazier.mobile.data.preferences.DefaultRootStore
import com.kazier.mobile.data.repository.FileRepository
import com.kazier.mobile.data.repository.FolderRepository
@@ -225,15 +226,11 @@ class PdfBuilderViewModel @Inject constructor(
val actualName = displayName(createdUri) ?: fileName
val bytes = cacheFile.length()
val inserted = fileRepository.saveLocalFile(
input = SaveFileInput(
input = pdfSaveFileInput(
uri = createdUri.toString(),
name = actualName,
extension = "pdf",
size = bytes,
mimeType = "application/pdf",
lastModified = System.currentTimeMillis(),
exists = true,
syncStatus = "local",
bytes = bytes,
now = System.currentTimeMillis(),
),
folderResourceId = folderId,
)
@@ -358,4 +355,26 @@ sealed interface BuildPhase {
data class Ready(val file: File) : BuildPhase
data class Saved(val resourceId: String) : BuildPhase
data class Failed(val message: String) : BuildPhase
}
}
/**
* Ligne Room d'un PDF assemblé : déjà « traité » (l'utilisateur vient de le
* construire — pas de review) et `syncStatus` via la constante, pas un
* littéral.
*/
internal fun pdfSaveFileInput(
uri: String,
name: String,
bytes: Long,
now: Long,
): SaveFileInput = SaveFileInput(
uri = uri,
name = name,
extension = "pdf",
size = bytes,
mimeType = "application/pdf",
lastModified = now,
exists = true,
syncStatus = FileStatus.LOCAL,
processed = true,
)
@@ -52,24 +52,40 @@ class SwipeReviewViewModel @Inject constructor(
fun load() {
viewModelScope.launch {
_uiState.update { it.copy(isLoading = true) }
val files = runCatching { fileRepository.getUnprocessed() }
.getOrElse { e ->
runCatching { fileRepository.getUnprocessed() }
.onSuccess { files ->
_uiState.update { it.copy(isLoading = false, cards = files, total = files.size) }
}
.onFailure { e ->
Timber.w(e, "review: cannot load unprocessed files")
// Échec de reload : le deck existant est conservé (jamais
// vidé à tort), seule l'erreur est signalée.
_uiState.update {
it.copy(error = context.getString(R.string.review_load_error))
it.copy(
isLoading = false,
error = context.getString(R.string.review_load_error),
)
}
emptyList()
}
_uiState.update { it.copy(isLoading = false, cards = files, total = files.size) }
}
}
/** Swipe droite (ou bouton ✓) : garder le document, le voilà traité. */
fun keep(file: FileEntity) {
viewModelScope.launch {
runCatching { fileRepository.markProcessed(file.resourceId) }
.onFailure { Timber.w(it, "review: mark processed failed for %s", file.resourceId) }
removeOptimistically(file.resourceId)
val ok = runCatching { fileRepository.markProcessed(file.resourceId) }.isSuccess
if (ok) {
removeOptimistically(file.resourceId)
} else {
// Échec : la carte est réinsérée en tête (jamais perdue).
Timber.w("review: mark processed failed for %s — card kept", file.resourceId)
_uiState.update {
it.copy(
error = context.getString(R.string.review_keep_error),
cards = reinsertHead(it.cards, file),
)
}
}
}
}
@@ -83,7 +99,7 @@ class SwipeReviewViewModel @Inject constructor(
_uiState.update {
it.copy(
error = context.getString(R.string.review_delete_error),
cards = listOf(file) + it.cards.filterNot { c -> c.resourceId == file.resourceId },
cards = reinsertHead(it.cards, file),
)
}
}
@@ -93,9 +109,19 @@ class SwipeReviewViewModel @Inject constructor(
/** Échappatoire : tout marquer traité d'un coup (premier lancement massif). */
fun markAllProcessed() {
viewModelScope.launch {
runCatching { fileRepository.markAllProcessed() }
.onFailure { Timber.w(it, "review: mark all failed") }
val snapshot = _uiState.value.cards
_uiState.update { it.copy(cards = emptyList()) }
val ok = runCatching { fileRepository.markAllProcessed() }.isSuccess
if (!ok) {
// Échec : le deck est restauré (jamais vidé à tort).
Timber.w("review: mark all failed — deck restored")
_uiState.update {
it.copy(
error = context.getString(R.string.review_keep_error),
cards = snapshot,
)
}
}
}
}
@@ -106,4 +132,13 @@ class SwipeReviewViewModel @Inject constructor(
private fun removeOptimistically(resourceId: String) {
_uiState.update { it.copy(cards = it.cards.filterNot { c -> c.resourceId == resourceId }) }
}
}
}
/**
* Réinsère une carte en tête du deck (échec d'une action optimiste) sans
* doublon : la carte n'est jamais perdue, jamais dupliquée.
*/
internal fun reinsertHead(
cards: List<FileEntity>,
file: FileEntity,
): List<FileEntity> = listOf(file) + cards.filterNot { it.resourceId == file.resourceId }
@@ -5,6 +5,7 @@ import android.graphics.Bitmap
import android.graphics.Matrix
import android.graphics.PointF
import android.util.Size
import android.view.View
import androidx.camera.core.CameraSelector
import androidx.camera.core.ImageAnalysis
import androidx.camera.core.ImageCapture
@@ -84,10 +85,16 @@ fun CameraStage(
}
var previewView by remember { mutableStateOf<PreviewView?>(null) }
val imageCapture = remember {
ImageCapture.Builder()
.setTargetResolution(Size(1920, 1080))
.build()
// Pas de résolution forcée : la capture suit le défaut du device (une
// cible 1920×1080 paysage imposait pleine-rés + copie tournée en portrait,
// ~×2 mémoire → OOM sur petits devices).
val imageCapture = remember { ImageCapture.Builder().build() }
// Listener nommé pour pouvoir le retirer (`onRelease`) : pas de fuite.
val layoutListener = remember {
View.OnLayoutChangeListener { _, left, top, right, bottom, _, _, _, _ ->
viewSize = IntSize(right - left, bottom - top)
}
}
Box(modifier = modifier) {
@@ -96,12 +103,11 @@ fun CameraStage(
PreviewView(ctx).apply {
implementationMode = PreviewView.ImplementationMode.PERFORMANCE
}.also { view ->
view.addOnLayoutChangeListener { v, left, top, right, bottom, _, _, _, _ ->
viewSize = IntSize(right - left, bottom - top)
}
view.addOnLayoutChangeListener(layoutListener)
}
},
update = { previewView = it },
onRelease = { it.removeOnLayoutChangeListener(layoutListener) },
modifier = Modifier.fillMaxSize(),
)
@@ -158,24 +164,35 @@ fun CameraStage(
val bindingListener = Runnable {
if (disposed.get()) return@Runnable
val provider = providerFuture.get()
val preview = Preview.Builder().build().also { it.setSurfaceProvider(pv.surfaceProvider) }
// Preview et analyse partagent la même résolution cible : les deux
// flux subissent le même crop, et l'overlay calibré sur l'image
// d'analyse coïncide avec ce que PreviewView affiche (FILL_CENTER).
// Avant, l'overlay suivait le flux ImageAnalysis seul alors que
// l'écran montrait le flux Preview (ratio/crop différents → quad
// décalé dès que les ratios divergeaient).
val preview = Preview.Builder().setTargetResolution(SCAN_STREAM_SIZE)
.build().also { it.setSurfaceProvider(pv.surfaceProvider) }
val analysis = ImageAnalysis.Builder()
.setTargetResolution(SCAN_STREAM_SIZE)
.setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
.build()
analysis.setAnalyzer(analysisExecutor) { proxy ->
var frame: Bitmap? = null
var scaled: Bitmap? = null
try {
val unrotated = proxy.toBitmap()
val degrees = proxy.imageInfo.rotationDegrees
val bitmap = if (degrees != 0) rotate(unrotated, degrees) else unrotated
try {
viewModel.processAnalysisFrame(bitmap.width, bitmap.height, bitmap)
} finally {
if (bitmap !== unrotated) unrotated.recycle()
bitmap.recycle()
}
frame = if (degrees != 0) rotate(unrotated, degrees) else unrotated
if (frame !== unrotated) unrotated.recycle()
// Jamais de pleine-rés vers le détecteur (churn GC +
// batterie à ~30 fps) : downscale vers le côté de détection.
scaled = downscaleForAnalysis(frame)
viewModel.processAnalysisFrame(scaled.width, scaled.height, scaled)
} catch (_: Exception) {
// Une frame illisible ne doit pas stopper l'analyse.
} finally {
if (frame !== scaled) frame?.recycle()
scaled?.recycle()
proxy.close()
}
}
@@ -198,11 +215,14 @@ fun CameraStage(
}
private fun rotate(bitmap: Bitmap, degrees: Int): Bitmap {
if (degrees == 0) return bitmap
val matrix = Matrix().apply {
when (degrees) {
90 -> setRotate(90f)
180 -> setRotate(180f)
270 -> setRotate(270f)
// Angle inattendu : pas de copie silencieuse, on garde l'original.
else -> return bitmap
}
}
return bitmap.run {
@@ -210,6 +230,19 @@ private fun rotate(bitmap: Bitmap, degrees: Int): Bitmap {
}
}
/** Downscale d'une frame d'analyse vers [ANALYSIS_MAX_SIDE] (alias si déjà petit). */
private fun downscaleForAnalysis(frame: Bitmap): Bitmap {
val maxSide = maxOf(frame.width, frame.height)
if (maxSide <= ANALYSIS_MAX_SIDE) return frame
val scale = ANALYSIS_MAX_SIDE.toFloat() / maxSide
return Bitmap.createScaledBitmap(
frame,
(frame.width * scale).toInt().coerceAtLeast(1),
(frame.height * scale).toInt().coerceAtLeast(1),
true,
)
}
private fun capture(context: Context, imageCapture: ImageCapture, viewModel: ScanViewModel) {
val file = File(context.cacheDir, "scan_capture_${System.currentTimeMillis()}.jpg")
imageCapture.takePicture(
@@ -247,4 +280,10 @@ private fun capture(context: Context, imageCapture: ImageCapture, viewModel: Sca
)
}
private const val SCAN_JPEG_QUALITY = 92
private const val SCAN_JPEG_QUALITY = 92
/** Résolution commune Preview/analyse (même crop → overlay aligné). */
private val SCAN_STREAM_SIZE = Size(1280, 720)
/** Côté max des frames envoyées au détecteur (GC/batterie bornés). */
private const val ANALYSIS_MAX_SIDE = 900
@@ -185,10 +185,17 @@ fun CropStage(
Canvas(modifier = Modifier.fillMaxSize()) {
val dst = ScanGeometry.viewportFit(viewport, boxSize.width, boxSize.height)
// Offset et taille arrondis indépendamment → dépassement 1 px
// en bordure (frange noire sur images impaires) : on clampe
// la source dans l'image.
val srcLeft = viewport.left.roundToInt().coerceIn(0, imageWidth)
val srcTop = viewport.top.roundToInt().coerceIn(0, imageHeight)
val srcRight = viewport.right.roundToInt().coerceIn(srcLeft + 1, imageWidth)
val srcBottom = viewport.bottom.roundToInt().coerceIn(srcTop + 1, imageHeight)
drawImage(
image = bitmap.asImageBitmap(),
srcOffset = IntOffset(viewport.left.roundToInt(), viewport.top.roundToInt()),
srcSize = IntSize(viewport.width().roundToInt(), viewport.height().roundToInt()),
srcOffset = IntOffset(srcLeft, srcTop),
srcSize = IntSize(srcRight - srcLeft, srcBottom - srcTop),
dstOffset = IntOffset(dst.left.roundToInt(), dst.top.roundToInt()),
dstSize = IntSize(dst.width().roundToInt(), dst.height().roundToInt()),
)
@@ -45,6 +45,7 @@ object ScanGeometry {
viewWidth: Int,
viewHeight: Int,
): PointF {
if (sourceRect.width() <= 0f || sourceRect.height() <= 0f) return PointF(point.x, point.y)
val dst = viewportFit(sourceRect, viewWidth, viewHeight)
if (dst.width() <= 0f || dst.height() <= 0f) return point
return PointF(
@@ -60,6 +61,7 @@ object ScanGeometry {
viewWidth: Int,
viewHeight: Int,
): PointF {
if (sourceRect.width() <= 0f || sourceRect.height() <= 0f) return PointF(point.x, point.y)
val dst = viewportFit(sourceRect, viewWidth, viewHeight)
if (dst.width() <= 0f || dst.height() <= 0f) return point
return PointF(
@@ -11,7 +11,6 @@ import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.kazier.mobile.R
import com.kazier.mobile.data.local.entity.ScanPageEntity
import com.kazier.mobile.data.local.entity.ScanPageStatus
import com.kazier.mobile.data.local.entity.ScanSessionEntity
import com.kazier.mobile.data.preferences.DefaultRootStore
import com.kazier.mobile.data.repository.FileRepository
@@ -21,6 +20,7 @@ import com.kazier.mobile.data.repository.ScanRepository
import com.kazier.mobile.features.saf.SafUris
import com.kazier.mobile.features.saf.SafWriter
import com.kazier.mobile.features.scan.CornerGeometry
import com.kazier.mobile.features.scan.ScanExport
import com.kazier.mobile.features.scan.ScanImageProcessor
import com.kazier.mobile.features.scan.ScanQuad
import com.kazier.mobile.features.scan.ScanRenderMode
@@ -34,7 +34,6 @@ import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
@@ -44,6 +43,7 @@ import java.io.FileOutputStream
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Locale
import java.util.UUID
import javax.inject.Inject
import kotlin.math.max
import kotlin.math.min
@@ -113,11 +113,7 @@ class ScanViewModel @Inject constructor(
val rootId = defaultRootStore.get()
val session = scanRepository.getOrCreateActiveSession(rootId)
_session.value = session
combine(
scanRepository.observePages(session.id),
scanRepository.observePageCount(session.id),
) { pageList, _ -> pageList }
.collect { _pages.value = it }
scanRepository.observePages(session.id).collect { _pages.value = it }
}
}
@@ -177,28 +173,47 @@ class ScanViewModel @Inject constructor(
viewModelScope.launch(Dispatchers.IO) {
_busy.value = true
try {
val (targetW, targetH) = CornerGeometry.outputSize(currentDraft.quad.points)
if (CornerGeometry.isDegenerate(currentDraft.quad.points)) {
_message.value = context.getString(R.string.scan_error_page)
return@launch
}
val processed = imageProcessor.process(
currentDraft.bitmap,
currentDraft.quad,
_renderMode.value,
)
val order = scanRepository.pageCount(currentSession.id) + 1
val sessionDir = ensureSessionDir(currentSession.id)
val finalFile = File(sessionDir, "page_$order.jpg")
FileOutputStream(finalFile).use { out ->
processed.compress(Bitmap.CompressFormat.JPEG, JPEG_QUALITY, out)
try {
val sessionDir = ensureSessionDir(currentSession.id)
// Nom unique (timestamp + aléatoire), jamais `page_$order` :
// après suppression, COUNT réutilisait un nom existant et
// écrasait le JPEG d'une autre page.
val finalFile = uniquePageFile(sessionDir)
FileOutputStream(finalFile).use { out ->
processed.compress(Bitmap.CompressFormat.JPEG, JPEG_QUALITY, out)
}
try {
scanRepository.addPage(
session = currentSession,
tempUri = finalFile.absolutePath,
cornersJson = quadToString(currentDraft.quad),
// Dimensions réelles post-scale (le processeur
// plafonne à 2400 px), pas celles du quad.
width = processed.width,
height = processed.height,
)
} catch (e: Exception) {
// Insert Room échoué : pas de JPEG orphelin.
finalFile.delete()
throw e
}
} finally {
// `process()` alias l'entrée si OpenCV est indisponible :
// ne recycler que la nouvelle instance, jamais le bitmap
// du brouillon encore dessiné par CropStage.
if (processed !== currentDraft.bitmap) processed.recycle()
}
processed.recycle()
currentDraft.sourceFile.delete()
scanRepository.addPage(
session = currentSession,
tempUri = finalFile.absolutePath,
cornersJson = quadToString(currentDraft.quad),
width = targetW,
height = targetH,
)
_draft.value = null
_stage.value = ScanStage.CAMERA
} catch (e: Exception) {
@@ -230,8 +245,12 @@ class ScanViewModel @Inject constructor(
fun deletePage(page: ScanPageEntity) {
val currentSession = _session.value ?: return
viewModelScope.launch(Dispatchers.IO) {
File(page.tempUri).delete()
scanRepository.deletePage(page.id, currentSession.id)
// DB d'abord, fichier ensuite : un crash entre les deux laisse au
// pire un JPEG orphelin (nettoyé à l'abandon), jamais une ligne
// vers un fichier absent.
runCatching { scanRepository.deletePage(page.id, currentSession.id) }
.onSuccess { File(page.tempUri).delete() }
.onFailure { Timber.w(it, "scan delete page failed") }
}
}
@@ -242,7 +261,12 @@ class ScanViewModel @Inject constructor(
}
}
/** Exporte toutes les pages dans le dossier racine, 1 fichier = 1 outbox. */
/**
* Exporte les pages en attente dans le dossier racine, 1 fichier =
* 1 outbox. Idempotent : seul le `PENDING` est exporté (un retry ne
* duplique jamais l'`EXPORTED`) ; seules les pages réussies sont marquées
* `EXPORTED` et la session ne passe `DONE` que si tout a réussi.
*/
fun export() {
val currentSession = _session.value ?: return
viewModelScope.launch(Dispatchers.IO) {
@@ -256,48 +280,70 @@ class ScanViewModel @Inject constructor(
val rootUri = SafUris.toDocumentUri(rootFolder.uri)
?: error("default root has no uri")
val pages = scanRepository.getPages(currentSession.id)
val pages = ScanExport.pendingForExport(scanRepository.getPages(currentSession.id))
if (pages.isEmpty()) {
// Retry après succès : rien à faire, on termine.
scanRepository.finishSession(currentSession.id)
_exported.value = true
return@launch
}
val stamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(Date())
var failures = 0
pages.forEachIndexed { index, page ->
val file = File(page.tempUri)
if (!file.exists()) return@forEachIndexed
val displayName = "scan_${stamp}_${(index + 1).toString().padStart(2, '0')}.jpg"
val createdUri = SafWriter.createDocument(
resolver = context.contentResolver,
treeUri = rootUri.toString(),
mimeType = "image/jpeg",
displayName = displayName,
) ?: error("cannot create document in default root")
SafWriter.copyInto(createdUri, file, context.contentResolver)
if (!file.isFile) {
// Temp manquant : échec compté (reprise possible, pas
// de DONE silencieux avec un PENDING abandonné).
Timber.w("scan export: missing temp for page %d", page.id)
failures++
return@forEachIndexed
}
runCatching {
context.contentResolver.takePersistableUriPermission(
createdUri,
Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_GRANT_WRITE_URI_PERMISSION,
)
}.onFailure { Timber.w(it, "persistable uri permission absent") }
val folderId = SafWriter.resolveTargetFolder(folderRepository, createdUri)
?: rootFolderId
val name = SafWriter.displayName(context.contentResolver, createdUri)
?: displayName
fileRepository.saveLocalFile(
input = SaveFileInput(
uri = createdUri.toString(),
name = name,
extension = "jpg",
size = file.length(),
val displayName = "scan_${stamp}_${(index + 1).toString().padStart(2, '0')}.jpg"
val createdUri = SafWriter.createDocument(
resolver = context.contentResolver,
treeUri = rootUri.toString(),
mimeType = "image/jpeg",
lastModified = file.lastModified(),
exists = true,
// Déjà traité au scan : ne pas remonter dans la review.
processed = true,
),
folderResourceId = folderId,
)
scanRepository.markPageExported(page.copy(status = ScanPageStatus.EXPORTED))
displayName = displayName,
) ?: error("cannot create document in default root")
SafWriter.copyInto(createdUri, file, context.contentResolver)
runCatching {
context.contentResolver.takePersistableUriPermission(
createdUri,
Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_GRANT_WRITE_URI_PERMISSION,
)
}.onFailure { Timber.w(it, "persistable uri permission absent") }
val folderId = SafWriter.resolveTargetFolder(folderRepository, createdUri)
?: rootFolderId
val name = SafWriter.displayName(context.contentResolver, createdUri)
?: displayName
fileRepository.saveLocalFile(
input = SaveFileInput(
uri = createdUri.toString(),
name = name,
extension = "jpg",
size = file.length(),
mimeType = "image/jpeg",
lastModified = file.lastModified(),
exists = true,
// Déjà traité au scan : ne pas remonter dans la review.
processed = true,
),
folderResourceId = folderId,
)
scanRepository.markPageExported(page)
}.onFailure { e ->
Timber.e(e, "scan export failed for page %d", page.id)
failures++
}
}
if (ScanExport.shouldFinishSession(failures)) {
scanRepository.finishSession(currentSession.id)
_exported.value = true
} else {
_message.value = context.getString(R.string.scan_error_export)
}
scanRepository.finishSession(currentSession.id)
_exported.value = true
} catch (e: Exception) {
Timber.e(e, "scan export failed")
_message.value = when (e) {
@@ -328,8 +374,13 @@ class ScanViewModel @Inject constructor(
val rootUri = SafUris.toDocumentUri(rootFolder.uri)
?: error("default root has no uri")
val pages = scanRepository.getPages(currentSession.id)
if (pages.isEmpty()) return@launch
val pages = ScanExport.pendingForExport(scanRepository.getPages(currentSession.id))
if (pages.isEmpty()) {
// Retry après succès : rien à faire, on termine.
scanRepository.finishSession(currentSession.id)
_exported.value = true
return@launch
}
val stamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(Date())
val displayName = "scan_$stamp.pdf"
@@ -381,14 +432,21 @@ class ScanViewModel @Inject constructor(
)
cacheFile.delete()
if (result.failedIds.isNotEmpty()) {
Timber.w("scan pdf: %d page(s) not embedded", result.failedIds.size)
// Seules les pages effectivement embarquées sont marquées :
// un échec partiel garde ses PENDING pour reprise, sans DONE.
val failedSet = result.failedIds.toHashSet()
if (failedSet.isNotEmpty()) {
Timber.w("scan pdf: %d page(s) not embedded", failedSet.size)
}
pages.forEach { page ->
scanRepository.markPageExported(page.copy(status = ScanPageStatus.EXPORTED))
ScanExport.succeeded(pages, failedSet).forEach { page ->
scanRepository.markPageExported(page)
}
if (ScanExport.shouldFinishSession(failedSet.size)) {
scanRepository.finishSession(currentSession.id)
_exported.value = true
} else {
_message.value = context.getString(R.string.scan_error_export)
}
scanRepository.finishSession(currentSession.id)
_exported.value = true
} catch (e: Exception) {
Timber.e(e, "scan pdf export failed")
_message.value = when (e) {
@@ -408,12 +466,19 @@ class ScanViewModel @Inject constructor(
/** Annule la session : suppression des fichiers temp + fermeture. */
fun abandon() {
val currentSession = _session.value ?: return
_session.value = null
cleanupScope.launch {
scanRepository.getPages(currentSession.id).forEach { File(it.tempUri).delete() }
sessionDir(currentSession.id)?.delete()
val pages = scanRepository.getPages(currentSession.id)
pages.forEach { File(it.tempUri).delete() }
val dir = sessionDir(currentSession.id)
if (dir.exists()) dir.deleteRecursively()
_pages.value = emptyList()
scanRepository.abandonSession(currentSession.id)
_session.value = null
if (pages.isEmpty()) {
// Session vide : purge de la ligne, pas de ABANDONED orphelin.
runCatching { scanRepository.deleteSession(currentSession.id) }
} else {
scanRepository.abandonSession(currentSession.id)
}
}
}
@@ -424,11 +489,21 @@ class ScanViewModel @Inject constructor(
// ------------------------------------------------------------ helpers
private fun ensureSessionDir(sessionId: Long): File =
sessionDir(sessionId)?.apply { if (!exists()) mkdirs() } ?: sessionDir(sessionId)!!
sessionDir(sessionId).apply { if (!exists()) mkdirs() }
private fun sessionDir(sessionId: Long): File? = runCatching {
File(context.filesDir, "$SCAN_DIR/$sessionId").also { it.mkdirs() }
}.getOrNull()
/** Getter pur (jamais de `mkdirs`) : ne recrée pas ce que `abandon` supprime. */
private fun sessionDir(sessionId: Long): File =
File(context.filesDir, "$SCAN_DIR/$sessionId")
/** Nom de page unique (timestamp + aléatoire) — jamais de collision. */
private fun uniquePageFile(dir: File): File {
var file: File
do {
val suffix = UUID.randomUUID().toString().replace("-", "").take(8)
file = File(dir, "page_${System.currentTimeMillis()}_$suffix.jpg")
} while (file.exists())
return file
}
private fun defaultQuad(width: Int, height: Int): List<PointF> {
val inset = min(width, height) * 0.08f
@@ -41,6 +41,7 @@ import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
@@ -96,9 +97,9 @@ fun SearchScreen(
val deleteError by viewModel.deleteError.collectAsStateWithLifecycle()
val deleteSuccess by viewModel.deleteSuccess.collectAsStateWithLifecycle()
val selection = rememberSelectionState()
var showMoveDialog by remember { mutableStateOf(false) }
var showDeleteWarning by remember { mutableStateOf(false) }
var showDeleteConfirm by remember { mutableStateOf(false) }
var showMoveDialog by rememberSaveable { mutableStateOf(false) }
var showDeleteWarning by rememberSaveable { mutableStateOf(false) }
var showDeleteConfirm by rememberSaveable { mutableStateOf(false) }
var pendingDeleteMode by remember { mutableStateOf<FileDeleter.DeleteMode?>(null) }
var pendingDeleteReview by remember { mutableStateOf<DeleteReview?>(null) }
val snackbarHostState = remember { SnackbarHostState() }
@@ -166,12 +167,15 @@ fun SearchScreen(
},
bottomBar = {
if (selection.active) {
// M34 : les actions portent sur les résultats visibles —
// la sélection ne survit ni à la frappe ni au changement de filtre.
val visibleIds = uiState.results.map { it.resourceId }.toSet()
val selectedVisibleIds = selection.ids.filter { it in visibleIds }
SelectionNavBar(
onMove = { showMoveDialog = true },
onBuildPdf = {
val ids = selection.ids.toList()
selection.clear()
onBuildPdf(ids)
onBuildPdf(selectedVisibleIds)
},
onDeleteModeSelected = { mode ->
val selectedFiles = uiState.results.filter { it.resourceId in selection.ids }
@@ -184,7 +188,7 @@ fun SearchScreen(
showDeleteConfirm = true
}
},
enabled = selection.ids.isNotEmpty(),
enabled = selectedVisibleIds.isNotEmpty(),
)
} else {
FloatingNavBar(selected = selectedTab, onSelect = onTabSelected)
@@ -212,7 +216,9 @@ fun SearchScreen(
viewModel.closeMovePicker()
},
onConfirm = { folderId ->
val ids = selection.ids.toList()
// M34 : seuls les ids encore visibles sont déplacés.
val visibleIds = uiState.results.map { it.resourceId }.toSet()
val ids = selection.ids.filter { it in visibleIds }
selection.clear()
showMoveDialog = false
viewModel.moveSelectedFiles(ids, folderId)
@@ -240,7 +246,9 @@ fun SearchScreen(
DeleteConfirmDialog(
count = selection.ids.size,
onConfirm = {
val ids = selection.ids.toList()
// M34 : seuls les ids encore visibles sont supprimés.
val visibleIds = uiState.results.map { it.resourceId }.toSet()
val ids = selection.ids.filter { it in visibleIds }
val mode = pendingDeleteMode!!
selection.clear()
showDeleteConfirm = false
@@ -291,6 +299,9 @@ private fun SearchContent(
CategoryChip(
label = stringResource(R.string.category_all),
selected = uiState.selectedCategory == null,
// M34 : les filtres sont figés en mode sélection (les
// résultats sous la sélection ne doivent pas changer).
enabled = !selection.active,
onClick = { onCategorySelect(null) },
)
}
@@ -298,6 +309,7 @@ private fun SearchContent(
CategoryChip(
label = categoryLabel(category),
selected = uiState.selectedCategory == category.dbValue,
enabled = !selection.active,
onClick = { onCategorySelect(category.dbValue) },
category = category,
)
@@ -319,10 +331,12 @@ private fun CategoryChip(
selected: Boolean,
onClick: () -> Unit,
category: FileCategory? = null,
enabled: Boolean = true,
) {
FilterChip(
selected = selected,
onClick = onClick,
enabled = enabled,
label = { Text(label) },
leadingIcon = category?.let { cat ->
{
@@ -21,7 +21,6 @@ import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.debounce
import kotlinx.coroutines.flow.flatMapLatest
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
@@ -51,20 +50,34 @@ class SearchViewModel @Inject constructor(
private val _deleteSuccess = MutableStateFlow(false)
val deleteSuccess: StateFlow<Boolean> = _deleteSuccess.asStateFlow()
/**
* Résultats Room : seule cette branche est debouncée (300 ms). La requête
* affichée ([uiState.query]) suit la frappe brute sans à-coups (M31).
*/
@OptIn(FlowPreview::class, ExperimentalCoroutinesApi::class)
val uiState: StateFlow<SearchUiState> = combine(
private val results: StateFlow<List<FileEntity>> = combine(
_searchQuery.debounce(SEARCH_DEBOUNCE_MS),
_selectedCategory,
) { query, category -> CategoryQuery(query, category) }
.flatMapLatest { (query, category) ->
val trimmed = query.trim()
val flow = if (trimmed.isEmpty()) {
if (trimmed.isEmpty()) {
fileRepository.recentFiles(category)
} else {
fileRepository.searchFiles(trimmed, category)
}
flow.map { files -> SearchUiState(query, category, files) }
}
.stateIn(
scope = viewModelScope,
started = SharingStarted.WhileSubscribed(STOP_TIMEOUT_MS),
initialValue = emptyList(),
)
val uiState: StateFlow<SearchUiState> = combine(
_searchQuery,
_selectedCategory,
results,
) { query, category, files -> SearchUiState(query, category, files) }
.stateIn(
scope = viewModelScope,
started = SharingStarted.WhileSubscribed(STOP_TIMEOUT_MS),
@@ -1,7 +1,6 @@
package com.kazier.mobile.ui.settings
import androidx.compose.foundation.clickable
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
@@ -20,13 +19,13 @@ import androidx.compose.material.icons.filled.Person
import androidx.compose.material3.Button
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.FilterChip
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.OutlinedButton
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Switch
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.material3.TopAppBar
@@ -80,12 +79,6 @@ fun SettingsScreen(
var username by rememberSaveable { mutableStateOf("") }
var password by rememberSaveable { mutableStateOf("") }
val darkNow = when (theme) {
ThemePreference.DARK -> true
ThemePreference.LIGHT -> false
ThemePreference.SYSTEM -> isSystemInDarkTheme()
}
Scaffold(
topBar = {
TopAppBar(
@@ -110,19 +103,22 @@ fun SettingsScreen(
.verticalScroll(rememberScrollState()),
) {
HorizontalDivider()
// M36 : 3 états (Système/Clair/Sombre) — le Switch DARK/LIGHT
// rendait SYSTEM inatteignable alors que le store le supporte.
SettingsRow(
icon = { Icon(Icons.Filled.DarkMode, contentDescription = null) },
title = stringResource(R.string.settings_dark_mode),
title = stringResource(R.string.settings_theme),
subtitle = stringResource(
if (darkNow) R.string.settings_dark_mode_on
else R.string.settings_dark_mode_off,
when (theme) {
ThemePreference.DARK -> R.string.settings_theme_dark
ThemePreference.LIGHT -> R.string.settings_theme_light
ThemePreference.SYSTEM -> R.string.settings_theme_system
},
),
trailing = {
Switch(
checked = darkNow,
onCheckedChange = { on ->
viewModel.setTheme(if (on) ThemePreference.DARK else ThemePreference.LIGHT)
},
ThemeSelector(
selected = theme,
onSelect = viewModel::setTheme,
)
},
)
@@ -267,6 +263,43 @@ fun SettingsScreen(
}
}
@Composable
private fun ThemeSelector(
selected: ThemePreference,
onSelect: (ThemePreference) -> Unit,
) {
Row(verticalAlignment = Alignment.CenterVertically) {
ThemeChip(
label = stringResource(R.string.settings_theme_system),
selected = selected == ThemePreference.SYSTEM,
onClick = { onSelect(ThemePreference.SYSTEM) },
)
ThemeChip(
label = stringResource(R.string.settings_theme_light),
selected = selected == ThemePreference.LIGHT,
onClick = { onSelect(ThemePreference.LIGHT) },
)
ThemeChip(
label = stringResource(R.string.settings_theme_dark),
selected = selected == ThemePreference.DARK,
onClick = { onSelect(ThemePreference.DARK) },
)
}
}
@Composable
private fun ThemeChip(
label: String,
selected: Boolean,
onClick: () -> Unit,
) {
FilterChip(
selected = selected,
onClick = onClick,
label = { Text(label) },
)
}
@Composable
private fun SettingsRow(
icon: @Composable () -> Unit,
@@ -7,6 +7,8 @@ import com.kazier.mobile.domain.ThemePreference
import com.kazier.mobile.domain.ThemePreferenceStore
import dagger.hilt.android.lifecycle.HiltViewModel
import javax.inject.Inject
import kotlinx.coroutines.Job
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
@@ -27,11 +29,18 @@ class SettingsViewModel @Inject constructor(
private val _testUiState = MutableStateFlow(ServerTestUiState())
val testUiState: StateFlow<ServerTestUiState> = _testUiState.asStateFlow()
/**
* M37 : dès que l'utilisateur tape, le champ est « sale » — le `load()`
* asynchrone de l'init ne doit plus écraser sa saisie à son retour.
*/
private var dirty = false
private var saveJob: Job? = null
init {
viewModelScope.launch {
themePreferenceStore.load()
serverConfigStore.load()
_serverUrl.value = serverConfigStore.current
if (!dirty) _serverUrl.value = serverConfigStore.current
}
}
@@ -39,10 +48,18 @@ class SettingsViewModel @Inject constructor(
viewModelScope.launch { themePreferenceStore.set(theme) }
}
/** Persiste la base serveur au fil de la frappe (affichage = saisie brute). */
/**
* Affichage = saisie brute immédiate ; persistance debouncée (m36 : une
* écriture prefs par frappe = churn IO, une par pause suffit).
*/
fun onServerUrlChange(url: String) {
dirty = true
_serverUrl.value = url
viewModelScope.launch { serverConfigStore.set(url) }
saveJob?.cancel()
saveJob = viewModelScope.launch {
delay(SAVE_DEBOUNCE_MS)
serverConfigStore.set(url)
}
}
/** Ping `/health` sur l'URL saisie (même non sauvegardée). */
@@ -70,4 +87,6 @@ data class ServerTestUiState(
val isTesting: Boolean = false,
/** null = pas encore testé ; true/false = résultat du dernier test. */
val success: Boolean? = null,
)
)
private const val SAVE_DEBOUNCE_MS = 500L
@@ -24,5 +24,7 @@ class WatchedFoldersViewModel @Inject constructor(
/** Nombre de racines surveillées — l'UI plafonne l'affichage à 99 (« 99+ »). */
val count: StateFlow<Int> = folderRepository.observeSafRoots()
.map { it.size }
.stateIn(viewModelScope, SharingStarted.Eagerly, 0)
// m35 : WhileSubscribed — Eagerly collectait Room en continu même sur
// les autres onglets (aggravé par la double instance du badge).
.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), 0)
}
@@ -107,6 +107,10 @@
<string name="settings_dark_mode">Dark mode</string>
<string name="settings_dark_mode_on">Dark theme active</string>
<string name="settings_dark_mode_off">Light theme active</string>
<string name="settings_theme">Theme</string>
<string name="settings_theme_system">System</string>
<string name="settings_theme_light">Light</string>
<string name="settings_theme_dark">Dark</string>
<string name="settings_server">Server</string>
<string name="settings_server_url">Server address</string>
<string name="settings_test_connection">Test connection</string>
@@ -28,6 +28,7 @@
<string name="review_mark_all_message">Les documents restants seront considérés comme traités et synchronisés vers le cloud sans être revus.</string>
<string name="review_load_error">Impossible de charger les documents à traiter.</string>
<string name="review_delete_error">Impossible de supprimer ce document — permission refusée.</string>
<string name="review_keep_error">Impossible de garder ce document — réessaie.</string>
<string name="browse_up">Remonter</string>
<string name="move_here_count">Déplacer ici (%1$d)</string>
<string name="move_pick_title">Déplacer %1$d fichier(s)…</string>
@@ -107,6 +108,10 @@
<string name="settings_dark_mode">Mode sombre</string>
<string name="settings_dark_mode_on">Thème sombre actif</string>
<string name="settings_dark_mode_off">Thème clair actif</string>
<string name="settings_theme">Thème</string>
<string name="settings_theme_system">Système</string>
<string name="settings_theme_light">Clair</string>
<string name="settings_theme_dark">Sombre</string>
<string name="settings_server">Serveur</string>
<string name="settings_server_url">Adresse du serveur</string>
<string name="settings_test_connection">Tester la connexion</string>