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>
@@ -9,11 +9,13 @@ import com.kazier.mobile.data.local.AppDatabase
import com.kazier.mobile.data.local.entity.PendingOperationEntity
import com.kazier.mobile.data.local.entity.PendingOperationType
import com.kazier.mobile.data.local.entity.PendingOpStatus
import com.kazier.mobile.data.local.entity.FolderEntity
import com.kazier.mobile.data.remote.ApiClient
import com.kazier.mobile.data.remote.ApiService
import com.kazier.mobile.data.repository.FileRepository
import com.kazier.mobile.data.repository.OutboxRepository
import com.kazier.mobile.data.repository.SaveFileInput
import com.kazier.mobile.domain.DeviceIdentity
import com.kazier.mobile.domain.GenerateId
import kotlinx.coroutines.test.runTest
import org.junit.After
@@ -64,8 +66,24 @@ class ProcessedGateTest {
val apiClient = ApiClient(apiService, moshi)
val generateId = GenerateId()
outboxRepository = OutboxRepository(opsDao, generateId, moshi)
fileRepository = FileRepository(fileDao, apiClient, generateId, db, outboxRepository)
outboxRepository = OutboxRepository(opsDao, generateId, DeviceIdentity(db.userPreferenceDao(), generateId), moshi)
fileRepository = FileRepository(fileDao, db.folderDao(), apiClient, generateId, db, outboxRepository)
// Validation applicative du parent (M18) : le dossier hôte existe.
runTest {
db.folderDao().upsert(
FolderEntity(
resourceId = FOLDER,
uri = null,
name = FOLDER,
exists = 1,
parentResourceId = null,
syncStatus = "local",
addedAt = NOW,
updatedAt = NOW,
),
)
}
}
@After
@@ -0,0 +1,242 @@
package com.kazier.mobile.data.remote
import android.content.Context
import androidx.room.Room
import androidx.test.core.app.ApplicationProvider
import com.squareup.moshi.Moshi
import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory
import com.kazier.mobile.auth.SessionManager
import com.kazier.mobile.auth.TokenProvider
import com.kazier.mobile.auth.TokenStore
import com.kazier.mobile.data.local.AppDatabase
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 com.kazier.mobile.data.remote.dto.UserDto
import com.kazier.mobile.domain.ActiveUserStore
import com.kazier.mobile.domain.LocalModeStore
import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.withTimeout
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.MultipartBody
import okhttp3.RequestBody
import okhttp3.ResponseBody.Companion.toResponseBody
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Assert.assertNotNull
import org.junit.Assert.assertNull
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
import retrofit2.Response
/**
* Lot E (M25) : le 401 sur endpoint protégé purge la session via le callback
* possédé par `SessionManager` (singleton) — pas par un ViewModel — donc la
* purge survit à `onCleared`. Le 401 du login reste exonéré.
*/
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34])
class Auth401Test {
private lateinit var context: Context
private lateinit var db: AppDatabase
private lateinit var tokenStore: FakeTokenStore
private lateinit var tokenProvider: TokenProvider
private lateinit var apiClient: ApiClient
private lateinit var sessionManager: SessionManager
@Before
fun setUp() {
context = ApplicationProvider.getApplicationContext<Context>()
db = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java)
.allowMainThreadQueries()
.build()
val moshi = Moshi.Builder().add(KotlinJsonAdapterFactory()).build()
tokenStore = FakeTokenStore()
tokenProvider = TokenProvider()
apiClient = ApiClient(UnauthorizedFake(), moshi)
sessionManager = SessionManager(
tokenStore,
ActiveUserStore(db.userPreferenceDao()),
tokenProvider,
LocalModeStore(db.userPreferenceDao()),
apiClient,
)
}
@After
fun tearDown() {
db.close()
}
private fun seed() {
tokenStore.save("tok-abc", UserDto(id = "u1", username = "alice"), expiresAt = 9_999_999_999_999L)
tokenProvider.current = "tok-abc"
}
private suspend fun awaitPurge() = withTimeout(5_000L) {
while (tokenStore.getToken() != null) delay(10L)
}
@Test
fun `401_protege_purge_la_session`() = runBlocking {
seed()
val error = runCatching { apiClient.listFolders() }.exceptionOrNull()
assertNotNull(error)
assertEquals("UNAUTHORIZED", (error as ApiException).code)
// Token en mémoire tombé synchronement…
assertNull(tokenProvider.current)
// …persistance purgée en IO juste après.
awaitPurge()
assertNull(tokenStore.getUser())
}
@Test
fun `401_purge_encore_apres_destruction_du_viewmodel`() = runBlocking {
// `AuthViewModel` ne possède plus `onUnauthorized` : il n'y a rien à
// annuler dans `onCleared` — le callback singleton reste branché.
assertNotNull(apiClient.onUnauthorized)
seed()
runCatching { apiClient.listFolders() }
awaitPurge()
assertNull(tokenProvider.current)
// Et un second 401 purge toujours (pas de one-shot).
seed()
runCatching { apiClient.listFolders() }
awaitPurge()
assertNull(tokenProvider.current)
}
@Test
fun `401_login_ne_purge_pas`() = runBlocking {
seed()
val error = runCatching { apiClient.login("alice", "mauvais-mdp", "device-1") }.exceptionOrNull()
assertNotNull(error)
assertEquals("UNAUTHORIZED", (error as ApiException).code)
assertEquals("tok-abc", tokenProvider.current)
assertEquals("tok-abc", tokenStore.getToken())
}
private class FakeTokenStore : TokenStore {
private var token: String? = null
private var user: UserDto? = null
private var expiresAt: Long? = null
override fun getToken(): String? = token
override fun getUser(): UserDto? = user
override fun getExpiresAt(): Long? = expiresAt
override fun save(token: String, user: UserDto, expiresAt: Long?) {
this.token = token
this.user = user
this.expiresAt = expiresAt
}
override fun clear() {
token = null
user = null
expiresAt = null
}
}
/** `listFolders` et `login` répondent 401 ; le reste est inutilisé. */
private class UnauthorizedFake : ApiService {
private fun unauthorized(): okhttp3.ResponseBody =
"""{"error":{"code":"UNAUTHORIZED","message":"expired"}}"""
.toResponseBody("application/json".toMediaType())
override suspend fun listFolders(): Response<ApiEnvelope<List<FolderDto>>> =
Response.error(401, unauthorized())
override suspend fun login(
body: LoginRequestDto,
): Response<ApiEnvelope<LoginResponseDto>> = Response.error(401, unauthorized())
override suspend fun listFiles(
folderId: String?,
page: Int?,
pageSize: Int?,
): Response<ApiEnvelope<List<FileDto>>> = Response.success(ApiEnvelope(data = emptyList()))
override suspend fun registerDevice(
body: DeviceRegistrationDto,
): Response<ApiEnvelope<DeviceRegistrationDto>> =
Response.success(ApiEnvelope(data = body))
override suspend fun syncOps(
body: SyncOpsRequest,
): Response<ApiEnvelope<SyncOpsResult>> =
Response.success(ApiEnvelope(data = SyncOpsResult(applied = 0)))
override suspend fun resolveUser(
username: String,
): Response<ApiEnvelope<ResolvedUserDto>> = Response.success(ApiEnvelope())
override suspend fun syncPermissions(
after: Long?,
): Response<ApiEnvelope<List<ResourcePermissionDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun uploadFile(
file: MultipartBody.Part,
resourceId: RequestBody?,
folderId: RequestBody?,
): Response<ApiEnvelope<FileDto>> = Response.success(ApiEnvelope())
override suspend fun submitOcr(
body: OcrSubmitDto,
): Response<ApiEnvelope<OcrJobDto>> = Response.success(ApiEnvelope())
override suspend fun getOcrJob(
jobId: String,
): Response<ApiEnvelope<OcrJobDto>> = Response.success(ApiEnvelope())
override suspend fun getFileOcr(
fileId: String,
): Response<ApiEnvelope<FileOcrDto>> = Response.success(ApiEnvelope())
override suspend fun getFile(
fileId: String,
): Response<ApiEnvelope<FileDto>> = Response.success(ApiEnvelope())
override suspend fun deleteFile(
fileId: String,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun searchFiles(
query: String,
page: Int?,
pageSize: Int?,
): Response<ApiEnvelope<List<FileDto>>> = Response.success(ApiEnvelope(data = emptyList()))
override suspend fun changePassword(
body: ChangePasswordDto,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun getShareLink(
token: String,
): Response<ApiEnvelope<ShareLinkDto>> = Response.success(ApiEnvelope())
}
}
@@ -0,0 +1,196 @@
package com.kazier.mobile.data.remote
import android.content.Context
import androidx.room.Room
import androidx.test.core.app.ApplicationProvider
import com.squareup.moshi.Moshi
import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory
import com.kazier.mobile.data.local.AppDatabase
import com.kazier.mobile.data.remote.dto.ApiEnvelope
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.SyncOpsRequest
import com.kazier.mobile.data.remote.dto.SyncOpsResult
import com.kazier.mobile.data.repository.FileRepository
import com.kazier.mobile.data.repository.OutboxRepository
import com.kazier.mobile.domain.DeviceIdentity
import com.kazier.mobile.domain.GenerateId
import kotlinx.coroutines.test.runTest
import okhttp3.MultipartBody
import okhttp3.RequestBody
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
import retrofit2.Response
/**
* Lot E (M21) : `refreshFromServer` draine toutes les pages en suivant `meta`
* au lieu de jeter la pagination après la 1re page de 50.
*/
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34])
class PaginationTest {
private lateinit var context: Context
private lateinit var db: AppDatabase
private fun moshi(): Moshi = Moshi.Builder()
.add(KotlinJsonAdapterFactory())
.build()
@Before
fun setUp() {
context = ApplicationProvider.getApplicationContext<Context>()
db = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java)
.allowMainThreadQueries()
.build()
}
@After
fun tearDown() {
db.close()
}
private fun fileDto(i: Int) = FileDto(
id = "%032d".format(i),
name = "doc-$i.pdf",
size = 100L + i,
)
private fun repository(fake: PagedFilesFake): FileRepository {
val m = moshi()
val generateId = GenerateId()
val outbox = OutboxRepository(
db.pendingOperationDao(),
generateId,
DeviceIdentity(db.userPreferenceDao(), generateId),
m,
)
return FileRepository(db.fileDao(), db.folderDao(), ApiClient(fake, m), generateId, db, outbox)
}
@Test
fun `refreshFromServer_charge_3_pages_de_50_en_suivant_meta`() = runTest {
val all = (1..150).map(::fileDto)
val fake = PagedFilesFake(all, withMeta = true)
repository(fake).refreshFromServer("folder-x")
val stored = db.fileDao().getByFolderOnce("folder-x")
assertEquals(150, stored.size)
assertEquals(listOf(1, 2, 3), fake.requestedPages)
}
@Test
fun `refreshFromServer_sans_meta_s_arrete_a_la_page_partielle`() = runTest {
val all = (1..110).map(::fileDto)
val fake = PagedFilesFake(all, withMeta = false)
repository(fake).refreshFromServer("folder-x")
val stored = db.fileDao().getByFolderOnce("folder-x")
assertEquals(110, stored.size)
assertEquals(listOf(1, 2, 3), fake.requestedPages)
}
/** Fake `GET /files` paginé côté serveur (page 1-based, pageSize 50). */
private class PagedFilesFake(
private val all: List<FileDto>,
private val withMeta: Boolean,
) : ApiService {
val requestedPages = mutableListOf<Int>()
override suspend fun listFolders(): Response<ApiEnvelope<List<FolderDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun listFiles(
folderId: String?,
page: Int?,
pageSize: Int?,
): Response<ApiEnvelope<List<FileDto>>> {
val p = page ?: 1
val ps = pageSize ?: 50
requestedPages += p
val slice = all.drop((p - 1) * ps).take(ps)
val meta = if (withMeta) ApiMeta(page = p, pageSize = ps, total = all.size) else null
return Response.success(ApiEnvelope(data = slice, meta = meta))
}
override suspend fun registerDevice(
body: DeviceRegistrationDto,
): Response<ApiEnvelope<DeviceRegistrationDto>> =
Response.success(ApiEnvelope(data = body))
override suspend fun login(
body: LoginRequestDto,
): Response<ApiEnvelope<LoginResponseDto>> = Response.success(ApiEnvelope())
override suspend fun syncOps(
body: SyncOpsRequest,
): Response<ApiEnvelope<SyncOpsResult>> =
Response.success(ApiEnvelope(data = SyncOpsResult(applied = 0)))
override suspend fun resolveUser(
username: String,
): Response<ApiEnvelope<ResolvedUserDto>> = Response.success(ApiEnvelope())
override suspend fun syncPermissions(
after: Long?,
): Response<ApiEnvelope<List<ResourcePermissionDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun uploadFile(
file: MultipartBody.Part,
resourceId: RequestBody?,
folderId: RequestBody?,
): Response<ApiEnvelope<FileDto>> = Response.success(ApiEnvelope())
override suspend fun submitOcr(
body: OcrSubmitDto,
): Response<ApiEnvelope<OcrJobDto>> = Response.success(ApiEnvelope())
override suspend fun getOcrJob(
jobId: String,
): Response<ApiEnvelope<OcrJobDto>> = Response.success(ApiEnvelope())
override suspend fun getFileOcr(
fileId: String,
): Response<ApiEnvelope<FileOcrDto>> = Response.success(ApiEnvelope())
override suspend fun getFile(
fileId: String,
): Response<ApiEnvelope<FileDto>> = Response.success(ApiEnvelope())
override suspend fun deleteFile(
fileId: String,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun searchFiles(
query: String,
page: Int?,
pageSize: Int?,
): Response<ApiEnvelope<List<FileDto>>> = Response.success(ApiEnvelope(data = emptyList()))
override suspend fun changePassword(
body: ChangePasswordDto,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun getShareLink(
token: String,
): Response<ApiEnvelope<ShareLinkDto>> = Response.success(ApiEnvelope())
}
}
@@ -0,0 +1,129 @@
package com.kazier.mobile.data.remote
import android.content.Context
import androidx.room.Room
import androidx.test.core.app.ApplicationProvider
import com.kazier.mobile.data.local.AppDatabase
import com.kazier.mobile.data.local.entity.UserPreferenceEntity
import com.kazier.mobile.domain.PrefKeys
import com.kazier.mobile.domain.ServerConfigStore
import kotlinx.coroutines.test.runTest
import okhttp3.Call
import okhttp3.Interceptor
import okhttp3.OkHttpClient
import okhttp3.Protocol
import okhttp3.Request
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
import java.util.concurrent.TimeUnit
/**
* Lot E (M26/M28) : cold start avec URL custom — aucune requête ne part vers
* l'hôte par défaut (l'interceptor restaure l'URL avant la 1re requête) — et
* `set()` rejette les URL invalides sans persister.
*/
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34])
class ServerConfigTest {
private lateinit var context: Context
private lateinit var db: AppDatabase
private fun store(): ServerConfigStore =
ServerConfigStore(db.userPreferenceDao(), OkHttpClient())
@Before
fun setUp() {
context = ApplicationProvider.getApplicationContext<Context>()
db = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java)
.allowMainThreadQueries()
.build()
}
@After
fun tearDown() {
db.close()
}
@Test
fun `cold_start_custom_aucune_requete_vers_le_defaut`() = runTest {
db.userPreferenceDao().upsert(
UserPreferenceEntity(PrefKeys.SERVER_URL, "https://kazier.example.com:8443/api/v1", 1L),
)
val store = store()
assertFalse(store.isLoaded)
val chain = CapturingChain(Request.Builder().url("http://kazier.invalid/api/v1/files").build())
ServerUrlInterceptor(store).intercept(chain)
val proceeded = chain.proceeded ?: error("aucune requête relayée")
assertEquals("kazier.example.com", proceeded.url.host)
assertEquals(8443, proceeded.url.port)
assertEquals("https", proceeded.url.scheme)
assertTrue(proceeded.url.encodedPath.startsWith("/api/v1/files"))
assertTrue(store.isLoaded)
}
@Test
fun `set_invalide_rejete_sans_persister`() = runTest {
val store = store()
store.load()
assertFalse(store.set("http://"))
assertFalse(store.set("foo bar"))
assertFalse(store.set("ftp://host/api/v1"))
assertFalse(store.set(""))
assertFalse(store.set("https://"))
assertEquals(ServerConfigStore.DEFAULT_BASE_URL, store.current)
assertNull(db.userPreferenceDao().getValue(PrefKeys.SERVER_URL))
}
@Test
fun `set_valide_normalise_et_persiste`() = runTest {
val store = store()
store.load()
assertTrue(store.set("https://example.com/api/v1/"))
assertEquals("https://example.com/api/v1", store.current)
assertEquals("https://example.com/api/v1", db.userPreferenceDao().getValue(PrefKeys.SERVER_URL))
// Schéma absent → http:// préfixé.
assertTrue(store.set("example.com/api/v1"))
assertEquals("http://example.com/api/v1", store.current)
}
/** Fake `Interceptor.Chain` qui capture la requête relayée (aucun réseau). */
private class CapturingChain(private val original: Request) : Interceptor.Chain {
var proceeded: Request? = null
override fun request(): Request = original
override fun proceed(request: Request): okhttp3.Response {
proceeded = request
return okhttp3.Response.Builder()
.request(request)
.protocol(Protocol.HTTP_1_1)
.code(200)
.message("OK")
.build()
}
override fun connection(): okhttp3.Connection? = null
override fun call(): Call = throw UnsupportedOperationException()
override fun connectTimeoutMillis(): Int = 0
override fun withConnectTimeout(timeout: Int, unit: TimeUnit): Interceptor.Chain = this
override fun readTimeoutMillis(): Int = 0
override fun withReadTimeout(timeout: Int, unit: TimeUnit): Interceptor.Chain = this
override fun writeTimeoutMillis(): Int = 0
override fun withWriteTimeout(timeout: Int, unit: TimeUnit): Interceptor.Chain = this
}
}
@@ -9,13 +9,17 @@ import com.kazier.mobile.data.local.AppDatabase
import com.kazier.mobile.data.local.dao.FolderDao
import com.kazier.mobile.data.local.dao.PendingOperationDao
import com.kazier.mobile.data.local.entity.FolderEntity
import com.kazier.mobile.data.local.entity.FileEntity
import com.kazier.mobile.data.local.entity.PendingOperationEntity
import com.kazier.mobile.data.local.entity.PendingOperationType
import com.kazier.mobile.data.local.entity.PendingOpStatus
import com.kazier.mobile.data.remote.ApiClient
import com.kazier.mobile.data.remote.ApiService
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.IdResultDto
import com.kazier.mobile.data.remote.dto.ShareLinkDto
import com.kazier.mobile.data.remote.dto.FileDto
import com.kazier.mobile.data.remote.dto.FileOcrDto
import com.kazier.mobile.data.remote.dto.FolderDto
@@ -27,8 +31,14 @@ import com.kazier.mobile.data.remote.dto.ResolvedUserDto
import com.kazier.mobile.data.remote.dto.ResourcePermissionDto
import com.kazier.mobile.data.remote.dto.SyncOpsRequest
import com.kazier.mobile.data.remote.dto.SyncOpsResult
import com.kazier.mobile.domain.ActiveUserStore
import com.kazier.mobile.domain.DeviceIdentity
import com.kazier.mobile.domain.GenerateId
import com.kazier.mobile.features.saf.FileMover
import com.kazier.mobile.features.saf.FolderDeleter
import com.kazier.mobile.features.saf.FolderMerger
import com.kazier.mobile.features.saf.SafFolderCreator
import com.kazier.mobile.features.thumbnails.ThumbnailStore
import kotlinx.coroutines.test.runTest
import okhttp3.MultipartBody
import okhttp3.RequestBody
@@ -57,7 +67,9 @@ class FolderMergeDataTest {
private lateinit var folderDao: FolderDao
private lateinit var opsDao: PendingOperationDao
private lateinit var folderRepository: FolderRepository
private lateinit var fileRepository: FileRepository
private lateinit var outboxRepository: OutboxRepository
private lateinit var merger: FolderMerger
@Before
fun setUp() {
@@ -71,15 +83,42 @@ class FolderMergeDataTest {
val moshi = Moshi.Builder().add(KotlinJsonAdapterFactory()).build()
val generateId = GenerateId()
val deviceIdentity = DeviceIdentity(db.userPreferenceDao(), generateId)
outboxRepository = OutboxRepository(opsDao, generateId, moshi)
outboxRepository = OutboxRepository(opsDao, generateId, deviceIdentity, moshi)
folderRepository = FolderRepository(
folderDao = folderDao,
apiClient = ApiClient(FolderMergeApiService(), moshi),
generateId = generateId,
deviceIdentity = deviceIdentity,
activeUserStore = ActiveUserStore(db.userPreferenceDao()),
appDatabase = db,
outboxRepository = outboxRepository,
)
// Tout cloud-only (uri NULL) : la fusion n'atteint jamais le provider
// SAF, seul Room + l'outbox sont exercés.
fileRepository = FileRepository(
db.fileDao(),
folderDao,
ApiClient(FolderMergeApiService(), moshi),
generateId,
db,
outboxRepository,
)
val fileMover = FileMover(context, fileRepository, folderRepository)
val folderDeleter = FolderDeleter(
context,
folderRepository,
fileRepository,
outboxRepository,
db,
ThumbnailStore(context),
)
merger = FolderMerger(
context,
folderRepository,
fileRepository,
fileMover,
folderDeleter,
SafFolderCreator(context),
)
}
@After
@@ -92,21 +131,27 @@ class FolderMergeDataTest {
folderDao.upsert(folder(ROOT, parent = null))
folderDao.upsert(folder(CHILD_A, parent = ROOT))
folderDao.upsert(folder(CHILD_B, parent = ROOT))
folderDao.upsert(folder(MERGED, parent = ROOT))
// Gate `create` (M2) : les dossiers sont déjà connus du serveur, le
// reparent journalise donc un `move_resource` par dossier.
opsDao.insert(createOp(CHILD_A, "aa"))
opsDao.insert(createOp(CHILD_B, "bb"))
folderRepository.reparentSubFolders(listOf(CHILD_A, CHILD_B), MERGED)
assertEquals("parent_A repositionné", MERGED, folderDao.getByResourceId(CHILD_A)!!.parentResourceId)
assertEquals("parent_B repositionné", MERGED, folderDao.getByResourceId(CHILD_B)!!.parentResourceId)
val ops = opsDao.selectPending(10)
assertEquals("une op move par dossier (ordre outbox)", 2, ops.size)
assertEquals(PendingOperationType.MOVE_RESOURCE, ops[0].operation)
assertEquals("folder", ops[0].resourceType)
assertEquals(CHILD_A, ops[0].resourceId)
assertEquals(ROOT_WITH_MERGED, ops[0].payload)
assertEquals(PendingOperationType.MOVE_RESOURCE, ops[1].operation)
assertEquals(CHILD_B, ops[1].resourceId)
assertEquals(PendingOpStatus.PENDING, ops[1].status)
val moves = opsDao.selectPending(10)
.filter { it.operation == PendingOperationType.MOVE_RESOURCE }
assertEquals("une op move par dossier (ordre outbox)", 2, moves.size)
assertEquals(PendingOperationType.MOVE_RESOURCE, moves[0].operation)
assertEquals("folder", moves[0].resourceType)
assertEquals(CHILD_A, moves[0].resourceId)
assertEquals(ROOT_WITH_MERGED, moves[0].payload)
assertEquals(PendingOperationType.MOVE_RESOURCE, moves[1].operation)
assertEquals(CHILD_B, moves[1].resourceId)
assertEquals(PendingOpStatus.PENDING, moves[1].status)
}
@Test
@@ -114,6 +159,9 @@ class FolderMergeDataTest {
folderDao.upsert(folder(ROOT, parent = null))
folderDao.upsert(folder(CHILD_A, parent = ROOT))
folderDao.upsert(folder(CHILD_B, parent = ROOT))
// Dossier cible au niveau racine : il existe (validation M18) sans
// fausser le comptage des enfants de ROOT.
folderDao.upsert(folder(MERGED, parent = null))
// L'ancien parent n'a plus d'enfants visibles.
assertEquals(2, folderRepository.getChildren(ROOT).size)
@@ -129,6 +177,42 @@ class FolderMergeDataTest {
assertEquals(0, opsDao.selectPending(10).size)
}
@Test
fun relance_apres_crash_mi_fusion_reutilise_le_dossier_fusionne() = runTest {
// État après crash à mi-fusion : le dossier fusionné existe déjà (avec
// son `create_resource`), une partie du contenu est déjà déplacée.
folderDao.upsert(folder(ROOT, parent = null))
folderDao.upsert(folder(SRC_A, parent = ROOT))
folderDao.upsert(folder(SRC_B, parent = ROOT))
folderDao.upsert(mergedFolder())
opsDao.insert(createOp(MERGED))
folderDao.upsert(folder(CHILD_A, parent = MERGED))
db.fileDao().upsert(cloudFile(FILE_X, SRC_B))
val report = merger.mergeSelectedFolders(
listOf(
folderDao.getByResourceId(SRC_A)!!,
folderDao.getByResourceId(SRC_B)!!,
),
MERGED_NAME,
)
val merged = folderDao.getAll()
.filter { it.name == MERGED_NAME && it.parentResourceId == ROOT }
assertEquals("aucun dossier fusionné dupliqué à la relance", 1, merged.size)
assertEquals(MERGED, merged[0].resourceId)
assertEquals(
"relance sans second create_resource",
1,
opsDao.selectPending(100).count {
it.operation == PendingOperationType.CREATE_RESOURCE && it.resourceId == MERGED
},
)
assertEquals("contenu restant déplacé", MERGED, db.fileDao().getByResourceId(FILE_X)!!.folderResourceId)
assertEquals("enfant déjà déplacé conservé", MERGED, folderDao.getByResourceId(CHILD_A)!!.parentResourceId)
assertEquals(0, report.failed)
}
@Test
fun hasCreateOperationAnyType_reconnait_les_dossiers_pousses() = runTest {
opsDao.insert(
@@ -168,12 +252,55 @@ class FolderMergeDataTest {
updatedAt = NOW,
)
private fun mergedFolder() = FolderEntity(
resourceId = MERGED,
uri = null,
name = MERGED_NAME,
exists = 1,
parentResourceId = ROOT,
ownerId = OWNER,
syncStatus = "cloud",
addedAt = NOW,
updatedAt = NOW,
)
private fun cloudFile(resourceId: String, folderId: String) = FileEntity(
resourceId = resourceId,
uri = null,
name = "$resourceId.txt",
folderResourceId = folderId,
extension = "txt",
size = 512L,
mimeType = "text/plain",
category = "TEXT",
exists = 1,
syncStatus = "cloud",
processed = true,
addedAt = NOW,
updatedAt = NOW,
)
private fun createOp(resourceId: String, opSuffix: String = "f") = PendingOperationEntity(
operationId = opSuffix.repeat(32).take(32),
resourceId = resourceId,
resourceType = "folder",
operation = PendingOperationType.CREATE_RESOURCE,
payload = "{}",
status = PendingOpStatus.PENDING,
createdAt = NOW,
updatedAt = NOW,
)
private companion object {
const val NOW = 1_700_000_000_000L
const val ROOT = "11111111111111111111111111111111"
const val CHILD_A = "22222222222222222222222222222222"
const val CHILD_B = "33333333333333333333333333333333"
const val MERGED = "44444444444444444444444444444444"
const val SRC_A = "55555555555555555555555555555555"
const val SRC_B = "66666666666666666666666666666666"
const val FILE_X = "cccccccccccccccccccccccccccccccc"
const val MERGED_NAME = "Fusion"
const val OWNER = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
const val FOLDER_ID = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
val ROOT_WITH_MERGED = """{"toFolderResourceId":"$MERGED"}"""
@@ -229,4 +356,26 @@ private class FolderMergeApiService : ApiService {
override suspend fun getFileOcr(
fileId: String,
): Response<ApiEnvelope<FileOcrDto>> = Response.success(ApiEnvelope(data = FileOcrDto(text = "")))
override suspend fun getFile(
fileId: String,
): Response<ApiEnvelope<FileDto>> = Response.success(ApiEnvelope())
override suspend fun deleteFile(
fileId: String,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun searchFiles(
query: String,
page: Int?,
pageSize: Int?,
): Response<ApiEnvelope<List<FileDto>>> = Response.success(ApiEnvelope(data = emptyList()))
override suspend fun changePassword(
body: ChangePasswordDto,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun getShareLink(
token: String,
): Response<ApiEnvelope<ShareLinkDto>> = Response.success(ApiEnvelope())
}
@@ -1,8 +1,13 @@
package com.kazier.mobile.data.repository
import android.content.ContentProvider
import android.content.ContentValues
import android.content.Context
import android.net.Uri
import android.os.Bundle
import androidx.room.Room
import androidx.test.core.app.ApplicationProvider
import com.kazier.mobile.domain.ActiveUserStore
import com.squareup.moshi.Moshi
import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory
import com.kazier.mobile.data.local.AppDatabase
@@ -10,13 +15,17 @@ import com.kazier.mobile.data.local.dao.FileDao
import com.kazier.mobile.data.local.dao.PendingOperationDao
import com.kazier.mobile.data.local.entity.FileEntity
import com.kazier.mobile.data.local.entity.FileStatus
import com.kazier.mobile.data.local.entity.FolderEntity
import com.kazier.mobile.data.local.entity.PendingOperationEntity
import com.kazier.mobile.data.local.entity.PendingOperationType
import com.kazier.mobile.data.local.entity.PendingOpStatus
import com.kazier.mobile.data.remote.ApiClient
import com.kazier.mobile.data.remote.ApiService
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.IdResultDto
import com.kazier.mobile.data.remote.dto.ShareLinkDto
import com.kazier.mobile.data.remote.dto.FileDto
import com.kazier.mobile.data.remote.dto.FileOcrDto
import com.kazier.mobile.data.remote.dto.FolderDto
@@ -28,7 +37,9 @@ import com.kazier.mobile.data.remote.dto.ResolvedUserDto
import com.kazier.mobile.data.remote.dto.ResourcePermissionDto
import com.kazier.mobile.data.remote.dto.SyncOpsRequest
import com.kazier.mobile.data.remote.dto.SyncOpsResult
import com.kazier.mobile.domain.DeviceIdentity
import com.kazier.mobile.domain.GenerateId
import com.kazier.mobile.features.saf.FileMover
import kotlinx.coroutines.test.runTest
import okhttp3.MultipartBody
import okhttp3.RequestBody
@@ -41,6 +52,7 @@ import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
import org.robolectric.shadows.ShadowContentResolver
import retrofit2.Response
/**
@@ -60,6 +72,7 @@ class MoveProtectionTest {
private lateinit var fileRepository: FileRepository
private lateinit var outboxRepository: OutboxRepository
private lateinit var apiService: MoveProtectionApiService
private lateinit var moshi: Moshi
@Before
fun setUp() {
@@ -70,13 +83,19 @@ class MoveProtectionTest {
fileDao = db.fileDao()
opsDao = db.pendingOperationDao()
val moshi = Moshi.Builder().add(KotlinJsonAdapterFactory()).build()
val moshi = Moshi.Builder().add(KotlinJsonAdapterFactory()).build().also { this.moshi = it }
apiService = MoveProtectionApiService()
val apiClient = ApiClient(apiService, moshi)
val generateId = GenerateId()
outboxRepository = OutboxRepository(opsDao, generateId, moshi)
fileRepository = FileRepository(fileDao, apiClient, generateId, db, outboxRepository)
outboxRepository = OutboxRepository(opsDao, generateId, DeviceIdentity(db.userPreferenceDao(), generateId), moshi)
fileRepository = FileRepository(fileDao, db.folderDao(), apiClient, generateId, db, outboxRepository)
// Validation applicative du parent (M18) : les dossiers hôtes existent.
runTest {
db.folderDao().upsert(folderRow(SOURCE_FOLDER, parent = null))
db.folderDao().upsert(folderRow(TARGET_FOLDER, parent = null))
}
}
@After
@@ -186,8 +205,81 @@ class MoveProtectionTest {
assertEquals("la ligne émerge à nouveau", 1, row.exists)
}
// --- prédicats outbox ----------------------------------------------------
// --- applyMove : gate `create` (M2) ---------------------------------------
@Test
fun applyMove_sans_create_ne_journalise_pas_de_move_resource() = runTest {
// Fichier jamais poussé (ni pending ni synced) : le déplacement reste
// purement local, aucun `move_resource` (le serveur ne connaît pas la
// ressource — ce serait NOT_FOUND + ligne figée).
fileDao.upsert(file(SOURCE_FOLDER, exists = 1))
fileRepository.applyMove(FILE_ID, TARGET_FOLDER, null)
assertEquals(TARGET_FOLDER, fileDao.getByResourceId(FILE_ID)!!.folderResourceId)
assertTrue(
"aucun move_resource sans create préalable",
opsDao.selectPending(10).none { it.operation == PendingOperationType.MOVE_RESOURCE },
)
}
@Test
fun applyMove_avec_create_journalise_move_resource() = runTest {
fileDao.upsert(file(SOURCE_FOLDER, exists = 1))
opsDao.insert(
op(
status = PendingOpStatus.PENDING,
operation = PendingOperationType.CREATE_RESOURCE,
),
)
fileRepository.applyMove(FILE_ID, TARGET_FOLDER, NEW_URI)
val row = fileDao.getByResourceId(FILE_ID)!!
assertEquals(TARGET_FOLDER, row.folderResourceId)
assertEquals("l'uri suit le déplacement physique", NEW_URI, row.uri)
val moves = opsDao.selectPending(10)
.filter { it.operation == PendingOperationType.MOVE_RESOURCE && it.resourceId == FILE_ID }
assertEquals(1, moves.size)
}
// --- FileMover : refus SAF → Room inchangée (M3) ---------------------------
@Test
fun moveDocument_refuse_ne_change_pas_room() = runTest {
val context = ApplicationProvider.getApplicationContext<Context>()
// Provider qui refuse toute opération SAF (permission révoquée) :
// DocumentsContract.moveDocument passe par ContentResolver.call().
ShadowContentResolver.registerProviderInternal("com.test", RefusingProvider())
val fakeContext = context
val folderRepository = FolderRepository(
folderDao = db.folderDao(),
apiClient = ApiClient(apiService, moshi),
generateId = GenerateId(),
activeUserStore = ActiveUserStore(db.userPreferenceDao()),
appDatabase = db,
outboxRepository = outboxRepository,
)
val mover = FileMover(fakeContext, fileRepository, folderRepository)
// NB : `@Upsert` Room résout sur la PK, pas sur `resource_id` — pour
// changer l'uri d'une ligne existante, recopier son `id`.
val targetRow = db.folderDao().getByResourceId(TARGET_FOLDER)!!
db.folderDao().upsert(targetRow.copy(uri = TARGET_URI))
fileDao.upsert(file(SOURCE_FOLDER, exists = 1).copy(uri = FILE_URI))
mover.moveFiles(listOf(FILE_ID), TARGET_FOLDER)
val row = fileDao.getByResourceId(FILE_ID)!!
assertEquals("parent local conservé sur refus SAF", SOURCE_FOLDER, row.folderResourceId)
assertEquals("uri locale conservée sur refus SAF", FILE_URI, row.uri)
assertTrue(
"aucune op sur déplacement refusé",
opsDao.selectPending(10).isEmpty(),
)
}
// --- prédicats outbox ----------------------------------------------------
@Test
fun hasPendingMoveOperation_discrimine_pending_seul() = runTest {
opsDao.insert(op(status = PendingOpStatus.PENDING))
@@ -218,6 +310,17 @@ class MoveProtectionTest {
// --- fixtures ------------------------------------------------------------
private fun folderRow(resourceId: String, parent: String?) = FolderEntity(
resourceId = resourceId,
uri = null,
name = resourceId,
exists = 1,
parentResourceId = parent,
syncStatus = FileStatus.LOCAL,
addedAt = NOW,
updatedAt = NOW,
)
private fun file(folderId: String, exists: Int) = FileEntity(
resourceId = FILE_ID,
uri = PRE_MOVE_URI,
@@ -261,9 +364,35 @@ class MoveProtectionTest {
const val SIZE = 1024L
const val MIME = "text/plain"
const val PRE_MOVE_URI = "content://tree/11111111111111111111111111111111/doc"
const val FILE_URI = "content://com.test/tree/root/document/f1"
const val TARGET_URI = "content://com.test/tree/root/document/target"
const val NEW_URI = "content://com.test/tree/root/document/target/f1"
}
}
/** Provider qui refuse toute opération SAF (permission révoquée). */
private class RefusingProvider : ContentProvider() {
override fun onCreate(): Boolean = true
override fun call(authority: String, method: String, arg: String?, extras: Bundle?): Bundle? =
throw SecurityException("persisted permission revoked")
override fun query(
uri: Uri,
projection: Array<out String>?,
selection: String?,
selectionArgs: Array<out String>?,
sortOrder: String?,
): android.database.Cursor? = null
override fun getType(uri: Uri): String? = null
override fun insert(uri: Uri, values: ContentValues?): Uri? = null
override fun delete(uri: Uri, selection: String?, selectionArgs: Array<out String>?): Int = 0
override fun update(
uri: Uri,
values: ContentValues?,
selection: String?,
selectionArgs: Array<out String>?,
): Int = 0
}
/** Fake `ApiService` — seul `listFiles` est réellement consommé. */
private class MoveProtectionApiService : ApiService {
var files: List<FileDto> = emptyList()
@@ -316,4 +445,26 @@ private class MoveProtectionApiService : ApiService {
override suspend fun getFileOcr(
fileId: String,
): Response<ApiEnvelope<FileOcrDto>> = Response.success(ApiEnvelope(data = FileOcrDto(text = "")))
override suspend fun getFile(
fileId: String,
): Response<ApiEnvelope<FileDto>> = Response.success(ApiEnvelope())
override suspend fun deleteFile(
fileId: String,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun searchFiles(
query: String,
page: Int?,
pageSize: Int?,
): Response<ApiEnvelope<List<FileDto>>> = Response.success(ApiEnvelope(data = emptyList()))
override suspend fun changePassword(
body: ChangePasswordDto,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun getShareLink(
token: String,
): Response<ApiEnvelope<ShareLinkDto>> = Response.success(ApiEnvelope())
}
@@ -13,7 +13,10 @@ import com.kazier.mobile.data.local.entity.FileStatus
import com.kazier.mobile.data.remote.ApiClient
import com.kazier.mobile.data.remote.ApiService
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.IdResultDto
import com.kazier.mobile.data.remote.dto.ShareLinkDto
import com.kazier.mobile.data.remote.dto.FileDto
import com.kazier.mobile.data.remote.dto.FileOcrDto
import com.kazier.mobile.data.remote.dto.FolderDto
@@ -336,6 +339,28 @@ private class OcrApiServiceFake : ApiService {
return Response.success(ApiEnvelope(data = fileOcr))
}
override suspend fun getFile(
fileId: String,
): Response<ApiEnvelope<FileDto>> = Response.success(ApiEnvelope())
override suspend fun deleteFile(
fileId: String,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun searchFiles(
query: String,
page: Int?,
pageSize: Int?,
): Response<ApiEnvelope<List<FileDto>>> = Response.success(ApiEnvelope(data = emptyList()))
override suspend fun changePassword(
body: ChangePasswordDto,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun getShareLink(
token: String,
): Response<ApiEnvelope<ShareLinkDto>> = Response.success(ApiEnvelope())
private fun readBody(body: RequestBody): String {
val buffer = okio.Buffer()
body.writeTo(buffer)
@@ -0,0 +1,237 @@
package com.kazier.mobile.data.repository
import android.content.Context
import androidx.room.Room
import androidx.test.core.app.ApplicationProvider
import com.squareup.moshi.Moshi
import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory
import com.kazier.mobile.data.local.AppDatabase
import com.kazier.mobile.data.local.dao.FolderDao
import com.kazier.mobile.data.local.dao.PendingOperationDao
import com.kazier.mobile.data.local.entity.FolderEntity
import com.kazier.mobile.data.local.entity.PendingOperationEntity
import com.kazier.mobile.data.local.entity.PendingOperationType
import com.kazier.mobile.data.local.entity.PendingOpStatus
import com.kazier.mobile.data.remote.ApiClient
import com.kazier.mobile.data.remote.ApiService
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 com.kazier.mobile.domain.ActiveUserStore
import com.kazier.mobile.domain.DeviceIdentity
import com.kazier.mobile.domain.GenerateId
import kotlinx.coroutines.test.runTest
import okhttp3.MultipartBody
import okhttp3.RequestBody
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
import retrofit2.Response
/**
* Garde-fou refresh serveur vs reparent local (miroir dossiers du
* `MoveProtectionTest` fichiers) : tant qu'un `move_resource` dossier est en
* attente de push, `refreshFromServer` ne doit pas ré-attribuer l'ancien
* parent renvoyé par le serveur. Une fois l'op soldée (ou jamais journalisée),
* le serveur redevient source de vérité.
*/
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34])
class RefreshVsMoveTest {
private lateinit var db: AppDatabase
private lateinit var folderDao: FolderDao
private lateinit var opsDao: PendingOperationDao
private lateinit var folderRepository: FolderRepository
private lateinit var outboxRepository: OutboxRepository
private lateinit var apiService: RefreshVsMoveApiService
@Before
fun setUp() {
val context = ApplicationProvider.getApplicationContext<Context>()
db = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java)
.allowMainThreadQueries()
.build()
folderDao = db.folderDao()
opsDao = db.pendingOperationDao()
val moshi = Moshi.Builder().add(KotlinJsonAdapterFactory()).build()
apiService = RefreshVsMoveApiService()
val generateId = GenerateId()
outboxRepository = OutboxRepository(
opsDao,
generateId,
DeviceIdentity(db.userPreferenceDao(), generateId),
moshi,
)
folderRepository = FolderRepository(
folderDao = folderDao,
apiClient = ApiClient(apiService, moshi),
generateId = generateId,
activeUserStore = ActiveUserStore(db.userPreferenceDao()),
appDatabase = db,
outboxRepository = outboxRepository,
)
}
@After
fun tearDown() {
db.close()
}
@Test
fun reparent_pending_le_pull_ancien_parent_conserve_le_local() = runTest {
// Placement local : le dossier est déjà sous TARGET (reparent/merge).
folderDao.upsert(folder(CHILD, parent = TARGET))
// L'op move_resource n'a pas encore été poussée.
opsDao.insert(moveOp(status = PendingOpStatus.PENDING))
// Le serveur renvoie encore l'ancien parent (op pas appliquée).
apiService.folders = listOf(FolderDto(id = CHILD, name = NAME, parentId = SOURCE))
folderRepository.refreshFromServer()
assertEquals(
"placement local cible préservé",
TARGET,
folderDao.getByResourceId(CHILD)!!.parentResourceId,
)
}
@Test
fun refresh_sans_move_pending_suit_le_serveur() = runTest {
folderDao.upsert(folder(CHILD, parent = TARGET))
apiService.folders = listOf(FolderDto(id = CHILD, name = NAME_RENAMED, parentId = SOURCE))
folderRepository.refreshFromServer()
val row = folderDao.getByResourceId(CHILD)!!
assertEquals("le serveur redevient source de vérité", SOURCE, row.parentResourceId)
assertEquals("métadonnées serveur prises en compte", NAME_RENAMED, row.name)
}
// --- fixtures ------------------------------------------------------------
private fun folder(resourceId: String, parent: String?) = FolderEntity(
resourceId = resourceId,
uri = null,
name = resourceId,
exists = 1,
parentResourceId = parent,
syncStatus = "local",
addedAt = NOW,
updatedAt = NOW,
)
private fun moveOp(status: String) = PendingOperationEntity(
operationId = "e".repeat(32),
resourceId = CHILD,
resourceType = "folder",
operation = PendingOperationType.MOVE_RESOURCE,
payload = """{"toFolderResourceId":"$TARGET"}""",
status = status,
createdAt = NOW,
updatedAt = NOW,
)
private companion object {
const val NOW = 1_700_000_000_000L
const val SOURCE = "11111111111111111111111111111111"
const val TARGET = "22222222222222222222222222222222"
const val CHILD = "33333333333333333333333333333333"
const val NAME = "Enfant"
const val NAME_RENAMED = "Enfant renomme"
}
}
/** Fake `ApiService` — seul `listFolders` est réellement consommé. */
private class RefreshVsMoveApiService : ApiService {
var folders: List<FolderDto> = emptyList()
override suspend fun listFolders(): Response<ApiEnvelope<List<FolderDto>>> =
Response.success(ApiEnvelope(data = folders))
override suspend fun listFiles(
folderId: String?,
page: Int?,
pageSize: Int?,
): Response<ApiEnvelope<List<FileDto>>> = Response.success(ApiEnvelope(data = emptyList()))
override suspend fun registerDevice(
body: DeviceRegistrationDto,
): Response<ApiEnvelope<DeviceRegistrationDto>> =
Response.success(ApiEnvelope(data = body))
override suspend fun login(
body: LoginRequestDto,
): Response<ApiEnvelope<LoginResponseDto>> = Response.success(ApiEnvelope())
override suspend fun syncOps(
body: SyncOpsRequest,
): Response<ApiEnvelope<SyncOpsResult>> = Response.success(ApiEnvelope(data = SyncOpsResult(applied = 0)))
override suspend fun resolveUser(
username: String,
): Response<ApiEnvelope<ResolvedUserDto>> = Response.success(ApiEnvelope())
override suspend fun syncPermissions(
after: Long?,
): Response<ApiEnvelope<List<ResourcePermissionDto>>> =
Response.success(ApiEnvelope(data = emptyList()))
override suspend fun uploadFile(
file: MultipartBody.Part,
resourceId: RequestBody?,
folderId: RequestBody?,
): Response<ApiEnvelope<FileDto>> = Response.success(ApiEnvelope())
override suspend fun submitOcr(
body: OcrSubmitDto,
): Response<ApiEnvelope<OcrJobDto>> = Response.success(ApiEnvelope())
override suspend fun getOcrJob(
jobId: String,
): Response<ApiEnvelope<OcrJobDto>> = Response.success(ApiEnvelope())
override suspend fun getFileOcr(
fileId: String,
): Response<ApiEnvelope<FileOcrDto>> = Response.success(ApiEnvelope(data = FileOcrDto(text = "")))
override suspend fun getFile(
fileId: String,
): Response<ApiEnvelope<FileDto>> = Response.success(ApiEnvelope())
override suspend fun deleteFile(
fileId: String,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun searchFiles(
query: String,
page: Int?,
pageSize: Int?,
): Response<ApiEnvelope<List<FileDto>>> = Response.success(ApiEnvelope(data = emptyList()))
override suspend fun changePassword(
body: ChangePasswordDto,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun getShareLink(
token: String,
): Response<ApiEnvelope<ShareLinkDto>> = Response.success(ApiEnvelope())
}
@@ -15,7 +15,10 @@ import com.kazier.mobile.data.local.entity.FolderEntity
import com.kazier.mobile.data.remote.ApiClient
import com.kazier.mobile.data.remote.ApiService
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.IdResultDto
import com.kazier.mobile.data.remote.dto.ShareLinkDto
import com.kazier.mobile.data.remote.dto.FileDto
import com.kazier.mobile.data.remote.dto.FileOcrDto
import com.kazier.mobile.data.remote.dto.FolderDto
@@ -27,8 +30,7 @@ import com.kazier.mobile.data.remote.dto.ResolvedUserDto
import com.kazier.mobile.data.remote.dto.ResourcePermissionDto
import com.kazier.mobile.data.remote.dto.SyncOpsRequest
import com.kazier.mobile.data.remote.dto.SyncOpsResult
import com.kazier.mobile.domain.DeviceIdentity
import com.kazier.mobile.domain.GenerateId
import com.kazier.mobile.domain.ActiveUserStore
import kotlinx.coroutines.test.runTest
import okhttp3.MultipartBody
import okhttp3.RequestBody
@@ -63,6 +65,7 @@ class ShareRepositoryTest {
private lateinit var fileDao: FileDao
private lateinit var shareRepository: ShareRepository
private lateinit var apiService: FakeApiService
private lateinit var activeUserStore: ActiveUserStore
@Before
fun setUp() {
@@ -76,9 +79,9 @@ class ShareRepositoryTest {
val moshi = Moshi.Builder().add(KotlinJsonAdapterFactory()).build()
apiService = FakeApiService()
val apiClient = ApiClient(apiService, moshi)
val deviceIdentity = DeviceIdentity(db.userPreferenceDao(), GenerateId())
activeUserStore = ActiveUserStore(db.userPreferenceDao())
shareRepository = ShareRepository(apiClient, db, deviceIdentity)
shareRepository = ShareRepository(apiClient, db, activeUserStore)
}
@After
@@ -154,6 +157,7 @@ class ShareRepositoryTest {
@Test
fun absence_du_snapshot_marque_la_ressource_partagee_disparue() = runTest {
activeUserStore.set(CURRENT_USER)
folderDao.upsert(
folder(FOLDER_ID, uri = null, ownerId = OTHER_USER),
)
@@ -166,6 +170,53 @@ class ShareRepositoryTest {
assertNull(folder.uri)
}
@Test
fun fichier_d_autrui_absent_du_snapshot_marque_disparu() = runTest {
activeUserStore.set(CURRENT_USER)
fileDao.upsert(
sharedFile(FILE_ID, ownerId = OTHER_USER),
)
apiService.permissions = emptyList()
shareRepository.syncSnapshot()
assertEquals(0, fileDao.getByResourceId(FILE_ID)!!.exists)
}
@Test
fun ligne_cloud_only_possedee_jamais_marquee_disparue() = runTest {
// M23 : le snapshot exclut les ressources possédées → une ligne
// cloud-only propre (ownerId = user actif) ne doit jamais être
// markMissing sur snapshot vide.
activeUserStore.set(CURRENT_USER)
folderDao.upsert(
folder(FOLDER_ID, uri = null, ownerId = CURRENT_USER),
)
fileDao.upsert(
sharedFile(FILE_ID, ownerId = CURRENT_USER),
)
apiService.permissions = emptyList()
shareRepository.syncSnapshot()
assertEquals(1, folderDao.getByResourceId(FOLDER_ID)!!.exists)
assertEquals(1, fileDao.getByResourceId(FILE_ID)!!.exists)
}
@Test
fun sans_compte_actif_aucune_ligne_masquee() = runTest {
// Pas de user actif (mode local) : impossible d'attribuer les lignes
// cloud-only → convergence désactivée, rien n'est marqué disparu.
folderDao.upsert(
folder(FOLDER_ID, uri = null, ownerId = OTHER_USER),
)
apiService.permissions = emptyList()
shareRepository.syncSnapshot()
assertEquals(1, folderDao.getByResourceId(FOLDER_ID)!!.exists)
}
@Test
fun ligne_cloud_only_propre_non_touchee_par_convergence() = runTest {
// Une ligne cloud-only dont `ownerId` est NULL (pas encore typée) ne
@@ -210,8 +261,23 @@ class ShareRepositoryTest {
updatedAt = NOW,
)
private fun sharedFile(id: String, ownerId: String?) = FileEntity(
resourceId = id.padEnd(32, '0'),
uri = null,
name = id,
folderResourceId = FOLDER_ID,
size = 1,
exists = 1,
ownerId = ownerId,
syncStatus = FileStatus.CLOUD,
processed = true,
addedAt = NOW,
updatedAt = NOW,
)
private companion object {
const val NOW = 1_700_000_000_000L
const val CURRENT_USER = "00000000000000000000000000000001"
const val OTHER_USER = "11111111111111111111111111111111"
const val OWNER_ID = "22222222222222222222222222222222"
const val FOLDER_ID = "f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0"
@@ -273,4 +339,26 @@ private class FakeApiService : ApiService {
override suspend fun getFileOcr(
fileId: String,
): Response<ApiEnvelope<FileOcrDto>> = Response.success(ApiEnvelope(data = FileOcrDto(text = "")))
override suspend fun getFile(
fileId: String,
): Response<ApiEnvelope<FileDto>> = Response.success(ApiEnvelope())
override suspend fun deleteFile(
fileId: String,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun searchFiles(
query: String,
page: Int?,
pageSize: Int?,
): Response<ApiEnvelope<List<FileDto>>> = Response.success(ApiEnvelope(data = emptyList()))
override suspend fun changePassword(
body: ChangePasswordDto,
): Response<ApiEnvelope<IdResultDto>> = Response.success(ApiEnvelope())
override suspend fun getShareLink(
token: String,
): Response<ApiEnvelope<ShareLinkDto>> = Response.success(ApiEnvelope())
}
@@ -0,0 +1,67 @@
package com.kazier.mobile.domain
import android.content.Context
import androidx.room.Room
import androidx.test.core.app.ApplicationProvider
import com.kazier.mobile.data.local.AppDatabase
import kotlinx.coroutines.async
import kotlinx.coroutines.awaitAll
import kotlinx.coroutines.test.runTest
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
/**
* Contrat DeviceIdentity (M10) : `getOrCreate()` est atomique et ne renvoie
* jamais d'ID fantôme (non persisté).
* - appels concurrents → un seul ID persisté, tous les appelants le reçoivent ;
* - la valeur relue en DB est l'ID renvoyé ;
* - l'ID est un 32-hex valide.
*/
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34])
class DeviceIdentityTest {
private lateinit var db: AppDatabase
private lateinit var deviceIdentity: DeviceIdentity
@Before
fun setUp() {
val context = ApplicationProvider.getApplicationContext<Context>()
db = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java)
.allowMainThreadQueries()
.build()
deviceIdentity = DeviceIdentity(db.userPreferenceDao(), GenerateId())
}
@After
fun tearDown() {
db.close()
}
@Test
fun appels_concurrents_un_seul_id_persiste_jamais_de_fantome() = runTest {
val ids = (1..50).map {
async { deviceIdentity.getOrCreate() }
}.awaitAll()
val distinct = ids.toSet()
assertEquals("un seul ID pour 50 appels concurrents", 1, distinct.size)
val persisted = db.userPreferenceDao().getValue(PrefKeys.DEVICE_USER_ID)
assertEquals("l'ID renvoyé est celui persisté (pas de fantôme)", ids.first(), persisted)
assertTrue("32-hex valide", Regex("^[0-9a-f]{32}$").matches(ids.first()))
}
@Test
fun second_appel_relit_sans_regenerer() = runTest {
val first = deviceIdentity.getOrCreate()
val second = deviceIdentity.getOrCreate()
assertEquals(first, second)
}
}
@@ -0,0 +1,34 @@
package com.kazier.mobile.domain
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Test
/**
* Contrat GenerateId (C1) : tout ID généré est un 32-hex minuscule
* (`^[0-9a-f]{32}$`, CHECK-enforced côté serveur, cf. docs/api-v1.md §2).
*
* Non-régression de la sign-extension `Byte` → `%02x` : tout octet >= 0x80
* produisait `ffffffxx` (8 chars) au lieu de 2. Sur 10k IDs, des octets
* négatifs sont statistiquement garantis.
*/
class GenerateIdTest {
private val generateId = GenerateId()
private val hex32 = Regex("^[0-9a-f]{32}$")
@Test
fun dix_mille_ids_sont_tous_32_hex() {
repeat(10_000) { i ->
val id = generateId.newResourceId()
assertEquals("ID #$i : longueur 32", 32, id.length)
assertTrue("ID #$i : 32-hex minuscule ($id)", hex32.matches(id))
}
}
@Test
fun ids_successifs_distincts() {
val ids = List(1_000) { generateId.newResourceId() }.toSet()
assertEquals(1_000, ids.size)
}
}
@@ -0,0 +1,452 @@
package com.kazier.mobile.features.sync
import android.content.Context
import androidx.room.Room
import androidx.test.core.app.ApplicationProvider
import androidx.work.Data
import androidx.work.ForegroundUpdater
import androidx.work.ListenableWorker
import androidx.work.ProgressUpdater
import androidx.work.WorkerFactory
import androidx.work.WorkerParameters
import androidx.work.impl.utils.taskexecutor.SerialExecutor
import androidx.work.impl.utils.taskexecutor.TaskExecutor
import com.squareup.moshi.JsonAdapter
import com.squareup.moshi.Moshi
import com.squareup.moshi.Types
import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory
import com.kazier.mobile.auth.TokenProvider
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.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
import com.kazier.mobile.data.remote.ApiException
import com.kazier.mobile.data.remote.ApiService
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.SyncFailedDto
import com.kazier.mobile.data.remote.dto.SyncOpsRequest
import com.kazier.mobile.data.remote.dto.SyncOpsResult
import com.kazier.mobile.data.repository.OutboxRepository
import com.kazier.mobile.domain.DeviceIdentity
import com.kazier.mobile.domain.GenerateId
import java.util.UUID
import java.util.concurrent.Executor
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.test.runTest
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.MultipartBody
import okhttp3.RequestBody
import okhttp3.ResponseBody.Companion.toResponseBody
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Assert.fail
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
import retrofit2.Response
/**
* Protocole outbox (lot B) : le drain `POST /sync/ops` doit suivre le contrat
* `docs/api-v1.md §6.1` (séquentiel, stop à la 1re erreur, reprise à l'index).
*
* Couverts : C2 (retry sans dead-letter sur batch-level/transitoire), C6
* (stop au 1er échec + cascade enfants via `payload.parentResourceId`), C7
* (gardes anti-boucle/crash), M22 (CancellationException remonte), M24
* (`expiresAt` entier exact).
*/
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34])
class OutboxSyncWorkerTest {
private lateinit var db: AppDatabase
private lateinit var opsDao: PendingOperationDao
private lateinit var fileDao: FileDao
private lateinit var folderDao: FolderDao
private lateinit var moshi: Moshi
private lateinit var payloadAdapter: JsonAdapter<Map<String, Any?>>
private lateinit var fake: FakeApiService
private lateinit var apiClient: ApiClient
private lateinit var tokenProvider: TokenProvider
private lateinit var worker: OutboxSyncWorker
@Before
fun setUp() {
val context = ApplicationProvider.getApplicationContext<Context>()
db = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java)
.allowMainThreadQueries()
.build()
opsDao = db.pendingOperationDao()
fileDao = db.fileDao()
folderDao = db.folderDao()
moshi = Moshi.Builder().add(KotlinJsonAdapterFactory()).build()
payloadAdapter = moshi.adapter(
Types.newParameterizedType(Map::class.java, String::class.java, Any::class.java),
)
fake = FakeApiService()
apiClient = ApiClient(fake, moshi)
tokenProvider = TokenProvider().apply { current = "test-token" }
worker = OutboxSyncWorker(
context, workerParams(), apiClient, opsDao, fileDao, folderDao,
tokenProvider, moshi,
)
}
@After
fun tearDown() {
db.close()
}
// --- C2 : batch-level / transitoire → retry, jamais de dead-letter ------
@Test
fun reponse_200_sans_data_retry_sans_deadletter() = runTest {
insertOp(opId(1))
fake.syncOpsHandler = { Response.success(ApiEnvelope<SyncOpsResult>(data = null)) }
val result = worker.doWork()
assertTrue("200 sans {data} → retry, pas failed", result is ListenableWorker.Result.Retry)
assertEquals(1, opsDao.countPending())
}
@Test
fun erreur_429_retry_sans_deadletter() = runTest {
assertRetryOnHttpError(429)
}
@Test
fun erreur_408_retry_sans_deadletter() = runTest {
assertRetryOnHttpError(408)
}
private suspend fun assertRetryOnHttpError(code: Int) {
insertOp(opId(1))
insertOp(opId(2))
fake.syncOpsHandler = { httpError(code) }
val result = worker.doWork()
assertTrue("HTTP $code → retry, pas failed", result is ListenableWorker.Result.Retry)
assertEquals(2, opsDao.countPending())
}
// --- C6 : stop au 1er échec + cascade ------------------------------------
@Test
fun echec_op2_sur_20_seule_op2_failed_et_stop() = runTest {
val ids = (1..20).map { opId(it) }
ids.forEachIndexed { i, id ->
insertOp(operationId = id, resourceId = resId(i + 1))
}
var calls = 0
fake.syncOpsHandler = { req ->
calls++
assertEquals(20, req.operations.size)
opsResult(applied = 1, failed = SyncFailedDto(ids[1], "NAME_CONFLICT", "nom pris"))
}
val result = worker.doWork()
assertTrue(result is ListenableWorker.Result.Success)
assertEquals("stop au 1er échec : un seul batch envoyé", 1, calls)
val byOp = opsDao.observeRecent(100).first().associateBy { it.operationId }
assertEquals(PendingOpStatus.SYNCED, byOp[ids[0]]!!.status)
assertEquals(PendingOpStatus.FAILED, byOp[ids[1]]!!.status)
ids.drop(2).forEach { id ->
assertEquals("op $id reste pending (run stoppé)", PendingOpStatus.PENDING, byOp[id]!!.status)
}
}
@Test
fun echec_create_parent_cascade_enfant_via_parentResourceId() = runTest {
val parent = "p".repeat(32)
val child = "c".repeat(32)
val sibling = "s".repeat(32)
insertOp(
operationId = opId(1), resourceId = parent,
payload = """{"name":"parent"}""",
)
insertOp(
operationId = opId(2), resourceId = child,
payload = """{"name":"enfant","parentResourceId":"$parent"}""",
)
insertOp(
operationId = opId(3), resourceId = sibling,
payload = """{"name":"voisin"}""",
)
var calls = 0
fake.syncOpsHandler = { _ ->
calls++
opsResult(applied = 0, failed = SyncFailedDto(opId(1), "NOT_FOUND", "parent inconnu"))
}
val result = worker.doWork()
assertTrue(result is ListenableWorker.Result.Success)
assertEquals(1, calls)
val byOp = opsDao.observeRecent(100).first().associateBy { it.operationId }
assertEquals(PendingOpStatus.FAILED, byOp[opId(1)]!!.status)
assertEquals("l'enfant (autre resource_id) est cascadé", PendingOpStatus.FAILED, byOp[opId(2)]!!.status)
assertEquals("le voisin est intact", PendingOpStatus.PENDING, byOp[opId(3)]!!.status)
}
// --- C7 : gardes ----------------------------------------------------------
@Test
fun failed_inconnu_pas_de_boucle() = runTest {
insertOp(opId(1))
insertOp(opId(2))
var calls = 0
fake.syncOpsHandler = { _ ->
calls++
opsResult(applied = 0, failed = SyncFailedDto("f".repeat(32), "X", "inconnu"))
}
val result = worker.doWork()
assertTrue("failed inconnu → sortie, pas de boucle", result is ListenableWorker.Result.Success)
assertEquals(1, calls)
assertEquals(2, opsDao.countPending())
}
@Test
fun applied_superieur_taille_pas_de_crash() = runTest {
insertOp(opId(1))
insertOp(opId(2))
insertOp(opId(3))
var calls = 0
fake.syncOpsHandler = { _ ->
calls++
opsResult(applied = 999, failed = null)
}
val result = worker.doWork()
assertTrue(result is ListenableWorker.Result.Success)
assertEquals(1, calls)
assertEquals("tout le batch est acquitté (clamp), sans crash", 0, opsDao.countPending())
}
@Test
fun applied_zero_sans_failed_sortie() = runTest {
insertOp(opId(1))
insertOp(opId(2))
var calls = 0
fake.syncOpsHandler = { _ ->
calls++
opsResult(applied = 0, failed = null)
}
val result = worker.doWork()
assertTrue("applied=0 sans failed → sortie, pas de busy-loop", result is ListenableWorker.Result.Success)
assertEquals(1, calls)
assertEquals(2, opsDao.countPending())
}
// --- M22 : annulation -----------------------------------------------------
@Test
fun cancellation_exception_remonte() = runTest {
insertOp(opId(1))
fake.syncOpsHandler = { throw CancellationException("annulé") }
try {
worker.doWork()
fail("CancellationException attendue, pas de conversion")
} catch (e: CancellationException) {
// Attendu : remonte telle quelle (M22).
} catch (e: ApiException) {
fail("l'annulation ne doit pas devenir ApiException (${e.code})")
}
assertEquals(1, opsDao.countPending())
}
// --- M24 : expiresAt entier exact -----------------------------------------
@Test
fun share_expiresAt_entier_exact() = runTest {
val outbox = OutboxRepository(
opsDao, GenerateId(),
DeviceIdentity(db.userPreferenceDao(), GenerateId()), moshi,
)
val resourceId = "a".repeat(32)
val opId = outbox.enqueueShare(
resourceId = resourceId,
resourceType = "folder",
granteeUserId = "b".repeat(32),
access = "viewer",
expiresAt = EXPIRES_AT,
)
val stored = opsDao.selectPending(10).first { it.operationId == opId }
assertTrue(
"payload stocké entier exact, pas de notation E",
stored.payload.contains("\"expiresAt\":$EXPIRES_AT"),
)
// Round-trip worker : décodage Moshi (Double) → normalisation (Long).
val decoded = payloadAdapter.fromJson(stored.payload)!!
val normalized = normalizePayloadNumbers(decoded)
assertEquals(EXPIRES_AT, normalized["expiresAt"])
assertTrue(
"re-sérialisation entière exacte",
payloadAdapter.toJson(normalized).contains("\"expiresAt\":$EXPIRES_AT"),
)
}
// --- fixtures --------------------------------------------------------------
private suspend fun insertOp(
operationId: String,
resourceId: String = "r".repeat(31) + operationId.takeLast(1),
resourceType: String = "folder",
operation: String = PendingOperationType.CREATE_RESOURCE,
payload: String = "{}",
status: String = PendingOpStatus.PENDING,
) {
opsDao.insert(
PendingOperationEntity(
operationId = operationId,
resourceId = resourceId,
resourceType = resourceType,
operation = operation,
payload = payload,
status = status,
createdAt = NOW,
updatedAt = NOW,
),
)
}
private fun opId(i: Int): String = "%032x".format(i)
private fun resId(i: Int): String = "abcd" + "%028x".format(i)
private fun opsResult(applied: Int, failed: SyncFailedDto?): Response<ApiEnvelope<SyncOpsResult>> =
Response.success(ApiEnvelope(data = SyncOpsResult(applied, failed)))
private fun httpError(code: Int): Response<ApiEnvelope<SyncOpsResult>> =
Response.error(code, "{}".toResponseBody("application/json".toMediaType()))
private fun workerParams(): WorkerParameters {
val direct = Executor { command -> command.run() }
val taskExecutor = object : TaskExecutor {
override fun getMainThreadExecutor(): Executor = direct
override fun getSerialTaskExecutor(): SerialExecutor =
object : SerialExecutor {
override fun hasPendingTasks(): Boolean = false
override fun execute(command: Runnable) {
command.run()
}
}
}
return WorkerParameters(
UUID.randomUUID(),
Data.EMPTY,
emptyList(),
WorkerParameters.RuntimeExtras(),
0,
0,
direct,
taskExecutor,
WorkerFactory.getDefaultWorkerFactory(),
ProgressUpdater { _, _, _ -> throw UnsupportedOperationException() },
ForegroundUpdater { _, _, _ -> throw UnsupportedOperationException() },
)
}
private companion object {
const val NOW = 1_700_000_000_000L
const val EXPIRES_AT = 1_700_000_000_000L
}
/** Fake piloté : seul `syncOps` est scripté, le reste est hors scope. */
private class FakeApiService : ApiService {
lateinit var syncOpsHandler: suspend (SyncOpsRequest) -> Response<ApiEnvelope<SyncOpsResult>>
override suspend fun syncOps(body: SyncOpsRequest): Response<ApiEnvelope<SyncOpsResult>> =
syncOpsHandler(body)
override suspend fun listFolders(): Response<ApiEnvelope<List<FolderDto>>> =
throw UnsupportedOperationException()
override suspend fun listFiles(
folderId: String?,
page: Int?,
pageSize: Int?,
): Response<ApiEnvelope<List<FileDto>>> = throw UnsupportedOperationException()
override suspend fun registerDevice(
body: DeviceRegistrationDto,
): Response<ApiEnvelope<DeviceRegistrationDto>> = throw UnsupportedOperationException()
override suspend fun login(
body: LoginRequestDto,
): Response<ApiEnvelope<LoginResponseDto>> = throw UnsupportedOperationException()
override suspend fun resolveUser(
username: String,
): Response<ApiEnvelope<ResolvedUserDto>> = throw UnsupportedOperationException()
override suspend fun syncPermissions(
after: Long?,
): Response<ApiEnvelope<List<ResourcePermissionDto>>> = throw UnsupportedOperationException()
override suspend fun uploadFile(
file: MultipartBody.Part,
resourceId: RequestBody?,
folderId: RequestBody?,
): Response<ApiEnvelope<FileDto>> = throw UnsupportedOperationException()
override suspend fun submitOcr(body: OcrSubmitDto): Response<ApiEnvelope<OcrJobDto>> =
throw UnsupportedOperationException()
override suspend fun getOcrJob(jobId: String): Response<ApiEnvelope<OcrJobDto>> =
throw UnsupportedOperationException()
override suspend fun getFileOcr(fileId: String): Response<ApiEnvelope<FileOcrDto>> =
throw UnsupportedOperationException()
override suspend fun getFile(fileId: String): Response<ApiEnvelope<FileDto>> =
throw UnsupportedOperationException()
override suspend fun deleteFile(fileId: String): Response<ApiEnvelope<IdResultDto>> =
throw UnsupportedOperationException()
override suspend fun searchFiles(
query: String,
page: Int?,
pageSize: Int?,
): Response<ApiEnvelope<List<FileDto>>> = throw UnsupportedOperationException()
override suspend fun changePassword(
body: ChangePasswordDto,
): Response<ApiEnvelope<IdResultDto>> = throw UnsupportedOperationException()
override suspend fun getShareLink(token: String): Response<ApiEnvelope<ShareLinkDto>> =
throw UnsupportedOperationException()
}
}
@@ -0,0 +1,149 @@
package com.kazier.mobile.features.sync
import android.content.ContentProvider
import android.content.ContentValues
import android.content.Context
import android.database.Cursor
import android.database.MatrixCursor
import android.net.Uri
import android.provider.DocumentsContract
import androidx.test.core.app.ApplicationProvider
import kotlinx.coroutines.test.runTest
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
import org.robolectric.shadows.ShadowContentResolver
/**
* Garde-fous du walk SAF (lot D) :
* - permission révoquée → résultat propre (racine vide), jamais de crash ;
* - curseur dégénéré (colonne DOCUMENT_ID absente, valeurs nulles) → dossier
* vu vide, pas de crash ;
* - fichiers 0-octet → importés comme les autres (review + push au « garder »).
*/
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34])
class SafScannerTest {
private lateinit var appContext: Context
private val treeUri: Uri = Uri.parse("content://com.kazier.test/tree/rootDoc")
@Before
fun setUp() {
appContext = ApplicationProvider.getApplicationContext()
}
@Test
fun permission_perdue_retourne_une_racine_vide_sans_crash() = runTest {
val scanner = scannerWith { throw SecurityException("persisted permission revoked") }
val nodes = scanner.scanTree(treeUri)
assertEquals("la racine reste listée (vide), sans exception", 1, nodes.size)
assertTrue(nodes[0].files.isEmpty())
}
@Test
fun curseur_degenere_sans_colonne_document_id_ne_crash_pas() = runTest {
val scanner = scannerWith { uri ->
if (isChildrenQuery(uri)) {
MatrixCursor(arrayOf(DocumentsContract.Document.COLUMN_DISPLAY_NAME)).apply {
addRow(arrayOf<Any?>(null))
}
} else {
nameCursor("Root")
}
}
val nodes = scanner.scanTree(treeUri)
assertEquals(1, nodes.size)
assertTrue("dossier dégénéré vu vide", nodes[0].files.isEmpty())
}
@Test
fun fichier_zero_octet_importe() = runTest {
val scanner = scannerWith { uri ->
if (isChildrenQuery(uri) && uri.toString().contains("rootDoc")) {
MatrixCursor(
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,
),
).apply {
addRow(arrayOf<Any?>("rootDoc:empty.txt", "empty.txt", "text/plain", 0L, 123L))
addRow(
arrayOf<Any?>(
"rootDoc:sub",
"sub",
DocumentsContract.Document.MIME_TYPE_DIR,
0L,
null,
),
)
}
} else if (isChildrenQuery(uri)) {
MatrixCursor(
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,
),
)
} else {
nameCursor("Root")
}
}
val nodes = scanner.scanTree(treeUri)
assertEquals("racine + sous-dossier", 2, nodes.size)
val root = nodes.first { it.parentUri == null }
assertEquals(1, root.files.size)
assertEquals("empty.txt", root.files[0].name)
assertEquals("les 0-octet sont importés, pas exclus", 0L, root.files[0].size)
}
// --- fakes ---------------------------------------------------------------
private fun scannerWith(handler: (Uri) -> Cursor?): SafScanner {
val provider = object : ContentProvider() {
override fun onCreate(): Boolean = true
override fun query(
uri: Uri,
projection: Array<out String>?,
selection: String?,
selectionArgs: Array<out String>?,
sortOrder: String?,
): Cursor? = handler(uri)
override fun getType(uri: Uri): String? = null
override fun insert(uri: Uri, values: ContentValues?): Uri? = null
override fun delete(uri: Uri, selection: String?, selectionArgs: Array<out String>?): Int = 0
override fun update(
uri: Uri,
values: ContentValues?,
selection: String?,
selectionArgs: Array<out String>?,
): Int = 0
}
ShadowContentResolver.registerProviderInternal("com.kazier.test", provider)
return SafScanner(appContext)
}
private fun isChildrenQuery(uri: Uri): Boolean =
uri.pathSegments.contains("children")
private fun nameCursor(name: String): Cursor =
MatrixCursor(arrayOf(DocumentsContract.Document.COLUMN_DISPLAY_NAME)).apply {
addRow(arrayOf<Any?>(name))
}
}
@@ -1,6 +1,12 @@
package com.kazier.mobile.features.thumbnails
import android.content.ContentProvider
import android.content.ContentValues
import android.content.Context
import android.database.Cursor
import android.net.Uri
import android.os.Bundle
import android.os.ParcelFileDescriptor
import androidx.test.core.app.ApplicationProvider
import com.kazier.mobile.data.local.entity.FileEntity
import kotlinx.coroutines.test.runTest
@@ -13,7 +19,9 @@ import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
import org.robolectric.shadows.ShadowContentResolver
import java.io.File
import java.io.FileNotFoundException
/**
* Contrat du ThumbnailStore — les coûts ressources sont bornés par design :
@@ -33,6 +41,10 @@ class ThumbnailStoreTest {
fun setUp() {
context = ApplicationProvider.getApplicationContext()
store = ThumbnailStore(context)
// Toute URI `content://root/…` lève à l'ouverture (provider absent) :
// la génération échoue proprement au lieu de produire un bitmap
// fantôme des shadows Robolectric.
ShadowContentResolver.registerProviderInternal("root", ThrowingProvider())
}
@Test
@@ -127,20 +139,138 @@ class ThumbnailStoreTest {
assertFalse(target.exists())
}
// --- versions mtime + taille ------------------------------------------
@Test
fun nom_versionne_encode_mtime_et_taille() {
val id = "7".repeat(32)
val versioned = store.thumbnailFile(id, 10_000L, 1234L)
assertEquals("${id}_10000_1234.webp", versioned.name)
assertEquals(store.thumbnailFile(id).parent, versioned.parent)
}
@Test
fun nom_legacy_sans_mtime_ni_taille() {
val id = "8".repeat(32)
assertEquals(store.thumbnailFile(id), store.thumbnailFile(id, null, 1L))
assertEquals(store.thumbnailFile(id), store.thumbnailFile(id, 10_000L, null))
}
@Test
fun ensure_version_en_place_retournee_sans_generation() {
val resourceId = "9".repeat(32)
val file = fileWith(
resourceId = resourceId,
category = "IMAGE",
uri = "content://root/doc",
lastModified = 10_000L,
size = 1234L,
)
val versioned = store.thumbnailFile(resourceId, 10_000L, 1234L)
versioned.parentFile?.mkdirs()
versioned.writeBytes(ByteArray(4))
versioned.setLastModified(20_000L)
runTest {
val thumb = store.ensure(file)
assertEquals(versioned.absolutePath, thumb?.absolutePath)
assertEquals(0, store.lockCount())
}
}
@Test
fun version_perimee_regeneration_echoue_sans_supprimer_sans_fuite_mutex() {
val resourceId = "a".repeat(32)
val stale = store.thumbnailFile(resourceId, 5_000L, 111L)
stale.parentFile?.mkdirs()
stale.writeBytes(ByteArray(4))
stale.setLastModified(20_000L)
val file = fileWith(
resourceId = resourceId,
category = "IMAGE",
// URI non résolvable : la génération échoue.
uri = "content://root/absent",
lastModified = 10_000L,
size = 222L,
)
runTest {
assertNull(store.ensure(file))
}
// Échec conservateur : l'ancienne version reste, aucun mutex ne fuit.
assertTrue(stale.isFile)
assertEquals(0, store.lockCount())
}
@Test
fun fichier_vide_jamais_a_jour() {
val target = store.thumbnailFile("b".repeat(32))
target.parentFile?.mkdirs()
target.writeBytes(ByteArray(0))
target.setLastModified(20_000L)
assertFalse(store.isUpToDate(target, 10_000L))
}
@Test
fun delete_purge_toutes_les_versions_et_les_tmp() {
val resourceId = "c".repeat(32)
val legacy = store.thumbnailFile(resourceId)
val v1 = store.thumbnailFile(resourceId, 5_000L, 111L)
val tmp = java.io.File(legacy.parentFile, "${v1.name}.tmp")
listOf(legacy, v1, tmp).forEach {
it.parentFile?.mkdirs()
it.writeBytes(ByteArray(4))
}
store.delete(resourceId)
assertFalse(legacy.exists())
assertFalse(v1.exists())
assertFalse(tmp.exists())
}
private fun fileWith(
resourceId: String,
category: String?,
uri: String?,
lastModified: Long? = null,
size: Long = 1L,
) = FileEntity(
resourceId = resourceId,
name = "doc",
folderResourceId = "f".repeat(32),
size = 1L,
size = size,
uri = uri,
category = category,
lastModified = lastModified,
addedAt = 0L,
updatedAt = 0L,
)
}
/** Provider qui lève à l'ouverture (fichier SAF absent / permission révoquée). */
private class ThrowingProvider : ContentProvider() {
override fun onCreate(): Boolean = true
override fun openFile(uri: Uri, mode: String): ParcelFileDescriptor? =
throw FileNotFoundException("no such document: $uri")
override fun query(
uri: Uri,
projection: Array<out String>?,
selection: String?,
selectionArgs: Array<out String>?,
sortOrder: String?,
): Cursor? = throw FileNotFoundException("no such document: $uri")
override fun call(authority: String, method: String, arg: String?, extras: Bundle?): Bundle? =
throw FileNotFoundException("no such document")
override fun getType(uri: Uri): String? = null
override fun insert(uri: Uri, values: ContentValues?): Uri? = null
override fun delete(uri: Uri, selection: String?, selectionArgs: Array<out String>?): Int = 0
override fun update(
uri: Uri,
values: ContentValues?,
selection: String?,
selectionArgs: Array<out String>?,
): Int = 0
}
@@ -0,0 +1,49 @@
package com.kazier.mobile.ui.document
import org.junit.Assert.assertEquals
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
/**
* M35 — clamp du pager après suppression : le viewer ne reste jamais sur une
* page hors bornes (écran vide), il retombe sur une page valide.
*/
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34])
class PagerClampTest {
@Test
fun suppression_du_dernier_doc_retombe_sur_le_precedent() {
// 3 docs, page 2/2 supprimée → liste de 2, page mémorisée hors bornes.
assertEquals(1, resolveViewerPage(currentPage = 2, restoredPage = 2, itemCount = 2))
}
@Test
fun suppression_du_premier_doc_clampe_la_page_courante() {
// Page 0 supprimée, pager resté en tête d'une liste raccourcie.
assertEquals(0, resolveViewerPage(currentPage = 0, restoredPage = -1, itemCount = 2))
}
@Test
fun page_courante_haute_clampee_sans_memoire() {
assertEquals(2, resolveViewerPage(currentPage = 9, restoredPage = -1, itemCount = 3))
}
@Test
fun page_courante_negative_clampee_a_zero() {
assertEquals(0, resolveViewerPage(currentPage = -4, restoredPage = -1, itemCount = 3))
}
@Test
fun page_memorisee_valide_prime_sur_la_courante() {
// Rotation : pager tout neuf à 0, mémoire saveable restaurée à 2.
assertEquals(2, resolveViewerPage(currentPage = 0, restoredPage = 2, itemCount = 5))
}
@Test
fun liste_vide_retourne_zero() {
assertEquals(0, resolveViewerPage(currentPage = 0, restoredPage = 0, itemCount = 0))
}
}
@@ -0,0 +1,62 @@
package com.kazier.mobile.ui.document
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
/**
* M30 — survie à la rotation : l'état persisté (`jumpPending`, `savedPage`,
* tous deux primitifs donc `rememberSaveable` sans Saver custom) suffit à
* retrouver la page lue au lieu de retomber sur le document initial, et le
* vide transitoire du rechargement ne quitte jamais l'écran.
*/
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34])
class RotationStateTest {
@Test
fun rotation_revient_a_la_page_memorisee_pas_a_l_initiale() {
// Avant rotation : page 3 lue (jumpPending=false, savedPage=3).
// Après rotation : pager tout neuf (currentPage=0) + mémoire restaurée.
val target = resolveViewerPage(currentPage = 0, restoredPage = 3, itemCount = 5)
assertEquals(3, target)
}
@Test
fun rotation_avant_le_saut_initial_rejoue_le_saut() {
// jumpPending restauré à true → le saut vers le document demandé rejoue
// dès que la liste est chargée (index retrouvé dans la liste).
val jumpPending = true
val docs = listOf("a".repeat(32), "b".repeat(32), "c".repeat(32))
val index = docs.indexOfFirst { it == "b".repeat(32) }
assertTrue(jumpPending)
assertEquals(1, index)
}
@Test
fun rechargement_vide_apres_rotation_ne_quitte_pas() {
// hadDocuments retombe à false dans la composition toute neuve :
// le vide transitoire du reload ne déclenche pas onBack.
assertFalse(shouldExitViewer(jumpPending = false, hadDocuments = false, isEmpty = true))
}
@Test
fun vide_pendant_le_saut_initial_ne_quitte_pas() {
assertFalse(shouldExitViewer(jumpPending = true, hadDocuments = false, isEmpty = true))
}
@Test
fun liste_videe_apres_affichage_quitte() {
// Dernier document supprimé sous les yeux de l'utilisateur → retour.
assertTrue(shouldExitViewer(jumpPending = false, hadDocuments = true, isEmpty = true))
}
@Test
fun liste_non_vide_ne_quitte_jamais() {
assertFalse(shouldExitViewer(jumpPending = false, hadDocuments = true, isEmpty = false))
}
}
@@ -0,0 +1,60 @@
package com.kazier.mobile.ui.navigation
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
/**
* m29 — la route pdfbuilder ne produit jamais `"pdfbuilder/"` (qui ne matche
* pas `"pdfbuilder/{ids}"`) ; la sélection vide passe par la sentinelle
* `"empty"`, re-parsée en liste vide (aller-retour).
*/
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34])
class NavGraphTest {
@Test
fun selection_vide_ne_produit_pas_une_route_vide() {
val route = Routes.pdfBuilder(emptyList())
assertFalse("route vide interdite : $route", route == "pdfbuilder/")
assertTrue(route.startsWith("pdfbuilder/"))
assertEquals(emptyList<String>(), Routes.parseBuilderIds(route.substringAfter("pdfbuilder/")))
}
@Test
fun selection_vide_aller_retour_sentinelle() {
assertEquals("pdfbuilder/${Routes.BUILDER_EMPTY}", Routes.pdfBuilder(emptyList()))
assertEquals(emptyList<String>(), Routes.parseBuilderIds(Routes.BUILDER_EMPTY))
}
@Test
fun ids_aller_retour() {
val ids = listOf("a".repeat(32), "b".repeat(32))
val route = Routes.pdfBuilder(ids)
assertEquals("pdfbuilder/${ids.joinToString(",")}", route)
assertEquals(ids, Routes.parseBuilderIds(route.substringAfter("pdfbuilder/")))
}
@Test
fun blancs_filtres_avant_construction() {
val id = "a".repeat(32)
assertEquals("pdfbuilder/$id", Routes.pdfBuilder(listOf("", " ", id)))
assertEquals(emptyList<String>(), Routes.parseBuilderIds(" , "))
}
@Test
fun parse_nul_et_vide() {
assertEquals(emptyList<String>(), Routes.parseBuilderIds(null))
assertEquals(emptyList<String>(), Routes.parseBuilderIds(""))
}
@Test
fun routes_folder_et_document() {
assertEquals("folder/abc", Routes.folder("abc"))
assertEquals("document/abc", Routes.document("abc"))
}
}
@@ -0,0 +1,34 @@
package com.kazier.mobile.ui.pdfbuilder
import com.kazier.mobile.data.local.entity.FileStatus
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Test
/**
* Contrat d'import d'un PDF assemblé : déjà « traité » (l'utilisateur vient
* de le construire — jamais dans la file de review, comme l'export scan) et
* placement via la constante `FileStatus.LOCAL`.
*/
class PdfBuilderImportTest {
@Test
fun import_marche_processed_et_local() {
val input = pdfSaveFileInput(
uri = "content://tree/generated.pdf",
name = "rapport.pdf",
bytes = 2048L,
now = 42L,
)
assertTrue("un PDF assemblé ne remonte jamais en review", input.processed)
assertEquals(FileStatus.LOCAL, input.syncStatus)
assertEquals("pdf", input.extension)
assertEquals("application/pdf", input.mimeType)
assertEquals("content://tree/generated.pdf", input.uri)
assertEquals("rapport.pdf", input.name)
assertEquals(2048L, input.size)
assertEquals(42L, input.lastModified)
assertTrue(input.exists)
}
}
@@ -0,0 +1,259 @@
package com.kazier.mobile.ui.review
import android.content.Context
import androidx.room.Room
import androidx.test.core.app.ApplicationProvider
import com.kazier.mobile.R
import com.kazier.mobile.data.local.AppDatabase
import com.kazier.mobile.data.remote.ApiClient
import com.kazier.mobile.data.remote.ApiService
import com.kazier.mobile.data.repository.FileRepository
import com.kazier.mobile.data.repository.OutboxRepository
import com.kazier.mobile.data.repository.SaveFileInput
import com.kazier.mobile.domain.DeviceIdentity
import com.kazier.mobile.domain.GenerateId
import com.kazier.mobile.features.saf.SafFileDeleter
import com.kazier.mobile.features.thumbnails.ThumbnailStore
import com.squareup.moshi.Moshi
import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.test.StandardTestDispatcher
import kotlinx.coroutines.test.TestScope
import kotlinx.coroutines.test.advanceUntilIdle
import kotlinx.coroutines.test.resetMain
import kotlinx.coroutines.test.runTest
import kotlinx.coroutines.test.setMain
import kotlinx.coroutines.withContext
import kotlinx.coroutines.withTimeout
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
import retrofit2.Retrofit
import retrofit2.converter.moshi.MoshiConverterFactory
/**
* Contrat optimiste de la review : un échec ne perd jamais de carte —
* - `keep` en échec → carte réinsérée en tête + erreur ;
* - `delete` en échec (provider refuse) → carte réinsérée en tête + erreur ;
* - `markAllProcessed` en échec → deck restauré + erreur ;
* - `load` en échec → deck existant conservé (jamais vidé à tort) + erreur.
*/
@OptIn(ExperimentalCoroutinesApi::class)
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34])
class ReviewOptimisticTest {
private lateinit var context: Context
private lateinit var db: AppDatabase
private lateinit var fileRepository: FileRepository
private lateinit var deleter: SafFileDeleter
@Before
fun setUp() {
context = ApplicationProvider.getApplicationContext()
db = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java)
.allowMainThreadQueries()
.build()
val moshi = Moshi.Builder().add(KotlinJsonAdapterFactory()).build()
val apiService = Retrofit.Builder()
.baseUrl("http://localhost:1/")
.addConverterFactory(MoshiConverterFactory.create(moshi))
.build()
.create(ApiService::class.java)
val apiClient = ApiClient(apiService, moshi)
val generateId = GenerateId()
val outboxRepository =
OutboxRepository(db.pendingOperationDao(), generateId, DeviceIdentity(db.userPreferenceDao(), generateId), moshi)
fileRepository = FileRepository(db.fileDao(), db.folderDao(), apiClient, generateId, db, outboxRepository)
deleter = SafFileDeleter(context, fileRepository, outboxRepository, db, ThumbnailStore(context))
// Validation applicative du parent (M18) : le dossier hôte existe.
runBlocking {
db.folderDao().upsert(
com.kazier.mobile.data.local.entity.FolderEntity(
resourceId = FOLDER,
uri = "content://tree/root",
name = "root",
exists = 1,
parentResourceId = null,
syncStatus = com.kazier.mobile.data.local.entity.FileStatus.LOCAL,
addedAt = 0L,
updatedAt = 0L,
),
)
}
}
@After
fun tearDown() {
runCatching { db.close() }
}
@Test
fun garder_succes_retire_la_carte_sans_erreur() = runTest {
withMain {
saveUnprocessed(RESOURCE_A)
val vm = SwipeReviewViewModel(fileRepository, deleter, context)
awaitUiState(vm) { it.cards.size == 1 }
assertEquals(1, vm.uiState.value.cards.size)
vm.keep(vm.uiState.value.cards.first())
awaitUiState(vm) { it.cards.isEmpty() }
assertTrue(vm.uiState.value.cards.isEmpty())
assertNull(vm.uiState.value.error)
}
}
@Test
fun garder_echec_carte_reinseree_en_tete() = runTest {
withMain {
saveUnprocessed(RESOURCE_A)
val vm = SwipeReviewViewModel(fileRepository, deleter, context)
awaitUiState(vm) { it.cards.size == 1 }
val file = vm.uiState.value.cards.first()
// Table pierres : `markProcessed` lève (SQLiteException) → échec.
// (NB : `db.close()` suspend indéfiniment les appels Room au lieu
// de lever — inutilisable comme injection de faute.)
dropFilesTable()
vm.keep(file)
awaitUiState(vm) { it.error != null }
assertEquals(listOf(RESOURCE_A), vm.uiState.value.cards.map { it.resourceId })
assertEquals(context.getString(R.string.review_keep_error), vm.uiState.value.error)
}
}
@Test
fun supprimer_echec_provider_carte_reinseree_en_tete() = runTest {
withMain {
saveUnprocessed(RESOURCE_A)
val vm = SwipeReviewViewModel(fileRepository, deleter, context)
awaitUiState(vm) { it.cards.size == 1 }
val file = vm.uiState.value.cards.first()
// URI inconnu : le provider refuse → `delete` retourne false.
vm.delete(file)
awaitUiState(vm) { it.error != null }
assertEquals(listOf(RESOURCE_A), vm.uiState.value.cards.map { it.resourceId })
assertEquals(context.getString(R.string.review_delete_error), vm.uiState.value.error)
}
}
@Test
fun tout_marquer_echec_deck_restaure() = runTest {
withMain {
saveUnprocessed(RESOURCE_A)
val vm = SwipeReviewViewModel(fileRepository, deleter, context)
awaitUiState(vm) { it.cards.size == 1 }
assertEquals(1, vm.uiState.value.cards.size)
dropFilesTable()
vm.markAllProcessed()
awaitUiState(vm) { it.error != null }
assertEquals(listOf(RESOURCE_A), vm.uiState.value.cards.map { it.resourceId })
assertEquals(context.getString(R.string.review_keep_error), vm.uiState.value.error)
}
}
@Test
fun rechargement_echec_deck_existant_conserve() = runTest {
withMain {
saveUnprocessed(RESOURCE_A)
val vm = SwipeReviewViewModel(fileRepository, deleter, context)
awaitUiState(vm) { it.cards.size == 1 }
assertEquals(1, vm.uiState.value.cards.size)
dropFilesTable()
vm.load()
awaitUiState(vm) { it.error != null }
assertEquals(listOf(RESOURCE_A), vm.uiState.value.cards.map { it.resourceId })
assertEquals(context.getString(R.string.review_load_error), vm.uiState.value.error)
}
}
@Test
fun reinsertion_sans_doublon() {
val file = fileEntity(RESOURCE_A)
val cards = listOf(fileEntity(RESOURCE_B), file)
val result = reinsertHead(cards, file)
assertEquals(listOf(RESOURCE_A, RESOURCE_B), result.map { it.resourceId })
}
/** Injection de faute : toute lecture/écriture `files` lève aussitôt. */
private suspend fun dropFilesTable() {
db.openHelper.writableDatabase.execSQL("DROP TABLE `files`")
}
private suspend fun saveUnprocessed(resourceId: String) { fileRepository.saveLocalFile(
input = SaveFileInput(
uri = "content://tree/$resourceId",
name = "$resourceId.jpg",
extension = "jpg",
size = 1024,
mimeType = "image/jpeg",
resourceId = resourceId,
processed = false,
),
folderResourceId = FOLDER,
)
}
private fun fileEntity(resourceId: String) = com.kazier.mobile.data.local.entity.FileEntity(
resourceId = resourceId,
name = "$resourceId.jpg",
folderResourceId = FOLDER,
size = 1024L,
addedAt = 0L,
updatedAt = 0L,
)
private suspend fun TestScope.withMain(block: suspend () -> Unit) { val dispatcher = StandardTestDispatcher(testScheduler)
Dispatchers.setMain(dispatcher)
try {
block()
} finally {
Dispatchers.resetMain()
}
}
/**
* Attente déterministe d'un état VM : `advanceUntilIdle()` seul ne suffit
* pas — les lectures Room s'exécutent sur l'executor Room (thread réel) et
* `advanceUntilIdle` peut revenir avant leur reprise (temps virtuel brûlé
* sans attente réelle). On attend donc en temps RÉEL (`Dispatchers.IO` +
* `withTimeout` réel) la première valeur concordante du StateFlow.
*/
private suspend fun awaitUiState(
vm: SwipeReviewViewModel,
timeoutMs: Long = 10_000,
predicate: (SwipeReviewViewModel.ReviewUiState) -> Boolean,
) {
withContext(Dispatchers.IO) {
withTimeout(timeoutMs) {
vm.uiState.first(predicate)
}
}
}
private companion object {
const val FOLDER = "f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0"
const val RESOURCE_A = "aabbccddeeff11223344556677889900"
const val RESOURCE_B = "bbaa11223344556677889900ccddeeff"
}
}
@@ -0,0 +1,52 @@
package com.kazier.mobile.ui.scan
import android.graphics.Bitmap
import android.graphics.PointF
import com.kazier.mobile.features.scan.ScanImageProcessor
import com.kazier.mobile.features.scan.ScanQuad
import com.kazier.mobile.features.scan.ScanRenderMode
import org.junit.Assert.assertNull
import org.junit.Assert.assertSame
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
/**
* Contrat OpenCV-absent : `process()` retourne l'instance d'entrée elle-même
* (alias) — l'appelant (`ScanViewModel.confirmPage`) ne recycle que les
* nouvelles instances, jamais cet alias encore dessiné par `CropStage`
* (sinon crash `recycled bitmap` au retour caméra).
*/
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34])
class CropNoCvTest {
private val processor = ScanImageProcessor()
private fun bitmap() =
Bitmap.createBitmap(64, 48, Bitmap.Config.ARGB_8888)
private fun quad() = ScanQuad(
listOf(
PointF(4f, 4f),
PointF(60f, 4f),
PointF(60f, 44f),
PointF(4f, 44f),
),
)
@Test
fun process_sans_opencv_retourne_l_alias_d_entree() {
val input = bitmap()
val result = processor.process(input, quad(), ScanRenderMode.COLOR)
assertSame("sans OpenCV, process() doit aliaser l'entrée", input, result)
}
@Test
fun detection_sans_opencv_retourne_null() {
assertNull(processor.detectCorners(bitmap()))
}
}
@@ -0,0 +1,76 @@
package com.kazier.mobile.ui.scan
import com.kazier.mobile.data.local.entity.ScanPageEntity
import com.kazier.mobile.data.local.entity.ScanPageStatus
import com.kazier.mobile.features.scan.ScanExport
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Test
/**
* Contrat d'export d'une session de scan (décisions pures consommées par
* `ScanViewModel.export/exportPdf`) :
* - échec partiel → seules les pages réussies sont marquées `EXPORTED`,
* la session ne passe jamais `DONE` ;
* - retry idempotent → seul le `PENDING` est réexporté, l'`EXPORTED`
* n'est jamais rejoué (aucun doublon SAF/Room/outbox).
*/
class ScanExportTest {
@Test
fun echec_partiel_seuls_les_succes_marques_pas_de_done() {
val pages = listOf(
page("a".repeat(32), ScanPageStatus.PENDING),
page("b".repeat(32), ScanPageStatus.PENDING),
)
val failedIds = setOf("b".repeat(32))
val marked = ScanExport.succeeded(pages, failedIds)
assertEquals(listOf("a".repeat(32)), marked.map { it.resourceId })
assertFalse("un échec partiel ne termine jamais la session", ScanExport.shouldFinishSession(1))
}
@Test
fun retry_idempotent_seul_le_pending_reexporte() {
val pages = listOf(
page("a".repeat(32), ScanPageStatus.PENDING),
page("b".repeat(32), ScanPageStatus.EXPORTED),
)
val retry = ScanExport.pendingForExport(pages)
assertEquals(listOf("a".repeat(32)), retry.map { it.resourceId })
}
@Test
fun succes_total_marque_tout_et_termine() {
val pages = listOf(
page("a".repeat(32), ScanPageStatus.PENDING),
page("b".repeat(32), ScanPageStatus.PENDING),
)
assertEquals(pages, ScanExport.succeeded(pages, emptySet()))
assertTrue(ScanExport.shouldFinishSession(0))
}
@Test
fun session_deja_exportee_retry_sans_rien() {
val pages = listOf(page("a".repeat(32), ScanPageStatus.EXPORTED))
assertTrue(ScanExport.pendingForExport(pages).isEmpty())
}
private fun page(resourceId: String, status: String) = ScanPageEntity(
resourceId = resourceId,
sessionId = 1L,
tempUri = "/tmp/$resourceId.jpg",
cornersJson = "{}",
width = 100,
height = 100,
sortOrder = 0,
status = status,
createdAt = 0L,
)
}
@@ -0,0 +1,90 @@
package com.kazier.mobile.ui.scan
import android.content.Context
import androidx.room.Room
import androidx.test.core.app.ApplicationProvider
import com.kazier.mobile.data.local.AppDatabase
import com.kazier.mobile.data.local.dao.ScanDao
import com.kazier.mobile.data.local.entity.ScanSessionEntity
import com.kazier.mobile.data.repository.ScanRepository
import com.kazier.mobile.domain.GenerateId
import kotlinx.coroutines.test.runTest
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
/**
* Contrat d'ordre des pages de scan : `sort_order` est `MAX + 1`, jamais
* `COUNT` — après suppression, un ajout ne réutilise aucun ordre existant
* (sinon `ORDER BY sort_order` instable + `swapOrder` ambigu).
*/
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34])
class ScanOrderTest {
private lateinit var db: AppDatabase
private lateinit var scanDao: ScanDao
private lateinit var repository: ScanRepository
@Before
fun setUp() {
val context = ApplicationProvider.getApplicationContext<Context>()
db = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java)
.allowMainThreadQueries()
.build()
scanDao = db.scanDao()
repository = ScanRepository(db, scanDao, GenerateId())
}
@After
fun tearDown() {
db.close()
}
@Test
fun ajout_suppression_ajout_ordres_uniques() = runTest {
val session = repository.getOrCreateActiveSession(null)
val a = repository.addPage(session, "/tmp/a.jpg", "{}", 10, 10)
val b = repository.addPage(session, "/tmp/b.jpg", "{}", 10, 10)
repository.deletePage(a.id, session.id)
val c = repository.addPage(session, "/tmp/c.jpg", "{}", 10, 10)
val pages = repository.getPages(session.id)
assertEquals(2, pages.size)
val orders = pages.map { it.sortOrder }
assertEquals("les ordres doivent rester uniques", orders.size, orders.toSet().size)
// MAX(0,1) + 1 = 2 : aucun recyclage de l'ordre de A.
assertEquals(2, c.sortOrder)
assertTrue(pages.none { it.id == a.id })
assertTrue(pages.any { it.id == b.id })
}
@Test
fun ajouts_successifs_ordres_croissants_max_plus_un() = runTest {
val session = repository.getOrCreateActiveSession(null)
val orders = (0 until 3).map { i ->
repository.addPage(session, "/tmp/$i.jpg", "{}", 10, 10).sortOrder
}
assertEquals(listOf(0, 1, 2), orders)
}
@Test
fun sessions_independantes_compteurs_separes() = runTest {
val first = repository.getOrCreateActiveSession(null)
repository.addPage(first, "/tmp/a.jpg", "{}", 10, 10)
repository.abandonSession(first.id)
val second = repository.getOrCreateActiveSession(null)
val page = repository.addPage(second, "/tmp/b.jpg", "{}", 10, 10)
assertEquals(0, page.sortOrder)
}
}
@@ -0,0 +1,220 @@
package com.kazier.mobile.ui.search
import android.content.Context
import androidx.room.Room
import androidx.test.core.app.ApplicationProvider
import com.kazier.mobile.data.local.AppDatabase
import com.kazier.mobile.data.remote.ApiClient
import com.kazier.mobile.data.remote.ApiService
import com.kazier.mobile.data.repository.FileRepository
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.domain.ActiveUserStore
import com.kazier.mobile.domain.DeviceIdentity
import com.kazier.mobile.domain.GenerateId
import com.kazier.mobile.features.saf.FileDeleter
import com.kazier.mobile.features.saf.FileMover
import com.kazier.mobile.features.thumbnails.ThumbnailStore
import com.squareup.moshi.Moshi
import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.ExperimentalCoroutinesApi
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.test.StandardTestDispatcher
import kotlinx.coroutines.test.advanceTimeBy
import kotlinx.coroutines.test.runCurrent
import kotlinx.coroutines.test.runTest
import kotlinx.coroutines.test.setMain
import kotlinx.coroutines.test.resetMain
import kotlinx.coroutines.withContext
import kotlinx.coroutines.withTimeout
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config
import retrofit2.Retrofit
import retrofit2.converter.moshi.MoshiConverterFactory
/**
* M31 — le champ suit la frappe brute : `uiState.query` reflète la saisie
* sans attendre le debounce (300 ms), qui ne s'applique qu'à la requête Room.
*/
@OptIn(ExperimentalCoroutinesApi::class)
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [34])
class SearchFieldTest {
private lateinit var db: AppDatabase
private lateinit var fileRepository: FileRepository
private lateinit var context: Context
@Before
fun setUp() {
context = ApplicationProvider.getApplicationContext()
db = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java)
.allowMainThreadQueries()
.build()
val moshi = Moshi.Builder().add(KotlinJsonAdapterFactory()).build()
val apiService = Retrofit.Builder()
.baseUrl("http://localhost:1/")
.addConverterFactory(MoshiConverterFactory.create(moshi))
.build()
.create(ApiService::class.java)
val apiClient = ApiClient(apiService, moshi)
val generateId = GenerateId()
val outboxRepository = OutboxRepository(
db.pendingOperationDao(),
generateId,
DeviceIdentity(db.userPreferenceDao(), generateId),
moshi,
)
fileRepository = FileRepository(db.fileDao(), db.folderDao(), apiClient, generateId, db, outboxRepository)
// Validation applicative du parent (M18) : le dossier hôte existe.
runBlocking {
db.folderDao().upsert(
com.kazier.mobile.data.local.entity.FolderEntity(
resourceId = FOLDER,
uri = "content://tree/root",
name = "root",
exists = 1,
parentResourceId = null,
syncStatus = com.kazier.mobile.data.local.entity.FileStatus.LOCAL,
addedAt = 0L,
updatedAt = 0L,
),
)
}
}
@After
fun tearDown() {
db.close()
}
@Test
fun champ_suit_la_frappe_brute_sans_attendre_le_debounce() = runTest {
Dispatchers.setMain(StandardTestDispatcher(testScheduler))
try {
val viewModel = newViewModel()
backgroundScope.launch { viewModel.uiState.collect {} }
runCurrent()
// Trois frappes sans avancer l'horloge virtuelle (debounce = 300 ms).
viewModel.onQueryChange("r")
viewModel.onQueryChange("ra")
viewModel.onQueryChange("rap")
runCurrent()
assertEquals(
"le champ doit suivre la frappe brute, pas la valeur debouncée",
"rap",
viewModel.uiState.value.query,
)
} finally {
Dispatchers.resetMain()
}
}
@Test
fun resultats_room_seulement_apres_debounce() = runTest {
Dispatchers.setMain(StandardTestDispatcher(testScheduler))
try {
fileRepository.saveLocalFile(
input = SaveFileInput(
uri = "content://tree/rapport",
name = "rapport annuel.pdf",
extension = "pdf",
size = 1024,
mimeType = "application/pdf",
resourceId = RESOURCE_ID,
processed = true,
),
folderResourceId = FOLDER,
)
val viewModel = newViewModel()
backgroundScope.launch { viewModel.uiState.collect {} }
// Laisse l'état initial (requête vide → récents) se stabiliser :
// les lectures Room tournent sur l'executor Room (thread réel),
// on attend en temps RÉEL la première émission contenant le seed.
withContext(Dispatchers.IO) {
withTimeout(10_000) {
viewModel.uiState.first { state ->
state.results.any { it.resourceId == RESOURCE_ID }
}
}
}
viewModel.onQueryChange("zzz-sans-match")
runCurrent()
// Champ brut immédiat…
assertEquals("zzz-sans-match", viewModel.uiState.value.query)
// …mais la recherche Room n'a pas encore tourné : les récents
// (dont le fichier seedé) sont toujours affichés.
assertTrue(
"résultats prématurés : la requête Room doit attendre le debounce",
viewModel.uiState.value.results.any { it.resourceId == RESOURCE_ID },
)
// Debounce écoulé → la recherche tourne et ne matche plus rien.
// Attente en temps RÉEL (même raison que la stabilisation).
advanceTimeBy(400)
val settled = withContext(Dispatchers.IO) {
withTimeout(10_000) {
viewModel.uiState.first {
it.query == "zzz-sans-match" && it.results.none { f -> f.resourceId == RESOURCE_ID }
}
}
}
assertTrue(settled.results.isEmpty())
} finally {
Dispatchers.resetMain()
}
}
private fun newViewModel(): SearchViewModel {
val moshi = Moshi.Builder().add(KotlinJsonAdapterFactory()).build()
val apiService = Retrofit.Builder()
.baseUrl("http://localhost:1/")
.addConverterFactory(MoshiConverterFactory.create(moshi))
.build()
.create(ApiService::class.java)
val apiClient = ApiClient(apiService, moshi)
val generateId = GenerateId()
val outboxRepository = OutboxRepository(
db.pendingOperationDao(),
generateId,
DeviceIdentity(db.userPreferenceDao(), generateId),
moshi,
)
val fileRepo = fileRepository
val folderRepository = FolderRepository(
db.folderDao(),
apiClient,
generateId,
ActiveUserStore(db.userPreferenceDao()),
db,
outboxRepository,
)
return SearchViewModel(
fileRepo,
folderRepository,
FileMover(context, fileRepo, folderRepository),
FileDeleter(context, fileRepo, outboxRepository, db, ThumbnailStore(context)),
context,
)
}
private companion object {
const val FOLDER = "f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0"
const val RESOURCE_ID = "aabbccddeeff11223344556677889900"
}
}