Communitygithub.com

Internationalisation Flutter avec flutter_localizations et intl

Ajoute les dépendances `flutter_localizations` et `intl`, active le flag `generate: true` dans le `pubspec.yaml` et crée un fichier de configuration `l10n.yaml`. Utilisez-le pour initialiser la prise en charge de la localisation dans un nouveau projet Flutter.

Qu'est-ce que Internationalisation Flutter avec flutter_localizations et intl ?

Cette compétence guide l'utilisateur à travers l'installation et la configuration complète de l'internationalisation (i18n) et de la localisation (l10n) d'un projet Flutter. Elle commence par l'ajout des dépendances `flutter_localizations` et `intl`, puis active la génération automatique de code avec le flag `generate: true` dans le `pubspec.yaml`. Un fichier de configuration `l10n.yaml` est créé pour définir les répertoires des bundles de ressources (`.arb`), le fichier template et le fichier de sortie. Ensuite, la compétence montre comment configurer le point d'entrée de l'application (`MaterialApp`/`CupertinoApp`) en important les localisations générées et en injectant les délégués et les locales supportées. Pour l'ajout ou la modification de contenu localisé, la compétence détaille le workflow : définir les chaînes dans les fichiers `.arb`, exécuter `flutter pub get` pour générer les classes de localisation, et consommer ces chaînes typées de manière sécurisée via `AppLocalizations.of(context)`. Elle couvre également les fonctionnalités avancées : les espaces réservés pour les données dynamiques, la gestion des pluriels (avec la syntaxe `plural`) et les sélections conditionnelles (avec `select`). Cette compétence s'applique à n'importe quel projet Flutter (Android, iOS, Web, Desktop) et utilise les outils standard de l'écosystème Flutter (Dart, `flutter pub get`, fichiers `.arb`). Elle est utile à tout développeur Flutter souhaitant mettre en place une localisation robuste, maintenable et typée, en évitant les erreurs manuelles grâce à la génération automatique de code.

Compatible avec~Claude Code~Codex CLI~Cursor✓Gemini CLI
npx skills add https://github.com/dbillion/hermes-skills-public/tree/HEAD/skills-external/flutter-setup-localization

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Internationalisation des applications Flutter

Sommaire

Concepts fondamentaux

Flutter gère l'internationalisation (i18n) et la localisation (l10n) via les packages flutter_localizations et intl. L'approche standard utilise des fichiers App Resource Bundle (.arb) pour définir les chaînes localisées, qui sont ensuite compilées en une classe AppLocalizations générée, permettant un accès typé et sécurisé dans l'arbre de widgets.

Workflow de configuration

Copiez et suivez cette checklist lors de l'initialisation de l'internationalisation dans un projet Flutter :

  • Suivi des tâches
    • 1. Ajouter les dépendances dans pubspec.yaml.
    • 2. Activer le flag generate.
    • 3. Créer le fichier de configuration l10n.yaml.
    • 4. Configurer MaterialApp ou CupertinoApp.

1. Ajouter les dépendances

Ajoutez les packages de localisation requis au projet. Exécutez les commandes suivantes dans le terminal :

flutter pub add flutter_localizations --sdk=flutter
flutter pub add intl:any

Vérifiez que votre pubspec.yaml contient les éléments suivants dans dependencies :

dependencies:
  flutter:
    sdk: flutter
  flutter_localizations:
    sdk: flutter
  intl: any

2. Activer la génération de code

Ouvrez pubspec.yaml et activez le flag generate dans la section flutter pour automatiser les tâches de localisation :

flutter:
  generate: true

3. Créer le fichier de configuration

Créez un nouveau fichier nommé l10n.yaml dans le répertoire racine du projet Flutter. Définissez le répertoire d'entrée, le fichier template et le fichier de sortie :

arb-dir: lib/l10n
template-arb-file: app_en.arb
output-localization-file: app_localizations.dart
synthetic-package: true

4. Configurer le point d'entrée de l'application

Importez les localisations générées et la bibliothèque flutter_localizations dans votre main.dart. Injectez les délégués et les locales supportées dans votre MaterialApp ou CupertinoApp.

import 'package:flutter_localizations/flutter_localizations.dart';
import 'package:flutter_gen/gen_l10n/app_localizations.dart'; // Ajustez le chemin si synthetic-package est false

// ... dans la méthode build
return MaterialApp(
  localizationsDelegates: const [
    AppLocalizations.delegate,
    GlobalMaterialLocalizations.delegate,
    GlobalWidgetsLocalizations.delegate,
    GlobalCupertinoLocalizations.delegate,
  ],
  supportedLocales: const [
    Locale('en'), // Anglais
    Locale('es'), // Espagnol
  ],
  home: const MyHomePage(),
);

Workflow d'implémentation

Suivez ce workflow lors de l'ajout ou de la modification de contenu localisé.

1. Définir les fichiers ARB

  • Si vous créez un NOUVEAU contenu : Ajoutez la chaîne de base dans le fichier template (lib/l10n/app_en.arb). Incluez une description pour le contexte.
  • Si vous MODIFIEZ du contenu existant : Localisez la clé dans tous les fichiers .arb supportés et mettez à jour les valeurs.
{
  "helloWorld": "Hello World!",
  "@helloWorld": {
    "description": "La salutation conventionnelle du programmeur débutant"
  }
}

Créez les fichiers correspondants pour les autres locales (par ex. app_es.arb) :

{
  "helloWorld": "¡Hola Mundo!"
}

2. Générer les classes de localisation

Exécutez la commande suivante pour déclencher la génération de code :

flutter pub get

Boucle de retour : Exécutez le validateur -> examinez la sortie du terminal pour les erreurs de syntaxe ARB -> corrigez les virgules manquantes ou les espaces réservés non correspondants -> relancez flutter pub get.

3. Consommer les chaînes localisées

Accédez aux chaînes localisées dans votre arbre de widgets en utilisant AppLocalizations.of(context). Assurez-vous que le widget appelant est un descendant de MaterialApp.

Text(AppLocalizations.of(context)!.helloWorld)

Formatage avancé

Utilisez des espaces réservés pour les données dynamiques, les pluriels et les sélections conditionnelles.

Espaces réservés

Définissez les paramètres entre accolades et spécifiez leur type dans l'objet de métadonnées.

"hello": "Hello {userName}",
"@hello": {
  "description": "Un message avec un seul paramètre",
  "placeholders": {
    "userName": {
      "type": "String",
      "example": "Bob"
    }
  }
}

Pluriels

Utilisez la syntaxe plural pour gérer les variations de chaînes basées sur la quantité. Le cas other est obligatoire.

"nWombats": "{count, plural, =0{no wombats} =1{1 wombat} other{{count} wombats}}",
"@nWombats": {
  "description": "Un message pluriel",
  "placeholders": {
    "count": {
      "type": "num",
      "format": "compact"
    }
  }
}

Sélections

Utilisez la syntaxe select pour les chaînes conditionnelles, comme le texte genré.

"pronoun": "{gender, select, male{he} female{she} other{they}}",
"@pronoun": {
  "description": "Un message genré",
  "placeholders": {
    "gender": {
      "type": "String"
    }
  }
}

Exemples

l10n.yaml complet

arb-dir: lib/l10n
template-arb-file: app_en.arb
output-localization-file: app_localizations.dart
synthetic-package: true
use-escaping: true

Implémentation complète d'un widget

import 'package:flutter/material.dart';
import 'package:flutter_gen/gen_l10n/app_localizations.dart';

class GreetingWidget extends StatelessWidget {
  final String userName;
  final int notificationCount;

  const GreetingWidget({
    super.key, 
    required this.userName, 
    required this.notificationCount,
  });

  @override
  Widget build(BuildContext context) {
    final l10n = AppLocalizations.of(context)!;

    return Column(
      children: [
        Text(l10n.hello(userName)),
        Text(l10n.nWombats(notificationCount)),
      ],
    );
  }
}

Individual skills in this repo

This repo contains 6 individual skills — each has its own dedicated page.

dbillion/hermes-skills-public

Edit an existing image based on a text prompt.

dbillion/hermes-skills-public

Expert in video composition, editing, and format conversion. Use when the user wants to generate high-quality video, overlay images on video, concatenate clips, create GIFs, or sync audio to video using mcp-avtool-go and mcp-veo-go.

dbillion/hermes-skills-public

All animation knowledge for HyperFrames — atomic motion rules, multi-phase scene blueprints, scene transitions, broader motion-design techniques, AND the seven runtime adapters (GSAP default, plus Lottie, Three.js, Anime.js, CSS keyframes, Web Animations API, TypeGPU). Use for any motion or animation task: pick 2-4 rules and compose, or load a blueprint, or look up runtime-specific API (e.g. GSAP eases / Lottie player / Three.js mixer). Also covers auditing an existing composition's choreography (animation map) and 24 named text-animation effects. HyperFrames-native: single paused timeline, seek-safe, deterministic.

dbillion/hermes-skills-public

Use the HyperFrames CLI development loop: init, add, catalog, capture, lint, check, snapshot, compare, grade-compare, preview, play, present, beats, keyframes, single or batch render, publish, cloud, cloudrun, feedback, lambda, doctor, browser, info, upgrade, skills, compositions, docs, benchmark, telemetry, transcribe, auth, tts, and remove-background. Also use when diagnosing build or render failures. validate, inspect, and layout are deprecated aliases; use check. Covers local, HeyGen-hosted cloud, AWS Lambda, and Google Cloud Run rendering.

dbillion/hermes-skills-public

The HyperFrames composition contract — build one renderable project. Use for composition structure, the `data-*` timing attributes, `class="clip"`, tracks, sub-compositions, variables, framework-owned media playback, deterministic-render rules, and validation. Also covers Tailwind projects and the STORYBOARD.md / SCRIPT.md plan formats. Read before writing composition HTML.

dbillion/hermes-skills-public

Non-animation creative direction for HyperFrames videos. Use for design spec (frame.md / design.md) handling, palettes, typography, narration, beat planning, audio-reactive visuals, composition patterns, and brand / style decisions. For atomic motion patterns and scene blueprints, use `hyperframes-animation`.

Skills associés