Passer au contenu

Psittacus

Guide sur la sauvegarde de jeu dans Flutter avec une grille de sudoku en bois dans la jungle

Thème: Guides

Sauvegarder sa progression de jeu avec Flutter: shared_preferences vs Hive vs Isar vs SQLite

Comment gerer les donnees de sauvegarde dans un jeu Flutter sans perdre la progression des joueurs. Comparatif shared_preferences, Hive, Isar et SQLite.

Écrit par Maksymilian JackowskiDéveloppeur principal de jeux

Publié le 17 min

Un dimanche matin, vous ouvrez votre boîte de réception et découvrez le message d’un joueur désemparé. Après avoir mis à jour votre jeu de sudoku la veille, sa série de victoires de 214 jours consécutifs s’est volatilisée. La grille qu’il avait résolue à moitié est redevenue totalement vierge.

En inspectant le code, la cause apparaît rapidement : le fichier de sauvegarde ne comportait aucun numéro de version. La nouvelle version de l’application attendait une structure de données légèrement différente, et le mécanisme de chargement a discrètement renvoyé null face à ces champs inattendus. Techniquement, les données n’ont jamais été effacées du stockage, mais elles sont devenues illisibles pour le nouveau build. Pour le joueur, cette nuance n’a aucune importance : des mois d’efforts quotidiens sont tout simplement perdus.

Gérer l’état et la persistance des données dans Flutter (une problématique souvent recherchée sous le terme flutter game save data) semble anodin au premier abord. Cette impression s’évanouit dès qu’une mise à jour mal préparée corrompt les données des utilisateurs. Dans ce guide pratique, nous comparons les quatre solutions de stockage les plus répandues dans l’écosystème Flutter : shared_preferences, Hive, Isar et SQLite. Vous découvrirez quelles données méritent d’être écrites sur le disque, ce qu’il convient d’omettre, et comment mettre en place un patron d’enveloppe de sauvegarde (save envelope) avec des migrations de schéma strictement ascendantes. Tous les exemples de code sont rédigés en pur Dart et peuvent être testés directement dans DartPad.

Pourquoi la persistance est une fonctionnalité à part entière

Dans de nombreux tutoriels, la persistance des données est traitée comme une formalité technique vite expédiée entre la conception de l’interface et la publication sur les stores. Pour les joueurs, l’intégrité de leur sauvegarde constitue pourtant un contrat tacite avec le créateur. Les jeux de réflexion, comme le sudoku classique, reposent entièrement sur la continuité : une grille entamée dans les transports, une série quotidienne ininterrompue et des statistiques accumulées sur plusieurs mois créent l’attachement au jeu. Si une mise à jour détruit ces jalons, le joueur se sent trahi. Plutôt que de tout recommencer, il choisit souvent de désinstaller l’application.

La fiabilité de la sauvegarde a un impact direct sur la rétention. L’utilisateur doit avoir la certitude absolue qu’il peut verrouiller son écran ou basculer sur une autre application sans craindre de perdre ses chiffres saisis. Si quitter la partie en cours ressemble à un coup de dés, les joueurs hésitent à lancer une session quand ils ne disposent que de quelques minutes. Un système de sauvegarde solide est l’un des investissements les plus rentables pour fidéliser sa communauté.

Les quatre options de stockage dans Flutter

En pratique, presque tous les jeux mobiles développés avec Flutter s’appuient sur l’une des quatre approches suivantes. Chaque outil répond à des contraintes précises et présente des compromis distincts.

shared_preferences est le plugin officiel clé-valeur maintenu par l’équipe Flutter. Il encapsule les mécanismes natifs des plateformes : NSUserDefaults sous iOS et macOS, Android SharedPreferences ou la bibliothèque moderne DataStore Preferences. Il prend en charge les types primitifs : int, double, bool, String et List<String>. Depuis la version 2.3.0, le paquet propose deux nouvelles API, SharedPreferencesAsync et SharedPreferencesWithCache, tandis que l’ancienne classe SharedPreferences est vouée à disparaître. C’est l’outil idéal pour stocker les volumes sonores, le thème visuel ou des drapeaux simples, mais il ne convient absolument pas pour la sauvegarde principale d’un jeu.

Hive est une base de données clé-valeur légère écrite en pur Dart, inspirée de l’architecture Bitcask. Les données sont stockées dans des boîtes (boxes) typées ou dynamiques. Dès qu’une boîte est ouverte, les lectures s’effectuent de manière synchrone directement depuis la mémoire vive, ce qui assure des temps d’accès quasi instantanés. L’auteur d’origine ayant confié le projet à la communauté, celle-ci maintient et fait évoluer activement le fork hive_ce. Hive constitue un excellent choix pour les jeux de réflexion de taille modeste nécessitant une manipulation rapide de données structurées.

Isar est une base de données NoSQL avancée créée par le même développeur. Elle offre des requêtes indexées complexes, la gestion des relations entre objets et le support complet des transactions ACID. La version 3 est stable et largement adoptée. Le développement d’Isar 4 se prolonge cependant depuis de nombreux mois et le rythme des livraisons a ralenti. Avant d’adopter Isar pour un nouveau projet, consultez l’activité du dépôt Isar sur GitHub pour évaluer si cette cadence correspond à vos impératifs.

SQLite, généralement intégré via le plugin sqflite ou l’ORM typé drift, est la référence éprouvée du monde relationnel. Il garantit une conformité ACID totale, des décennies de stabilité et gère le mode WAL (Write-Ahead Logging) pour des lectures concurrentes rapides. Il encaisse sans faiblir des milliers de grilles de sudoku résolues avec l’historique détaillé de chaque coup joué. En contrepartie, il réclame davantage de code préparatoire : définition de schémas, requêtes SQL et gestion manuelle des migrations.

Tableau comparatif

OutilComplexité de mise en placeVitesse de lecture et écritureVolume de données idéalCas d’usage recommandé
shared_preferencesTrès faibleRapide pour de petites clésJusqu’à quelques KoRéglages audio, thème, drapeaux de tutoriel
HiveFaibleUltra-rapide (données en RAM)Jusqu’à quelques Mo par boîteFichier principal d’un jeu casual ou puzzle
IsarMoyenneTrès rapide avec indexDe quelques Mo à plusieurs dizainesModèles complexes nécessitant filtres et liens
SQLite (sqflite / drift)Moyenne à élevéeHaute fiabilité, ACID, WALN’importe quelle taille avec indexHistorique de parties, statistiques, entités

Comparatif visuel des solutions de stockage Flutter représentées par des coffres de capacités croissantes

Basez toujours votre choix technique sur votre scénario le plus exigeant et non sur l’état initial. L’état d’une seule grille de sudoku ne pèse qu’une fraction de kilo-octet. En revanche, si un joueur régulier accumule mille parties terminées avec l’horodatage et la durée de chaque coup, le volume grandit rapidement. Choisissez un outil qui reste fluide après des mois d’utilisation intensive.

Ce qu’il faut enregistrer et ce qu’il vaut mieux écarter

L’écriture sur disque la plus rapide reste celle que l’on n’a pas besoin d’exécuter. Avant de concevoir votre modèle, déterminez avec précision quelles informations méritent réellement une place sur le stockage persistant.

Données indispensables :

  • L’état de la grille active. Pour un jeu de sudoku : l’identifiant du défi, les chiffres initiaux donnés (ou la graine de génération), les coups saisis par le joueur, les annotations au crayon et le compteur de mouvements. Conservez le temps de jeu sous forme de millisecondes accumulées (elapsedMs) plutôt que comme un objet DateTime actif. Le chronomètre ne sera ainsi pas perturbé si le joueur change de fuseau horaire ou verrouille son téléphone plusieurs heures.
  • Les préférences du joueur. Volume de la musique et des effets, retours haptiques (vibrations), thème visuel choisi et niveau de difficulté souhaité.
  • Statistiques et séries de victoires. Nombre de victoires, temps moyens, records personnels et série quotidienne en cours accompagnée de la date de la dernière victoire validée. Un ancrage calendaire précis permet de vérifier la validité d’une série après une coupure ; un simple nombre comme streak = 12 ne permet aucun rattrapage en cas d’anomalie.
  • Indicateurs de progression. Confirmation de l’achèvement du tutoriel ou date d’affichage de la demande d’évaluation sur le store.

Données à proscrire de la sauvegarde :

  • Les données recalculables. La liste des candidats possibles pour chaque case d’un sudoku peut être déduite de l’état actuel de la grille en quelques microsecondes. L’écrire sur le disque alourdit inutilement le fichier et crée des risques d’incohérence si vos algorithmes de résolution évoluent.
  • L’état transitoire de l’interface. La position de défilement d’un menu, les fenêtres modales ouvertes ou l’étape d’une animation relèvent de la présentation, pas de la progression. Ces éléments doivent être reconstruits proprement au démarrage de l’écran.
  • Les instantanés complets à chaque tapotement. Enregistrez le progrès à des étapes opportunes : après une série de chiffres saisis, lors de la mise en pause ou lorsque l’application passe en arrière-plan. Bien qu’une grille au format JSON soit compacte, des centaines d’écritures par minute usent inutilement la mémoire flash et tirent sur la batterie.
  • L’horloge interne de l’appareil non vérifiée. Les joueurs n’hésitent pas à modifier l’heure de leur smartphone pour recharger plus vite leur énergie ou contourner des limites journalières. L’horloge locale ne doit servir qu’à l’affichage. Pour la logique de jeu et la validation des séries, fiez-vous à des horloges monotones ou à des horodatages issus de votre serveur.

La classe Dart suivante illustre une structure épurée pour un jeu de sudoku. Chaque champ correspond soit à la configuration initiale, soit à une décision du joueur, soit à un compteur. Ce code est écrit en pur Dart et tourne directement dans DartPad :

class SudokuSave {
  SudokuSave({
    required this.puzzleSeed,
    required this.entries,
    required this.pencilMarks,
    required this.elapsedMs,
    required this.hintsUsed,
  });

  factory SudokuSave.fresh(String seed) => SudokuSave(
        puzzleSeed: seed,
        entries: List.filled(81, 0),
        pencilMarks: const {},
        elapsedMs: 0,
        hintsUsed: 0,
      );

  final String puzzleSeed;           // Givens regenerate from the seed.
  final List<int> entries;           // 81 cells, 0 means empty.
  final Map<int, Set<int>> pencilMarks;
  final int elapsedMs;               // Accumulated time in milliseconds.
  final int hintsUsed;

  Map<String, Object?> toJson() => {
        'puzzleSeed': puzzleSeed,
        'entries': entries,
        'pencilMarks': {
          for (final e in pencilMarks.entries)
            '${e.key}': e.value.toList(),
        },
        'elapsedMs': elapsedMs,
        'hintsUsed': hintsUsed,
      };
}

Le patron d’enveloppe : un bouclier contre la corruption

Peu importe que vous utilisiez Hive, SQLite ou un simple fichier JSON sur disque, ne sauvegardez jamais vos données métier comme un objet brut. Encapsulez-les systématiquement dans une enveloppe (SaveEnvelope). Trois métadonnées fondamentales vous prémuniront contre la plupart des soucis en production : la version du schéma, un horodatage UTC et l’identifiant de l’appareil. Voici l’implémentation complète en pur Dart :

class SaveEnvelope {
  SaveEnvelope({
    required this.schemaVersion,
    required this.savedAtUtc,
    required this.deviceId,
    required this.payload,
  });

  static const int currentVersion = 1;

  final int schemaVersion;
  final DateTime savedAtUtc;
  final String deviceId;
  final Map<String, Object?> payload;

  Map<String, Object?> toJson() => {
        'schemaVersion': schemaVersion,
        'savedAtUtc': savedAtUtc.toIso8601String(),
        'deviceId': deviceId,
        'payload': payload,
      };

  static SaveEnvelope? fromJson(Map<String, Object?> json) {
    final version = json['schemaVersion'];
    if (version is! int || version > currentVersion) {
      // Either corrupted, or written by a newer build. Do not guess.
      return null;
    }
    final savedAt = DateTime.tryParse('${json['savedAtUtc']}');
    if (savedAt == null) return null;
    final payload = json['payload'];
    if (payload is! Map<String, Object?>) return null;
    return SaveEnvelope(
      schemaVersion: version,
      savedAtUtc: savedAt,
      deviceId: '${json['deviceId']}',
      payload: payload,
    );
  }
}

Notez la condition de garde dans la méthode fromJson : tout fichier dont la version est supérieure à celle prise en charge par l’application en cours d’exécution est immédiatement rejeté. Ce filtre empêche une ancienne version du jeu d’écraser aveuglément des données plus récentes et d’en détruire les champs inconnus. Au lieu d’un crash, vous pourrez inviter l’utilisateur à installer la dernière mise à jour.

Gestion des versions et migrations strictement ascendantes

Les migrations de données doivent s’appuyer sur de petites fonctions indépendantes, chacune faisant progresser le schéma d’une version exactement. Évitez d’écrire une fonction monolithique tentant de convertir n’importe quelle ancienne structure vers la plus récente. Il est bien plus sûr de chaîner de petites étapes séquentielles :

Map<String, Object?> migrateSave(Map<String, Object?> raw) {
  var version = raw['schemaVersion'];
  if (version is! int) return raw; // Legacy file with no version: treat as v0.
  var data = raw;
  while (version < SaveEnvelope.currentVersion) {
    data = switch (version) {
      0 => _v0ToV1(data),
      1 => _v1ToV2(data),
      _ => data,
    };
    version = data['schemaVersion'] as int;
  }
  return data;
}

Map<String, Object?> _v0ToV1(Map<String, Object?> data) => {
      ...data,
      'schemaVersion': 1,
      'deviceId': data['deviceId'] ?? 'legacy-device',
    };

Map<String, Object?> _v1ToV2(Map<String, Object?> data) => {
      ...data,
      'schemaVersion': 2,
      'savedAtUtc': data['savedAtUtc'] ??
          DateTime.fromMillisecondsSinceEpoch(0, isUtc: true)
              .toIso8601String(),
    };

Trois règles d’or pour assurer la pérennité du système en production :

  • Privilégiez les modifications additives. Plutôt que de renommer ou de supprimer des propriétés existantes, ajoutez de nouveaux champs munis de valeurs par défaut adaptées. Les versions antérieures du code ignoreront sans encombre les clés inconnues, alors qu’un champ attendu manquant provoque immanquablement une erreur.
  • Validez chaque migration avec des fichiers authentiques. Conservez dans vos tests unitaires de vrais fichiers de sauvegarde issus de chaque version précédemment publiée. Recréer des données factices à la main dans le code des tests masque souvent de vrais pièges de sérialisation.
  • Réalisez des écritures atomiques sur le disque. Écrivez d’abord vos données dans un fichier temporaire, forcez l’écriture matérielle (flush), puis substituez le fichier cible au moyen d’un renommage atomique (rename). En cas de coupure de courant inopinée, vous conserverez soit l’ancien fichier intact, soit le nouveau fichier complet, mais jamais un fragment incomplet. Les bases de données comme SQLite assurent cette garantie par défaut grâce à leurs transactions.

Étapes de migration de schéma de base de données ascendante représentées par des marches en pierre

Cinq pièges techniques qui surprennent les développeurs

1. shared_preferences n’assure aucune écriture disque immédiate. La documentation du paquet prévient sans détour que les écritures sur disque peuvent se faire de manière asynchrone en arrière-plan, sans certitude que les données survivent si le processus s’interrompt aussitôt. Les données critiques d’un jeu ne doivent donc jamais y être stockées. La perte d’un réglage de volume est sans gravité, mais l’effacement d’une série de 200 victoires au sudoku brise la confiance du joueur. Sur Android, privilégiez SharedPreferencesAsync, qui sauvegarde via DataStore Preferences au lieu des fichiers XML obsolètes.

2. Écriture asynchrone sur Android et temps de latence au démarrage. La méthode Android apply() rend la main instantanément tout en repoussant l’écriture physique. Dans certains scénarios défavorables, le système effectue ce vidage de tampon lors du prochain démarrage à froid de l’application, ce qui alourdit le temps de chargement. Si l’impact est imperceptible pour deux ou trois valeurs, des dizaines d’écritures répétées finissent par faire ramer le lancement du jeu.

3. Les scores de performance de Hive dépendent de la mémoire vive. De nombreux comparatifs sur Internet mesurent la rapidité de Hive sur des boîtes déjà ouvertes et conservées en RAM. Bien que ce soit le mode de fonctionnement normal, ces chiffres ne révèlent rien sur le temps nécessaire au démarrage à froid ni sur les débits d’écriture continue sur la mémoire flash. Prenez en compte le temps d’initialisation lors de la première ouverture après une mise à jour. N’oubliez pas non plus que le paquet initial n’évolue plus : tournez-vous vers le fork maintenu hive_ce.

4. L’horizon incertain d’Isar représente un risque de dépendance. Isar 4 fait l’objet d’un développement au long cours sans version finale stabilisée. Le choix d’une base de données pour un jeu mobile engage sur plusieurs années, car les joueurs conservent longtemps leurs titres favoris. Consultez le dépôt GitHub d’Isar ainsi que les tickets en cours avant de vous lancer. Isolez vos modèles du moteur de stockage afin de pouvoir changer de brique technique si nécessaire.

5. La sérialisation d’un gros JSON sur le thread UI fait chuter les images. L’exécution de jsonEncode sur un état de jeu volumineux mobilise le thread principal de Flutter (UI isolate), celui-là même qui calcule le rendu des images et gère les interactions tactiles. Si vous sérialisez de lourdes données à chaque coup joué, le jeu saccadera sur les appareils d’entrée de gamme. Déportez les encodages lourds vers un isolate secondaire via compute() ou réservez les sauvegardes aux étapes charnières. Vous trouverez d’autres bonnes pratiques dans le guide officiel Flutter sur la persistance.

Préparer son architecture pour la synchronisation cloud

En phase initiale, on met rarement en place un serveur dédié. Il est néanmoins judicieux d’organiser sa structure de données locale dès le début pour que l’ajout d’une synchronisation en ligne se fasse comme une simple intégration, sans devoir réécrire tout le projet.

Le patron d’enveloppe constitue un socle solide. Adoptez ces réflexes complémentaires :

  • Stockez systématiquement schemaVersion, deviceId et savedAtUtc. Toute logique de réconciliation s’appuie sur les métadonnées. Sans numéro de version, vous ne pourrez pas fusionner les données issues d’applications aux versions différentes. Sans horodatage, impossible d’établir la chronologie des coups, et sans identifiant d’appareil, diagnostiquer l’origine d’un conflit devient impossible.
  • Fusionnez les données champ par champ plutôt qu’au niveau du fichier entier. Imaginez un joueur qui termine une grille de sudoku hors ligne sur sa tablette, puis utilise un indice sur son smartphone une heure plus tard. Une stratégie naïve écrasant le fichier le plus ancien détruirait l’une de ces deux actions. La fusion au niveau de chaque propriété permet de conserver à la fois la grille résolue et le décompte des indices.
  • Surveillez les quotas imposés par les services cloud. Des plateformes comme Google Play Games Services imposent une taille maximale par emplacement de sauvegarde (souvent 3 Mo). C’est un espace gigantesque pour des données de jeu pures, tant que vous n’y glissez pas de captures d’écran ou de journaux bruts.
  • Ne vous fiez jamais à l’horloge locale pour déterminer l’ordre des événements. Les utilisateurs peuvent altérer l’heure de leur appareil. Conservez l’horodatage local (savedAtUtc) à des fins informatives et diagnostiques, mais appuyez-vous sur les horodatages générés par le serveur pour trancher les conflits de synchronisation.
  • La synchronisation doit préserver l’historique local du joueur. Une première connexion à un compte en ligne ne doit jamais écraser silencieusement des mois de progression enregistrés sur l’appareil. En cas de divergence, il est toujours plus prudent de combiner les données ou de demander au joueur quel état il souhaite conserver.

Synchronisation des données de jeu dans le cloud illustrée par des lanternes portant des tuiles de sudoku

Configurations recommandées pour un jeu de sudoku

La combinaison d’outils idéale dépend des besoins de votre jeu :

  • Le choix pragmatique par défaut : SharedPreferencesAsync pour les options basiques, associé à hive_ce pour le fichier principal de l’état du jeu. Un ensemble léger, rapide à exécuter dans les tests unitaires et garantissant un lancement quasi instantané.
  • Le choix analytique : la bibliothèque drift reposant sur SQLite. La solution idéale si vous prévoyez d’archiver chaque grille de sudoku jouée, de produire des statistiques détaillées et d’offrir des filtres avancés aux utilisateurs.
  • Le choix minimaliste : un fichier JSON unique écrit dans le dossier de l’application via path_provider avec renommage atomique. Pour un jeu simple comportant une seule partie en cours et des paramètres basiques, un fichier JSON suffit amplement.

Liste de contrôle avant le déploiement

Avant de publier votre jeu ou sa prochaine mise à jour sur les stores, passez en revue ces vérifications essentielles :

  • Chaque enregistrement comporte les champs schemaVersion, savedAtUtc et deviceId.
  • Le chargeur écarte les sauvegardes issues de versions plus récentes de l’application afin de protéger les données.
  • Les écritures sur disque sont strictement atomiques (fichier temporaire avec renommage ou transaction en base).
  • Les options simples sont logées dans shared_preferences, tandis que la progression repose sur un stockage pérenne.
  • Des fichiers d’exemple de chaque version antérieure du schéma sont intégrés à vos tests unitaires.
  • La sérialisation des données ne sature pas le thread UI pendant les phases de jeu.
  • Vous avez validé la taille maximale des données après plusieurs mois d’utilisation intensive.

Un mécanisme de sauvegarde irréprochable constitue le socle de la confiance accordée par les joueurs. Adoptez le versionnement de schéma et les écritures atomiques dès votre première ligne de code : votre jeu de sudoku préservera ainsi fidèlement les scores et les séries de victoires de vos utilisateurs pendant des années.

Lectures complémentaires

Polydocu - une aventure de sudoku

Neuf chiffres, une expédition dans la jungle, Poly le perroquet et aucun artifice payant. Rejoignez la liste d'attente et nous vous préviendrons dès le lancement.

Rejoindre la liste d'attente

Un seul e-mail à la sortie, aucun spam.

Trois autres notes du même carnet, choisies par thème et non par un algorithme.

Tous les articles