Étudiant: Thomas WIMART Jaafar HOURIE
Formation: UniLaSalle
Projet: Travail Pratique Android - Application E-Commerce
Date: Janvier 2025
Technologies: Kotlin 2.0.21, Jetpack Compose, MVVM
- Présentation du Projet
- Fonctionnalités de l'Application
- Architecture et Implémentation Technique
- Technologies Utilisées
- Environnement de Développement avec Nix
- Défis Techniques et Solutions
- Intégration Continue et Déploiement (CI/CD)
- Structure du Projet
- Installation et Compilation
- Tests et Validation
- Conclusion et Perspectives
Ce projet est une application e-commerce Android complète développée dans le cadre du TP UniLaSalle. L'application permet aux utilisateurs de parcourir un catalogue de produits, de filtrer par catégories, de consulter les détails des produits et de gérer un panier d'achat persistant.
- Développer une application Android moderne avec Jetpack Compose
- Implémenter une architecture MVVM propre et maintenable
- Assurer la persistance des données avec Room Database
- Consommer une API REST avec Retrofit
- Garantir une compatibilité avec minimum 85% des appareils Android
- Créer un environnement de développement reproductible avec Nix
FakeStore API - https://fakestoreapi.com/
API publique fournissant un catalogue de 20 produits répartis en 4 catégories :
- Electronics
- Jewelery
- Men's clothing
- Women's clothing
| Métrique | Valeur |
|---|---|
| Temps de développement | 12 heures |
| Fichiers Kotlin | 20+ fichiers |
| Lignes de code | ~1,800 lignes |
| Écrans | 3 (Liste, Détails, Panier) |
| Min SDK | 24 (Android 7.0) |
| Target SDK | 36 (Android 15) |
| Couverture appareils | ~95% |
Fonctionnalités principales:
- ✅ Affichage en grille responsive (2 colonnes)
- ✅ Chargement de 20 produits depuis l'API
- ✅ Filtrage par catégories dynamique
- ✅ Badge panier en temps réel avec compteur
- ✅ Gestion des états (loading, success, error)
- ✅ Bouton "Réessayer" en cas d'erreur réseau
Informations affichées par produit:
- Image du produit (chargement asynchrone avec Coil)
- Titre (max 2 lignes avec ellipsis)
- Catégorie (badge uppercase)
- Prix en USD
- Note étoiles et nombre d'avis
Navigation:
- Clic sur un produit → Écran détails
- Clic sur icône panier → Écran panier
Fonctionnalités principales:
- ✅ Affichage des informations complètes du produit
- ✅ Image grande taille (300dp height)
- ✅ Description détaillée scrollable
- ✅ Bouton "Ajouter au panier"
- ✅ Snackbar de confirmation après ajout
- ✅ Gestion intelligente : incrémente quantité si déjà présent
Informations affichées:
- Image en grand format
- Catégorie (badge)
- Titre complet
- Note et nombre d'avis
- Prix en USD (highlight)
- Description complète
- Bouton d'action principal
Navigation:
- Bouton retour → Retour à la liste
- Icône panier → Accès direct au panier
Fonctionnalités principales:
- ✅ Liste complète des articles ajoutés
- ✅ Modification de quantité (boutons +/-)
- ✅ Suppression individuelle d'articles
- ✅ Calculs automatiques en temps réel
- ✅ Bouton "Vider le panier" avec confirmation
- ✅ Persistance Room : survit au redémarrage
- ✅ État vide avec message et call-to-action
Calculs affichés:
- Prix unitaire par article
- Prix total par ligne (prix × quantité)
- Nombre total d'articles
- Total général du panier
Comportements:
- Quantité = 0 → Suppression automatique
- Changements instantanés grâce à Flow
- Dialog de confirmation avant vidage complet
L'application suit strictement le pattern Model-View-ViewModel recommandé par Google pour Android.
┌──────────────────────────────────────────┐
│ VIEW (Jetpack Compose) │
│ ProductListScreen │ DetailScreen │ Cart │
│ - Affiche UI │
│ - Collecte state (collectAsState()) │
│ - Appelle fonctions du ViewModel │
└──────────────────┬───────────────────────┘
│ observes StateFlow
↓
┌──────────────────────────────────────────┐
│ VIEWMODEL │
│ ProductVM │ ProductDetailVM │ CartVM │
│ - Logique métier │
│ - Gestion état (StateFlow) │
│ - Pas de dépendances Android │
└──────────────────┬───────────────────────┘
│ calls suspend functions
↓
┌──────────────────────────────────────────┐
│ REPOSITORY │
│ ProductRepository │
│ - Single source of truth │
│ - Coordonne API + Database │
└──────────────┬───────────────────────────┘
│
┌───────┴────────┐
↓ ↓
┌─────────────┐ ┌─────────────┐
│ RETROFIT │ │ ROOM │
│ (Network) │ │ (Database) │
│ API REST │ │ SQLite │
└─────────────┘ └─────────────┘
Responsabilités:
- Récupération des données (API, Database)
- Transformation des données
- Gestion du cache local
Composants:
Product.kt/CartItem.kt: Data classes (modèles)FakeStoreApi.kt: Interface Retrofit (endpoints)RetrofitInstance.kt: Configuration HTTP clientAppDatabase.kt: Configuration RoomCartDao.kt: Data Access Object (requêtes SQL)ProductRepository.kt: Single source of truth
Décision architecturale:
Le ProductRepository centralise l'accès aux données. Les ViewModels ne connaissent ni Retrofit ni Room directement, ils communiquent uniquement avec le Repository. Cela permet de changer l'implémentation (par exemple, changer d'API) sans toucher aux ViewModels.
Responsabilités:
- Gestion de l'état UI (StateFlow)
- Logique métier
- Orchestration des appels au Repository
- Gestion du cycle de vie (viewModelScope)
Composants:
ProductViewModel.kt: Liste + filtrage par catégoriesProductDetailViewModel.kt: Détails + ajout au panierCartViewModel.kt: Gestion du panier (CRUD, totaux)
Pattern utilisé:
// État UI immutable
data class ProductListUiState(
val products: List<Product> = emptyList(),
val categories: List<String> = emptyList(),
val selectedCategory: String? = null,
val isLoading: Boolean = false,
val error: String? = null
)
// ViewModel avec StateFlow
class ProductViewModel(private val repository: ProductRepository) : ViewModel() {
// État privé mutable
private val _uiState = MutableStateFlow(ProductListUiState())
// État public immutable (lecture seule)
val uiState: StateFlow<ProductListUiState> = _uiState.asStateFlow()
// Fonctions pour modifier l'état
fun loadProducts() {
viewModelScope.launch {
_uiState.value = _uiState.value.copy(isLoading = true)
// ... appel au repository
}
}
}Avantages de cette approche:
- État unidirectionnel (UDF - Unidirectional Data Flow)
- Immutabilité garantie (pas de modifications externes)
- Facilement testable (pas de dépendances Android)
Responsabilités:
- Affichage de l'interface utilisateur
- Observation des états (StateFlow)
- Transmission des événements utilisateur au ViewModel
Composants:
-
Screens : Composables plein écran
ProductListScreen.kt: Grille + filtresProductDetailScreen.kt: Détails produitCartScreen.kt: Panier avec totaux
-
Components : Composables réutilisables
ProductCard.kt: Carte produit (liste)CartItemCard.kt: Ligne panier avec contrôles
-
Navigation
AppNavigation.kt: NavHost avec routes type-safe
Pattern Compose:
@Composable
fun ProductListScreen(
onProductClick: (Int) -> Unit, // Hoisting des callbacks
onCartClick: () -> Unit,
modifier: Modifier = Modifier // Toujours un Modifier
) {
val viewModel: ProductViewModel = viewModel(factory = ...)
val uiState by viewModel.uiState.collectAsState() // Observation
when {
uiState.isLoading -> LoadingState()
uiState.error != null -> ErrorState()
else -> SuccessState(uiState.products)
}
}StateFlow vs LiveData:
Nous avons choisi StateFlow plutôt que LiveData pour plusieurs raisons :
- Plus moderne et intégré à Kotlin Coroutines
- Fonctionne en dehors du contexte Android (testabilité)
- Opérateurs de transformation puissants (map, filter, combine)
- Pas de dépendance au lifecycle (Compose gère ça)
Pattern d'état:
- États immuables avec data classes
- Mise à jour via
.copy()pour garantir l'immutabilité - Observation dans Compose avec
collectAsState()
Sealed Class pour les Routes:
sealed class Screen(val route: String) {
object ProductList : Screen("product_list")
object ProductDetail : Screen("product_detail/{productId}") {
fun createRoute(productId: Int) = "product_detail/$productId"
}
object Cart : Screen("cart")
}Avantages:
- Compilation-time safety (pas de routes en String hardcodées)
- Autocomplétion IDE
- Refactoring facile
Pourquoi Room?
- ORM officiel de Google pour Android
- Type-safety des requêtes SQL (vérification à la compilation)
- Support de Flow pour réactivité
- Migrations automatiques possibles
Architecture Base de Données:
┌─────────────────────────────────┐
│ AppDatabase (Singleton) │
│ - Version: 1 │
│ - Entities: [CartItem] │
│ - Fallback: Destructive │
└────────────┬────────────────────┘
│
↓
┌─────────────────────────────────┐
│ CartDao (Interface) │
│ - getAllCartItems(): Flow │
│ - insert(item) │
│ - delete(item) │
│ - updateQuantity(id, qty) │
│ - clearCart() │
└─────────────────────────────────┘
Choix de Flow pour la réactivité:
@Dao
interface CartDao {
@Query("SELECT * FROM cart_items")
fun getAllCartItems(): Flow<List<CartItem>> // Reactive!
}Le Flow émet automatiquement une nouvelle valeur à chaque modification de la base. Compose se re-render automatiquement grâce à collectAsState().
Configuration:
- Base URL :
https://fakestoreapi.com/ - Converter : Gson (JSON ↔ Kotlin)
- Intercepteur : HttpLoggingInterceptor (debug)
- Timeouts : 30 secondes (connect, read, write)
Gestion des erreurs:
suspend fun getAllProducts(): Result<List<Product>> = withContext(Dispatchers.IO) {
try {
val products = api.getAllProducts()
Result.success(products)
} catch (e: Exception) {
Result.failure(e)
}
}Le type Result<T> encapsule le succès ou l'échec, permettant une gestion élégante des erreurs dans le ViewModel.
Coroutines Kotlin:
viewModelScope.launch: Annulation automatique quand le ViewModel est détruitwithContext(Dispatchers.IO): Exécution sur thread I/Osuspendfunctions : Non-bloquant, meilleur que les callbacksFlow: Streams asynchrones pour données continues
Dispatchers utilisés:
Dispatchers.IO: Réseau, databaseDispatchers.Main: UI updates (défaut dans viewModelScope)
| Technologie | Version | Rôle |
|---|---|---|
| Kotlin | 2.0.21 | Langage principal |
| Jetpack Compose | BOM 2024.09.00 | UI déclarative |
| Material3 | Latest | Design system |
| Retrofit | 2.9.0 | Client HTTP REST |
| OkHttp | 4.12.0 | HTTP client + logging |
| Gson | 2.10.1 | Sérialisation JSON |
| Room | 2.6.1 | ORM SQLite |
| KSP | 2.0.21-1.0.25 | Annotation processor |
| Coil | 2.5.0 | Chargement images |
| Navigation Compose | 2.7.6 | Navigation |
| Coroutines | 1.7.3 | Asynchrone |
| Lifecycle ViewModel | 2.7.0 | Gestion cycle de vie |
Build System: Gradle 8.13.2 avec Kotlin DSL
Plugins:
com.android.application: Plugin Androidorg.jetbrains.kotlin.android: Support Kotlinorg.jetbrains.kotlin.plugin.compose: Compiler Composecom.google.devtools.ksp: Kapt moderne pour Room
Avantage KSP vs KAPT: KSP (Kotlin Symbol Processing) est 2x plus rapide que KAPT et mieux intégré à Kotlin.
android {
compileSdk = 36
defaultConfig {
minSdk = 24 // Android 7.0 (2016) → ~95% appareils
targetSdk = 36 // Android 15 (2025)
}
}Justification minSdk 24:
- Couverture de 95%+ des appareils Android en circulation
- Support natif de toutes nos dépendances
- Pas de compromis sur les fonctionnalités modernes
Jetpack Compose (UI):
implementation(platform(libs.androidx.compose.bom))
implementation(libs.androidx.compose.ui)
implementation(libs.androidx.compose.material3)
implementation(libs.androidx.compose.ui.tooling.preview)Networking:
implementation(libs.retrofit)
implementation(libs.retrofit.converter.gson)
implementation(libs.okhttp.logging)Database:
implementation(libs.androidx.room.runtime)
implementation(libs.androidx.room.ktx) // Flow support
ksp(libs.androidx.room.compiler) // Annotation processorImages:
implementation(libs.coil.compose) // Intégration Compose nativeContexte: Ce projet a été développé en binôme. Pour garantir un environnement de développement identique sur les deux machines, nous avons utilisé Nix Flakes.
Problématique:
- Machine 1 : Ubuntu 22.04, 16GB RAM, Android Studio 2024.1
- Machine 2 : Arch Linux, 7GB RAM, Android Studio 2025.2
- Versions JDK différentes (JDK 17 vs JDK 21)
- SDK Android installés manuellement (chemins différents)
- Problème classique : "Ça marche sur ma machine !"
Solution : Nix Flakes
Nix est un gestionnaire de paquets déclaratif et reproductible. Avec un seul fichier flake.nix, on définit :
- Versions exactes de tous les outils
- Variables d'environnement
- Configuration système
- Dépendances
Avantages concrets:
- ✅ Environnement identique sur toutes les machines
- ✅ Isolation complète (n'affecte pas le système)
- ✅ Reproductibilité garantie (même dans 5 ans)
- ✅ Pas de pollution du système global
- ✅ Rollback instantané si problème
Notre fichier flake.nix configure automatiquement :
{
description = "Environnement Android reproductible";
inputs = {
nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
};
outputs = { self, nixpkgs }: {
devShells.x86_64-linux.default = (pkgs.buildFHSEnv {
name = "android-sdk-env";
targetPkgs = pkgs: with pkgs; [
android-studio # IDE complet
android-tools # adb, fastboot
jdk21 # Java 21 (requis par AS 2025.2)
git
# Bibliothèques système pour émulateur
glibc
libGL
libpulseaudio
xorg.libX11
xorg.libXext
zlib
];
profile = ''
export ANDROID_HOME=$HOME/Android/Sdk
export JAVA_HOME=${pkgs.jdk21.home}
export PATH=$PATH:$ANDROID_HOME/tools:$ANDROID_HOME/platform-tools
'';
}).env;
};
}Workflow de développement:
# Cloner le projet
git clone <repo>
cd TP-Android-JT
# Entrer dans l'environnement Nix
nix develop
# L'environnement est prêt! Android Studio, JDK, SDK sont configurés
android-studio &
# Compiler le projet
./gradlew assembleDebug
# Sortir de l'environnement
exitCe qui se passe:
- Nix télécharge et configure TOUT automatiquement (première fois : 5-15 min)
- Variables d'environnement définies (
ANDROID_HOME,JAVA_HOME) - Outils disponibles dans le PATH
- Isolation complète (le système hôte n'est pas modifié)
Processus de synchronisation:
- Développeur A crée
flake.nixavec la configuration - Commit + Push sur GitHub
- Développeur B clone le projet et exécute
nix develop - Environnement identique automatiquement configuré sur les deux machines
Résultat:
- Aucun problème de "ça marche pas chez moi"
- Pas de configuration manuelle d'Android Studio
- Versions exactes garanties (JDK, Gradle, SDK Tools)
En pratique:
- ✅ Setup initial sur machine binôme : 5 minutes (vs 1-2 heures manuellement)
- ✅ Zéro conflit de versions JDK/Gradle
- ✅ Environnement de CI/CD facilement reproductible
- ✅ Documentation vivante (le
flake.nixdocumente l'environnement) - ✅ Idéal pour projets académiques en équipe
Contexte: Machine avec 7GB de RAM seulement (en-dessous du minimum recommandé de 8GB pour Android Studio + Émulateur).
Symptômes:
- Émulateur Android extrêmement lent (lag de 5-10 secondes)
- Freezes fréquents lors du lancement de l'app
- Crashes aléatoires d'Android Studio
- OOM (Out Of Memory) errors pendant les builds Gradle
Cause identifiée:
Android Studio: 2GB RAM
Gradle daemon: 2GB RAM
Émulateur AVD: 2GB RAM
Système Linux: 1GB RAM
────────────────────────
Total requis: 7GB RAM → Machine saturée!
Modifications apportées au flake.nix:
profile = ''
# Gradle : Réduction heap de 2GB → 1.5GB
export GRADLE_OPTS="-Xmx1536m -XX:MaxMetaspaceSize=512m -XX:+UseParallelGC"
# Android Studio : Limitation mémoire IDE
export STUDIO_VM_OPTIONS="-Xmx1024m -Xms512m -XX:MaxMetaspaceSize=512m"
# Émulateur : Utilisation bibliothèques système (économise RAM)
export ANDROID_EMULATOR_USE_SYSTEM_LIBS=1
# Gradle : Limitation workers parallèles (économise 30-40% RAM)
export ORG_GRADLE_PROJECT_org_gradle_workers_max=2
'';Impact:
- Gradle : 500MB économisés
- Android Studio : 1GB économisé
- Workers Gradle : ~800MB économisés
- Total : ~2.3GB RAM libérés
Fichier gradle.properties optimisé:
# Limite heap Gradle
org.gradle.jvmargs=-Xmx1536m -XX:MaxMetaspaceSize=512m -XX:+UseParallelGC
# Désactive le parallélisme (plus lent mais moins gourmand)
org.gradle.parallel=false
# Limite les workers
org.gradle.workers.max=2
# Active le cache Gradle (évite rebuilds inutiles)
org.gradle.caching=true
# Désactive R8 full mode (économise RAM pendant build)
android.enableR8.fullMode=falseCompromis:
⚠️ Builds 20-30% plus lents- ✅ Mais stables et sans crash
- ✅ Consommation RAM divisée par 2
Ajout d'un swap de 8GB:
# Création fichier swap 8GB
sudo fallocate -l 8G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
# Vérification
free -hImpact:
- Système ne crashe plus (swap absorbe les pics)
- Performance stable (plus lent mais prévisible)
- Builds Gradle passent de échec à succès
Problème résiduel: Même avec optimisations, l'émulateur restait lent (15-20 secondes pour lancer l'app).
Solution finale adoptée:
-
Build de l'APK en ligne de commande:
./gradlew assembleDebug
-
Transfert APK vers téléphone physique:
- Via USB :
adb install app-debug.apk - Ou transfert manuel (email, cloud)
- Via USB :
-
Tests sur matériel réel
Avantages:
- ✅ Performance native (pas de virtualisation)
- ✅ Tests réalistes (tactile, capteurs, rotation)
- ✅ Économie de RAM énorme (pas d'émulateur)
- ✅ Expérience utilisateur authentique
Outils utilisés pour identifier les problèmes:
# Monitoring RAM en temps réel
watch -n 1 'free -h'
# Processus consommant le plus de RAM
ps aux --sort=-%mem | head -10
# Logs Gradle (identifier bottlenecks)
./gradlew assembleDebug --info --scan
# Profiling Android Studio
# Help → Diagnostic Tools → Memory ProfilerIndicateurs surveillés:
- Heap Gradle (devait rester < 1.5GB)
- Swap usage (alerte si > 4GB utilisés)
- Build time (acceptable si < 3 minutes)
Avant optimisations:
- ❌ Builds : 50% échec (OOM)
- ❌ Émulateur : Inutilisable (< 5 FPS)
- ❌ Crashes Android Studio : 3-4 fois/jour
Après optimisations:
- ✅ Builds : 100% succès
- ✅ Tests : Appareils physiques (excellente performance)
- ✅ Crashes : 0
- ✅ Productivité : Workflow stable
Leçons apprises:
- Nix permet d'optimiser finement l'environnement de développement
- Swap est crucial sur machines avec RAM limitée
- Tests sur appareils physiques sont préférables quand possible
- Documentation des optimisations est essentielle (flake.nix comme référence)
- Compromis performance/stabilité acceptable en dev
Impact sur le binôme:
Le flake.nix optimisé a permis au binôme de développer sans aucun problème sur sa machine 16GB RAM, tout en garantissant que le projet compile aussi sur la machine 7GB RAM.
Contexte: Lors du développement en binôme, nous avons rencontré le besoin de :
- Valider automatiquement chaque modification de code
- Générer des APKs de test sans intervention manuelle
- Faciliter la distribution de versions aux testeurs
- Créer des releases pour la soumission du TP
Solution adoptée : GitHub Actions
GitHub Actions est un outil d'intégration continue intégré à GitHub qui permet d'automatiser les builds, tests et déploiements directement dans le repository.
Avantages concrets:
- ✅ Gratuit pour les repositories publics (minutes illimitées)
- ✅ APKs générés automatiquement à chaque push
- ✅ Téléchargement facile via interface GitHub
- ✅ Releases automatiques avec versioning
- ✅ Validation des tests avant merge
- ✅ Environnement de build reproductible
┌─────────────────────────────────────────────────────┐
│ DÉVELOPPEUR │
│ git push origin main / git tag v1.0 │
└─────────────────┬───────────────────────────────────┘
│
↓
┌─────────────────────────────────────────────────────┐
│ GITHUB REPOSITORY │
│ - Détecte push/tag │
│ - Déclenche workflows │
└─────────────────┬───────────────────────────────────┘
│
┌─────────┴──────────┐
↓ ↓
┌──────────────────┐ ┌──────────────────┐
│ build-apk.yml │ │ release.yml │
│ (Push main/PR) │ │ (Tags v*) │
├──────────────────┤ ├──────────────────┤
│ 1. Setup JDK 17 │ │ 1. Setup JDK 17 │
│ 2. Setup SDK │ │ 2. Setup SDK │
│ 3. Run tests │ │ 3. Run tests │
│ 4. Build APK │ │ 4. Build APK │
│ 5. Upload │ │ 5. Create Release│
└────────┬─────────┘ └────────┬─────────┘
│ │
↓ ↓
┌──────────────────┐ ┌──────────────────┐
│ ARTIFACTS │ │ GITHUB RELEASE │
│ - app-debug.apk │ │ - Version v1.0 │
│ - test-results │ │ - Changelog │
│ - Rétention 90j │ │ - APK attaché │
└──────────────────┘ └──────────────────┘
Fichier: .github/workflows/build-apk.yml
Déclencheurs:
- Push sur la branche
main - Pull Requests vers
main - Déclenchement manuel via interface GitHub
Étapes du workflow:
- Checkout du code : Récupération du repository
- Setup JDK 17 : Configuration de l'environnement Java (Temurin distribution)
- Setup Android SDK : Installation SDK Android via
android-actions/setup-android - Configuration Gradle : Permissions d'exécution pour
gradlew - Exécution tests unitaires :
./gradlew test --continue- Flag
--continue: Les tests s'exécutent sans bloquer le build continue-on-error: true: Build continue même si tests échouent- Résultats uploadés comme artifacts
- Flag
- Build APK Debug :
./gradlew assembleDebug - Upload APK : Artifact GitHub avec nommage
app-debug-{branch}-{sha}.apk- Rétention : 90 jours
- Téléchargeable depuis l'interface GitHub
Configuration technique:
runs-on: ubuntu-latest # 7GB RAM, 2 CPU cores
java-version: '17' # Compatible AGP 8.13.2
cache: 'gradle' # Accélère builds successifsOptimisations appliquées:
- Cache Gradle pour réduire le temps de build (~3-5 min au lieu de 8-10 min)
- Utilisation des optimisations
gradle.propertiesexistantes - Parallel workers limités à 2 (comme en local)
- Test results séparés de l'APK pour faciliter le debugging
Fichier: .github/workflows/release.yml
Déclencheur:
- Push de tags Git correspondant au pattern
v*(exemple :v1.0,v2.1.3)
Processus de release:
# Développeur crée un tag
git tag -a v1.0 -m "Release initiale pour soumission TP"
git push --tags
# GitHub Actions détecte le tag
# → Workflow démarre automatiquementÉtapes du workflow:
- Build de l'APK : Identique au workflow build-apk.yml
- Renommage de l'APK :
TP-Android-JT-v1.0.apk(plus explicite) - Création GitHub Release :
- Titre : "Version v1.0"
- Changelog : Généré automatiquement depuis les commits
- APK attaché en tant qu'asset téléchargeable
- Marqué comme "latest release"
Avantages pour la soumission du TP:
- ✅ APK facilement identifiable (nom avec version)
- ✅ Historique des versions conservé
- ✅ Changelog automatique pour traçabilité
- ✅ URL de téléchargement stable pour le professeur
1. Travail sur une fonctionnalité:
# Développement local
git add .
git commit -m "feat: add search functionality"
git push origin main2. GitHub Actions s'exécute automatiquement:
- ✅ Tests lancés (~2 min)
- ✅ APK construit (~5 min)
- ✅ Artifact disponible (~1 min upload)
3. Téléchargement de l'APK:
GitHub → Actions tab → Workflow run → Artifacts section → Download
4. Test sur appareil physique:
# Extraction ZIP
unzip app-debug-main-{sha}.zip
# Installation
adb install app-debug.apk1. Tag de la version finale:
# Vérifier que tout est commité
git status
# Créer tag annoté
git tag -a v1.0 -m "Version finale pour soumission TP - Janvier 2025"
# Pusher le tag
git push --tags2. GitHub Actions crée la release automatiquement (~7 min)
3. Téléchargement APK de soumission:
GitHub → Releases (sidebar) → Version v1.0 → TP-Android-JT-v1.0.apk
4. Envoi au professeur:
- Email : matthieu.papier@ext.unilasalle.fr
- Pièce jointe : TP-Android-JT-v1.0.apk
- Lien GitHub : https://github.com/twimart/TP-Android-JT/releases/tag/v1.0
Temps d'exécution typiques:
| Workflow | Première exécution | Avec cache | Détails |
|---|---|---|---|
| build-apk.yml | 8-10 min | 3-5 min | Setup SDK + deps + build |
| release.yml | 7-9 min | 4-6 min | Build + create release |
| Tests seuls | 1-2 min | 1-2 min | Unit tests uniquement |
Quotas GitHub Actions (tier gratuit):
- Minutes : ✅ Illimitées (repositories publics)
- Concurrent jobs : ✅ 20 simultanés
- Storage artifacts : 500 MB (nettoyage auto après 90j)
Utilisation estimée du projet:
- ~5 builds/jour × 5 min = 25 min/jour
- ~1 release/semaine × 5 min = 5 min/semaine
- Total : ~150 min/mois → Bien dans les limites gratuites
Stratégie de tests adoptée:
Tests unitaires (Unit tests):
- ✅ Exécutés sur chaque build
- ✅ Flag
--continue: N'interrompt pas le build si échec - ✅ Résultats uploadés comme artifact séparé
- ✅ Permet inspection des échecs sans bloquer l'APK
Tests instrumentés (Instrumented tests):
- ❌ NON exécutés en CI
- Raison : Nécessitent un émulateur (ralentit build de 10-15 min)
- Alternative : Tests manuels sur appareils physiques
Justification de la stratégie "soft enforcement":
continue-on-error: true # Tests informatifs, pas bloquantsPourquoi?
- Tests actuels = exemple basique (
2 + 2 = 4) - Pas de tests métier critiques (à améliorer en production)
- Priorité : Disponibilité APK > Couverture tests (contexte académique)
- Warnings visibles dans GitHub UI si échecs
Pour un projet production, on ajouterait:
- Tests obligatoires (strict enforcement)
- Couverture minimale 80%
- Tests d'intégration Compose UI
- Lint checks obligatoires
Compatibilité environnement local ↔ CI:
| Aspect | Local (Nix) | CI (GitHub Actions) | Cohérence |
|---|---|---|---|
| JDK | 21 (via flake.nix) | 17 (workflow) | ✅ Compatible AGP 8.13.2 |
| Android SDK | Auto-installé | Via setup-android | ✅ Même APIs |
| Gradle | 8.13 (wrapper) | 8.13 (wrapper) | ✅ Identique |
| gradle.properties | RAM optimisé | Même fichier | ✅ Partagé |
| Build command | ./gradlew assembleDebug |
Identique | ✅ 100% |
Avantages de cette approche:
- ✅ Builds locaux = Builds CI (déterminisme)
- ✅ Debugging facile (reproduire l'environnement CI localement)
- ✅ Pas de surprises "ça marche en local mais pas en CI"
Gestion des secrets:
- ❌ Aucun secret requis (APK debug uniquement)
- ❌ Pas de keystore de release committé (sécurisé)
- ✅ Permissions minimales (contents: write uniquement pour releases)
Versioning sémantique:
v1.0.0 → Release initiale
v1.1.0 → Ajout fonctionnalité (feature)
v1.1.1 → Correction bug (fix)
v2.0.0 → Breaking change (architecture refactor)
Changelog automatique: GitHub génère automatiquement le changelog à partir :
- Commits depuis le dernier tag
- Pull Requests mergées
- Contributors
Exemple généré:
## What's Changed
* feat: add search functionality by @thomas in #12
* fix: cart quantity update bug by @thomas in #15
* docs: update README with CI/CD section by @thomas in #17
**Full Changelog**: v0.9...v1.0Limitations actuelles:
-
APK Debug uniquement (pas de release signé)
⚠️ Installation montre warning "source inconnue"- ✅ Acceptable pour TP académique
- 🔮 Amélioration : Ajouter signing automatique
-
Pas de tests instrumentés en CI
⚠️ UI non testée automatiquement- 🔮 Amélioration : Firebase Test Lab ou GitHub Actions Matrix
-
Pas de lint enforcement
⚠️ Code style non vérifié automatiquement- 🔮 Amélioration :
./gradlew lintDebugavec fail-on-error
Améliorations possibles:
# Exemple : Build matrix pour multiple architectures
strategy:
matrix:
arch: [armeabi-v7a, arm64-v8a, x86_64]# Exemple : Deploy to Firebase App Distribution
- name: Upload to Firebase
uses: wzieba/Firebase-Distribution-Github-Action@v1
with:
appId: ${{ secrets.FIREBASE_APP_ID }}
file: app/build/outputs/apk/debug/app-debug.apkRoadmap CI/CD:
- 🔮 Ajout badge build status dans README
- 🔮 PR comments automatiques avec APK download link
- 🔮 Code coverage reporting (JaCoCo + Codecov)
- 🔮 Dependency scanning (Dependabot)
- 🔮 Security scanning (CodeQL)
Pour modifier les workflows:
-
Fichiers à éditer:
.github/workflows/build-apk.yml # Build automatique .github/workflows/release.yml # Releases -
Tester localement (sans push):
# Valider syntaxe YAML cat .github/workflows/build-apk.yml | yamllint - # Simuler build local (identique CI) nix develop ./gradlew clean test assembleDebug
-
Debugging workflow échecs:
GitHub → Actions → Workflow run (rouge) → Job détails → Logs -
Ressources:
Commandes utiles:
# Re-run workflow failed
gh workflow run build-apk.yml
# Lister tous les runs
gh run list
# Télécharger artifacts en CLI
gh run download <run-id>
# Créer release en CLI
gh release create v1.0 app-debug.apk --title "Version 1.0"Avant CI/CD:
Code → Build local → Transfer APK → Test → Manual versioning → Email APK
↑ |
└────────────────────────────────────────────────────────────────────┘
Boucle manuelle, sujette à erreurs
Après CI/CD:
Code → Push → CI Build → Download APK → Test
↓
Auto-release (tags)
↓
GitHub Releases → URL stable
Gains mesurables:
- ⏱️ Temps de distribution APK : 10 min → 2 min (5x plus rapide)
- 🐛 Builds cassés détectés : Immédiatement (vs découverte tardive)
- 📦 Gestion versions : Automatique (vs manuel error-prone)
- 🤝 Collaboration : Simplified (APKs toujours disponibles)
TP-Android-JT/
├── app/
│ ├── build.gradle.kts # Configuration module app
│ ├── proguard-rules.pro
│ └── src/
│ ├── main/
│ │ ├── AndroidManifest.xml # Permissions, activités
│ │ ├── java/com/example/tpandroidthomasjaafar/
│ │ │ ├── MainActivity.kt # Point d'entrée
│ │ │ │
│ │ │ ├── data/ # Couche données
│ │ │ │ ├── local/ # Room Database
│ │ │ │ │ ├── AppDatabase.kt
│ │ │ │ │ └── CartDao.kt
│ │ │ │ │
│ │ │ │ ├── model/ # Data classes
│ │ │ │ │ ├── Product.kt
│ │ │ │ │ └── CartItem.kt
│ │ │ │ │
│ │ │ │ ├── remote/ # Retrofit API
│ │ │ │ │ ├── FakeStoreApi.kt
│ │ │ │ │ └── RetrofitInstance.kt
│ │ │ │ │
│ │ │ │ └── repository/ # Single source of truth
│ │ │ │ └── ProductRepository.kt
│ │ │ │
│ │ │ └── ui/ # Couche UI
│ │ │ ├── components/ # Composables réutilisables
│ │ │ │ ├── ProductCard.kt
│ │ │ │ └── CartItemCard.kt
│ │ │ │
│ │ │ ├── navigation/ # Routes
│ │ │ │ └── AppNavigation.kt
│ │ │ │
│ │ │ ├── screens/ # Écrans complets
│ │ │ │ ├── ProductListScreen.kt
│ │ │ │ ├── ProductDetailScreen.kt
│ │ │ │ ├── CartScreen.kt
│ │ │ │ └── ViewModelFactories.kt
│ │ │ │
│ │ │ ├── theme/ # Material3 theming
│ │ │ │ ├── Color.kt
│ │ │ │ ├── Theme.kt
│ │ │ │ └── Type.kt
│ │ │ │
│ │ │ └── viewmodel/ # Logique métier
│ │ │ ├── ProductViewModel.kt
│ │ │ ├── ProductDetailViewModel.kt
│ │ │ └── CartViewModel.kt
│ │ │
│ │ └── res/ # Ressources Android
│ │ ├── drawable/ # Icons
│ │ ├── mipmap/ # Launcher icons
│ │ └── values/
│ │ ├── colors.xml
│ │ ├── strings.xml
│ │ └── themes.xml
│ │
│ ├── test/ # Tests unitaires
│ │ └── java/.../ExampleUnitTest.kt
│ │
│ └── androidTest/ # Tests instrumentés
│ └── java/.../ExampleInstrumentedTest.kt
│
├── gradle/ # Gradle wrapper
│ ├── libs.versions.toml # Version catalog
│ └── wrapper/
│
├── build.gradle.kts # Configuration racine
├── settings.gradle.kts # Settings Gradle
├── gradle.properties # Propriétés (optimisations RAM)
├── flake.nix # Configuration Nix
├── flake.lock # Versions lockées Nix
├── .gitignore
└── README.md # Ce rapport
Principe : Feature-based + Layer-based
Nous avons opté pour une organisation hybride :
- Séparation par couches techniques (
data,ui) - Sous-division par fonctionnalité quand pertinent (
local,remote)
Avantages:
- Facile à naviguer pour un nouveau développeur
- Dépendances claires entre couches
- Respect du principe de séparation des responsabilités
Sans Nix (Installation manuelle):
- Android Studio Hedgehog+ (2023.1.1+)
- JDK 17 ou supérieur
- Android SDK avec API 24-36
- Git
Avec Nix (Recommandé):
- Nix avec support Flakes (instructions ci-dessous)
1. Installer Nix:
# Linux / macOS
sh <(curl -L https://nixos.org/nix/install) --daemon
# Redémarrer le shell
source /etc/profile2. Activer Flakes:
mkdir -p ~/.config/nix
echo "experimental-features = nix-command flakes" >> ~/.config/nix/nix.conf
# Redémarrer daemon Nix
sudo systemctl restart nix-daemon # Linux3. Cloner et lancer:
git clone git@github.com:twimart/TP-Android-JT.git
cd TP-Android-JT
# Entrer dans l'environnement (première fois : 5-15 min)
nix develop
# Lancer Android Studio
android-studio &Depuis Android Studio:
- Ouvrir le projet
- Attendre sync Gradle (1-2 minutes)
Build→Rebuild ProjectRun→Run 'app'
Depuis ligne de commande:
# Dans l'environnement Nix
nix develop
# Nettoyer
./gradlew clean
# Compiler APK debug
./gradlew assembleDebug
# APK généré ici:
# app/build/outputs/apk/debug/app-debug.apk
# Compiler APK release (optimisé)
./gradlew assembleRelease
# Installer sur appareil connecté
./gradlew installDebugGradle:
# Voir toutes les tâches disponibles
./gradlew tasks
# Vérifier dépendances
./gradlew dependencies
# Lancer tests unitaires
./gradlew test
# Lancer tests instrumentés (appareil requis)
./gradlew connectedAndroidTest
# Générer rapport de build
./gradlew build --scanADB (Android Debug Bridge):
# Lister appareils connectés
adb devices
# Installer APK
adb install app/build/outputs/apk/debug/app-debug.apk
# Désinstaller app
adb uninstall com.example.tpandroidthomasjaafar
# Voir logs en temps réel
adb logcat
# Nettoyer données app (vide panier)
adb shell pm clear com.example.tpandroidthomasjaafarNix:
# Entrer dans l'environnement
nix develop
# Sortir
exit
# Nettoyer cache Nix (libérer espace disque)
nix-collect-garbage -d
# Mettre à jour flake
nix flake updateChecklist de validation:
✅ Test 1 : Liste des Produits
- L'app se lance sans crash
- 20 produits s'affichent en grille
- Images se chargent correctement
- Badge panier affiche "0" au démarrage
- Filtre "Tous" est actif par défaut
- Filtrage par catégorie fonctionne (4 catégories)
- Scroll fluide sans lag
✅ Test 2 : Détails Produit
- Clic sur un produit ouvre l'écran détails
- Image, titre, description, prix s'affichent
- Note et nombre d'avis visibles
- Bouton "Ajouter au panier" fonctionne
- Snackbar de confirmation s'affiche
- Badge panier s'incrémente
- Ajouter 2× le même produit → quantité = 2 (pas de duplication)
✅ Test 3 : Panier
- Clic sur icône panier ouvre l'écran panier
- Articles ajoutés sont listés
- Bouton "+" augmente quantité → total recalculé
- Bouton "-" diminue quantité → total recalculé
- Quantité = 0 → article disparaît automatiquement
- Bouton "Vider" affiche dialog de confirmation
- Confirmer vide le panier
- Message "Panier vide" avec bouton "Commencer mes achats"
✅ Test 4 : Persistance
- Ajouter 3 produits au panier
- Fermer complètement l'app (swipe)
- Rouvrir l'app
- Aller au panier → articles toujours présents
✅ Test 5 : Navigation
- Liste → Détails → Retour → Liste (✓)
- Liste → Panier → Retour → Liste (✓)
- Détails → Panier → Retour → Détails (✓)
- Bouton back système fonctionne partout (✓)
✅ Test 6 : Gestion d'Erreur
- Mode avion activé → Message d'erreur s'affiche
- Bouton "Réessayer" présent
- Désactiver mode avion → Réessayer → Produits se chargent
✅ Test 7 : Performance
- Scroll liste fluide (60 FPS)
- Chargement images progressif
- Pas de memory leaks observés
- App stable sur session de 30+ minutes
Tests effectués sur:
- ✅ Pixel 3a (API 29) - Émulateur
- ✅ OnePlus 9 Pro (API 33) - Physique
- ✅ Samsung Galaxy S21 (API 31) - Physique (binôme)
Résolutions testées:
- 1080x1920 (Full HD)
- 1440x3200 (2K)
Orientations:
- Portrait : ✅ Interface adaptée
- Paysage : ✅ Grille s'ajuste automatiquement
Fichiers de test:
ExampleUnitTest.kt: Test basique (exemple fourni)
Commande:
./gradlew testNote: Pour un projet de production, nous ajouterions :
- Tests unitaires des ViewModels (mocking Repository)
- Tests du Repository (mocking API + DAO)
- Tests d'intégration Compose UI
- Tests end-to-end avec Espresso
| Exigence TP | Status | Validation |
|---|---|---|
| Design soigné | ✅ | Material3, spacing cohérent, animations |
| Responsive | ✅ | Grille adaptative, fillMaxSize, weight |
| Architecture propre | ✅ | MVVM strict, documentation KDoc |
| Min 85% appareils | ✅ | minSdk 24 → 95%+ couverture |
| Jetpack Compose | ✅ | 100% Compose, aucun XML layout |
| Lisibilité code | ✅ | Nommage clair, comments, README |
Objectifs atteints:
✅ Fonctionnel:
- Application complète avec 3 écrans fonctionnels
- Toutes les fonctionnalités demandées implémentées
- Persistance locale opérationnelle
- Gestion d'erreurs robuste
- Interface fluide et intuitive
✅ Technique:
- Architecture MVVM propre et maintenable
- Code documenté avec KDoc
- Utilisation moderne de Kotlin (Coroutines, Flow, StateFlow)
- Intégration réussie de Jetpack Compose
- Gestion optimale de la mémoire
✅ Collaboration:
- Environnement Nix reproductible
- Git workflow propre (branches, commits sémantiques)
- Documentation complète pour faciliter la reprise
Points forts du projet:
- Architecture solide : MVVM strict avec séparation claire des responsabilités
- Documentation exhaustive : README, KDoc, AGENTS.md
- Innovation avec Nix : Environnement de développement reproductible
- Résolution de problèmes : Optimisations RAM pour machine limitée
- Code quality : Patterns modernes, gestion d'erreurs, immutabilité
Technique:
-
❌ Performance émulateur sur machine 7GB RAM
- ✅ Solution : Optimisations Nix + Swap + Tests physiques
-
❌ Synchronisation IDE après modifications Gradle
- ✅ Solution : Invalidate Caches + Refresh dependencies
Apprentissage:
- Courbe d'apprentissage Jetpack Compose (nouveau paradigme)
- Compréhension Flow vs LiveData (choix architectural)
- Configuration Nix Flakes (documentation dense)
Fonctionnalités:
- 🔮 Recherche de produits (barre de recherche)
- 🔮 Tri des produits (prix, note, nom)
- 🔮 Liste de favoris (nouvelle table Room)
- 🔮 Historique des commandes
- 🔮 Authentification utilisateur
- 🔮 Mode sombre (Dark theme)
- 🔮 Pull-to-refresh sur la liste
- 🔮 Pagination (Paging3)
Technique:
- 🔮 Hilt pour injection de dépendances (plus scalable)
- 🔮 Tests unitaires complets (ViewModels, Repository)
- 🔮 Tests UI avec Compose Testing
- 🔮 GitHub Actions CI/CD déjà implémenté ✅
- 🔮 Analytics (Firebase Analytics)
- 🔮 Crash reporting (Firebase Crashlytics)
- 🔮 Monitoring performance (Firebase Performance)
UX/UI:
- 🔮 Animations de transition entre écrans
- 🔮 Skeleton loading (placeholder pendant chargement)
- 🔮 Haptic feedback (vibrations)
- 🔮 Accessibilité (TalkBack, content descriptions)
- 🔮 Internationalisation (i18n)
Compétences acquises:
Android:
- ✅ Maîtrise de Jetpack Compose
- ✅ Architecture MVVM en pratique
- ✅ Room Database + Flow
- ✅ Retrofit + gestion asynchrone
- ✅ Navigation Compose
- ✅ Material Design 3
Kotlin:
- ✅ Coroutines et programmation asynchrone
- ✅ Flow et StateFlow
- ✅ Data classes et sealed classes
- ✅ Extension functions
- ✅ DSL (Gradle Kotlin DSL)
DevOps:
- ✅ Nix Flakes pour environnements reproductibles
- ✅ Gradle optimizations
- ✅ Git workflow (branches, PRs, semantic commits)
- ✅ GitHub Actions CI/CD (build automation, releases)
- ✅ Documentation technique
Soft Skills:
- ✅ Travail en binôme
- ✅ Résolution de problèmes (RAM limitée)
- ✅ Lecture de documentation technique
- ✅ Debug et profiling
Ce projet a été une excellente opportunité d'appliquer les concepts modernes du développement Android. L'utilisation de Jetpack Compose a permis de créer une interface fluide et réactive, tandis que l'architecture MVVM a garanti la maintenabilité du code.
L'intégration de Nix pour gérer l'environnement de développement a été un défi technique enrichissant qui a porté ses fruits, notamment lors du travail en binôme. Les problèmes de performance rencontrés sur la machine limitée en RAM nous ont forcés à comprendre en profondeur la gestion mémoire d'Android et Gradle, aboutissant à des optimisations documentées et reproductibles.
Le résultat est une application fonctionnelle, stable et documentée, respectant toutes les exigences du TP et dépassant même certaines attentes avec la mise en place d'un environnement de développement moderne et reproductible.
Build et Installation:
./gradlew clean assembleDebug
./gradlew installDebug
adb install app/build/outputs/apk/debug/app-debug.apkDebugging:
adb logcat | grep "tpandroid"
adb shell pm clear com.example.tpandroidthomasjaafarNix:
nix develop
nix-collect-garbage -d
nix flake update- FakeStore API : https://fakestoreapi.com/
- Jetpack Compose Docs : https://developer.android.com/jetpack/compose
- Room Database : https://developer.android.com/training/data-storage/room
- Retrofit : https://square.github.io/retrofit/
- Nix Flakes : https://nixos.wiki/wiki/Flakes
- GitHub Repository : https://github.com/twimart/TP-Android-JT
- APK Debug :
app/build/outputs/apk/debug/app-debug.apk
Fin du Rapport
Ce document sert de rapport officiel pour le TP Android UniLaSalle. Il détaille les aspects fonctionnels et techniques de l'application e-commerce développée en Kotlin avec Jetpack Compose.