Mission 04 — Mode session

À l'issue de cette mission, vous saurez :

• orchestrer une logique de session (file de cartes, états, statistiques)
• animer une transition visuelle significative (flip)
• exploiter l'accéléromètre en respectant son cycle de vie

Spec

1. Depuis la liste, démarrer une session d'apprentissage avec les cartes en ordre aléatoire.
2. L'écran affiche le recto ; un tap sur la carte révèle le verso avec une animation de retournement (flip).
3. Réponse connue → bouton « Juste » : carte suivante.
4. Réponse inconnue → secouer le téléphone (= « Faux ») : la carte est remise dans la file jusqu'à être connue.
5. La session se termine quand toutes les cartes ont été « justes » ; afficher le résumé :
   1. temps passé,
   2. carte la plus difficile (la plus ratée),
   3. nombre de cartes connues à 100 % (zéro erreur),
   4. % de mémorisation (cartes 100 % / total).
6. L'accéléromètre est arrêté dès qu'on quitte l'écran d'apprentissage.

Maquette

Le flip attendu :

┌──────────────────────────┐    ┌──────────────────────────┐
│  Session   carte 3 / 10  │    │  Résumé de session       │
│                          │    │                          │
│   ┌──────────────────┐   │    │  ⏱ Temps passé : 4 min   │
│   │  Capitale de la  │   │    │  💀 Plus difficile :     │
│   │      CH ?        │   │    │     « 7 x 8 ? » (3 ratés)│
│   │  (tap = verso)   │   │    │  ✅ Connues à 100% : 7   │
│   └──────────────────┘   │    │  📊 Mémorisation : 70 %  │
│                          │    │                          │
│  [ Juste ]  (secouer=faux)│   │  [ Rejouer ]             │
└──────────────────────────┘    └──────────────────────────┘

Théorie utile

• Les 4 animations de base
• Enchaîner et combiner des animations
• Détecter une secousse (shake)
• Cycle de vie d'un capteur

Indices

• Le flip se fait en deux demi-rotations sur l'axe Y — le contenu change au milieu, quand la carte est invisible.
• L'évènement ShakeDetected arrive sur un thread secondaire : MainThread.BeginInvokeOnMainThread obligatoire pour toucher l'UI.
• Secousse sur l'émulateur : adb emu sensor set acceleration 100:100:100 (voir théorie).

• Mélanger une liste : cards.OrderBy(c => Random.Shared.Next()).ToList() — ou un Fisher-Yates pour les puristes.
• Une Queue<Card> modélise naturellement la file : Dequeue() pour la carte courante, Enqueue() pour remettre une carte ratée en fin de file.
• Comptez les erreurs par carte (dictionnaire id → nombre de ratés) : le résumé en découle directement.

Coup de pouce — squelette du flip

private bool _showingVerso = false;

private async void OnCardTapped(object sender, EventArgs e)
{
    if (_showingVerso) return;

    await cardView.RotateYTo(90, 200);
    // ... changer le texte affiché (recto → verso) ...
    cardView.RotationY = -90;
    await cardView.RotateYTo(..., ...);

    _showingVerso = true;
}

Validation

• L'ordre des cartes change d'une session à l'autre
• Tap sur le recto → animation flip → verso
• « Juste » passe à la carte suivante
• Secouer le téléphone remet la carte dans la file (démontrable sur émulateur via adb)
• Une carte ratée revient jusqu'à être connue ; la session se termine bien
• Quitter l'écran de session arrête l'accéléromètre (démontrable dans le code)

• Le résumé affiche les 4 statistiques exactes du CDC