[Français] English

Mon environnement de développement Flutter sous Linux, orienté Android

Pourquoi j’utilise Flutter pour créer des applications Android

L’outil officiel pour développer des applications Android est Android Studio, que l’on peut installer entre autres sur Linux. C’est un IDE basé sur IntelliJ Idea. Mais que faire si je veux utiliser mon propre IDE au lieu de m’en imposer un qui nécessite énormément de ressources pour tourner (selon la documentation 8 Go de RAM au minimum et 32 Go recommandés !) ?

Je suis habitué à Neovim qui est par défaut léger, personnalisable, et peut devenir un IDE puissant avec toutes les fonctionnalités de développement que l’on veut (LSP, formateurs, débogueurs…) grâce à différents plugins. Ne cherchez pas à substituer Android Studio par Neovim, certes Android Studio est lourd mais il reste le meilleur outil pour gérer et intégrer entre eux tous les différents composants d’une application Android (fichiers XML pour les ressources UI, gestion du code Java / Kotlin, émulation, intégration avec Gradle…).

Flutter est un framework qui permet de développer des applications qui fonctionnent sur plusieurs plateformes (Android, iOS, Windows, Linux…), et ce à l’aide d’un seul langage de programmation (le Dart). Ce que j’aime beaucoup avec Flutter est l’aspect purement déclaratif de l’interface utilisateur. On peut deviner la structure de l’UI rien qu’en lisant le code Dart, là où les projets Android codés en Java / Kotlin ont je trouve une UI plus difficile à deviner, avec un mélange de code Java / Kotlin et fichiers XML pour comprendre comment est codé l’UI (c’est un peu moins vrai aujourd’hui avec le nouveau toolkit Jetpack Compose qui permet similairement à Flutter d’avoir une UI déclaratif avec seulement du code Kotlin, mais cette technologie reste toujours très dépendante à l’utilisation de Android Studio). La raison principale pour laquelle j’utilise Flutter est l’existence d’un plugin Neovim, flutter-tools.nvim, permettant de coder facilement des applications Flutter dans cet IDE.

Pourquoi je ne veux pas installer Flutter dans mon environnement Linux

Si vous installez et utilisez Flutter sur votre machine Linux personnelle, vous allez remarquer l’apparition de plusieurs fichiers et dossiers dans votre répertoire personnel $HOME :

$HOME
├── .cache
├── .config
├── .dart-tool
├── .dartServer
├── .flutter-devtool
├── .local
├── .pki
├── .pub-cache
├── .ssh
├── Bureau
├── Documents
├── Images
├── Modèles
├── Musique
├── Public
├── Téléchargements
├── Vidéos
├── .bash_profile
├── .bashrc
└── .flutter

Remarquez la présence dans $HOME de 5 répertoires ou fichiers liés à Flutter : .dart-tool, .dartServer, .flutter-devtool, .pub-cache et .flutter. Vous conviendrez que tout cela donne un $HOME désorganisé, surtout quand il existe une spécification de longue date, utilisée par une majorité de programmes, pour organiser de manière claire tous ces répertoires et fichiers (cf. la spécification “XDG Base Directory”). Pour rappel, le but de cette spécification est de garder une structure minimale de $HOME, comme suit, avec les répertoires de configuration Dart et Flutter dans ~/.config, ~/.cache, ~/.local/share ou ~/.local/state (selon l’utilité de ces répertoires) au lieu d’être directement dans $HOME :

$HOME
├── .cache
├── .config
├── .local
├── .pki
├── .ssh
├── Bureau
├── Documents
├── Images
├── Modèles
├── Musique
├── Public
├── Téléchargements
├── Vidéos
├── .bash_profile
└── .bashrc

Les développeurs Flutter sont au courant du non-respect de la spécification XDG :

On peut retrouver des utilisateurs se plaindre de ce problème en 2020, et à l’heure où j’écris ces mots (début 2026) le problème persiste. A priori dans un future proche il sera possible de préciser à l’aide d’une variable d’environnement un répertoire racine commun pour tous les dossiers et fichiers Dart et Flutter ci-dessus (c’est-à-dire par exemple avoir un répertoire ~/.local/share/dart contenant tous ces derniers. C’est mieux, bien que cela ne suive pas à la lettre la spécification XDG.).

Au lieu d’attendre pendant 6 ans la résolution de ce problème pour espérer une structure un peu meilleure, j’ai fait le choix de mon côté d’installer Flutter dans une VM dans le but de laisser mon répertoire personnel propre. Et puis rappelons que Flutter active de la télémétrie par défaut (“opt-out”). Alors certes Flutter est un logiciel libre, mais cette télémétrie ne m’inspire pas confiance pour faire tourner ce programme dans mon propre environnement Linux. Isolons Flutter !

Installation d’une VM avec Flutter

Pourquoi une VM

Rappelons que le but est d’isoler Flutter. Les machines virtuelles sont la méthode d’isolation par excellence, mais certains me reprocheront de ne pas faire cela dans un conteneur OCI (Docker entre autres). Alors pourquoi une VM et pas Docker ? La raison principale est que je veux un environnement persistent, puisque sur cette VM on va aussi installer des outils auxiliaires pour la construction d’applications Android (cf. plus bas). Certes on peut avoir de la persistance avec les volumes Docker, mais je trouve cela plus propre d’avoir une VM.

Peut-être pour de la virtualisation un peu plus légère un LXC aurait suffit. Si vous connaissez cette technologie alors ça vaut peut-être le coup. Ici je me concentre sur probablement le plus connu à savoir des machines virtuelles.

Création de la VM avec virt-install

L’outil d’excellence pour de la virtualisation dans Linux est selon moi libvirt. Je vais installer la VM avec virt-install et la gérer par la suite avec virsh, mais peut-être seriez-vous plus intéressés par virt-manager si vous souhaitez une interface graphique pour créer et gérer vos machines virtuelles. Je ne détaille pas l’installation de ces outils ici qui peut changer selon votre distribution Linux. Le wiki de Arch Linux reste une excellente référence pour cela.

Libre à vous de choisir votre distribution Linux pour la VM. Ni la documentation officielle de Flutter ni Android ne recommandent une distribution spécifique. Remarquons cependant que ces logiciels utilisent apt-get dans leur documentation d’installation de dépendances (et aussi yum pour Android) 1 2. Aussi remarquons que la documentation officielle pour construire AOSP (ce qui ne nous concerne bien évidemment pas ici) utilise Ubuntu 18.04 ou plus 3. En conclusion le choix le plus sûr ici serait Ubuntu LTS. De mon côté j’utilise Arch Linux par habitude et parce que je veux la dernière version de Neovim.

Téléchargez une image cloud de la distribution que vous avez choisie avec cloud-init installé (pas nécessaire dans l’absolu, mais utile pour éviter de taper quelques commandes pour préparer la VM).

mkdir -p ~/Documents/Flutter/dev-vm
cd ~/Documents/Flutter/dev-vm
# Pour Arch, aller voir
# https://gitlab.archlinux.org/archlinux/arch-boxes/-/packages pour avoir le
# bon lien à jour ci-dessous
wget "https://gitlab.archlinux.org/archlinux/arch-boxes/-/package_files/11243/download"

On vérifie notre téléchargement. Pour Arch, encore une fois allez voir le lien GitLab ci-dessus, et récupérez :

Pour vérifier le checksum :

sha256sum -c Arch-Linux-x86_64-cloudimg-20260301.495047.qcow2.SHA256

Pour vérifier les signatures, la clé publique associée est disponible ici. On vérifie avec :

gpg --import arch-key.asc
gpg --verify Arch-Linux-x86_64-cloudimg-20260301.495047.qcow2.sig
gpg --verify Arch-Linux-x86_64-cloudimg-20260301.495047.qcow2.SHA256.sig

On crée une clé SSH qui nous servira pour se connecter à la VM :

ssh-keygen -f ~/.ssh/id_ed25519_flutter -C host
# Affichez la clé publique pour plus tard
cat ~/.ssh/id_ed25519_flutter.pub

Créez le fichier user-data.yaml suivant. L’idée est d’avoir deux utilisateurs, un appelé arch pour l’administration système, et un appelé flutter pour faire tourner nos commandes Flutter. On installe aussi les dépendances nécessaires pour Flutter 1 et les outils CLI d’Android (nécessaires pour la construction d’applications Android). Enfin on ajoute une ligne à /etc/fstab pour monter dans la VM un stockage partagée entre l’hôte et la VM pour pouvoir accéder à nos projets Flutter dans la VM.

#cloud-config
users:
  - name: flutter
    ssh_authorized_keys:
      # Complétez la clé SSH publique avec celle créée ci-dessus
      - ssh-ed25519 ... host
  - name: arch
    sudo: 'ALL=(ALL:ALL) NOPASSWD: ALL'
    ssh_authorized_keys:
      # Complétez la clé SSH publique avec celle créée ci-dessus
      - ssh-ed25519 ... host

packages:
  # Dans Arch, pas besoin de curl et xz qui sont déjà installés
  #- curl
  - git
  - unzip
  #- xz
  - zip
  - glu
  - which
  - wget
  - jdk17-openjdk
  # Neovim et utilitaires
  - neovim
  - less
  - gcc
  - fd

write_files:
  - path: /etc/fstab
    append: true
    defer: true
    content: |-
      shared_mount /home/flutter/my-project virtiofs defaults 0 0

On installe la VM avec ce qui suit. Remplacez $HOME/Documents/Flutter/my-projects par le chemin vers vos projets Flutter.

virt-install --connect qemu:///system \
  --name flutter-dev \
  --network network=default \
  --memory 8192 \
  --vcpus 4 \
  --osinfo archlinux \
  --import \
  --noreboot \
  --cloud-init user-data="$HOME/Documents/Flutter/dev-vm/user-data.yaml" \
  --disk pool=default,size=20,backing_store="$HOME/Documents/Flutter/dev-vm/Arch-Linux-x86_64-cloudimg-20260301.495047.qcow2" \
  --memorybacking source.type=memfd,access.mode=shared \
  --filesystem source="$HOME/Documents/Flutter/my-projects",target=shared_mount,driver.type=virtiofs

L’installation prend un peu de temps, et est complète lorsque la VM affiche [ OK ] Reached target Cloud-init target.. Vérifiez que cloud-init a bien tout installé. Ouvrez un autre terminal, connectez-vous en tant que arch, mettez à jour la VM et éteignez la :

# On récupère l'adresse IP locale de la VM avec :
virsh --connect qemu:///system domifaddr flutter-dev
ssh -i ~/.ssh/id_ed25519_flutter arch@192.168.122.123
# Dans la VM :
sudo pacman -Syu
sudo poweroff

Installation de Flutter et des outils CLI d’Android

On démarre et on se connecte sur la VM avec l’utilisateur flutter :

virsh --connect qemu:///system start flutter-dev
ssh -i ~/.ssh/id_ed25519_flutter flutter@192.168.122.123

Puis on installe Flutter 1 :

mkdir ~/develop
cd ~/develop
# Allez sur le site de Flutter pour récupérer le lien à jour
wget "https://storage.googleapis.com/flutter_infra_release/releases/stable/linux/flutter_linux_3.41.4-stable.tar.xz"
tar -xf flutter_linux_3.41.4-stable.tar.xz -C .
echo 'export PATH="$HOME/develop/flutter/bin:$PATH"' >> ~/.bashrc
# Reconnectez-vous et vérifiez l'installation
flutter --version
flutter --disable-analytics
dart --version

Ensuite on installe les outils CLI d’Android, nécessaires pour constuire les applications Android 4.

Les outils sont installés avec une archive qui contient ces derniers dans le répertoire cmdline-tools/bin. Or certains de ces outils attendent que le chemin vers leur exécutable soit cmdline-tools/latest/bin. Pour régler ce problème, on va d’abord installer les outils avec l’archive, ensuite utiliser sdkmanager pour réinstaller ces outils au bon endroit, et enfin supprimer les outils installés avec l’archive.

cd ~/develop
# Le lien ci-dessous est issu de la page
# "https://developer.android.com/studio", section "Command line tools only".
# Vérifiez que le lien n'a pas changé entre-temps
wget "https://dl.google.com/android/repository/commandlinetools-linux-14742923_latest.zip"
unzip commandlinetools-linux-14742923_latest.zip -d ~/develop/temp-android-sdk
mkdir -p ~/Android/Sdk
~/develop/temp-android-sdk/cmdline-tools/bin/sdkmanager --sdk_root=$HOME/Android/Sdk/ "cmdline-tools;latest"
rm -rf ~/develop/temp-android-sdk
echo 'export PATH="$HOME/Android/Sdk/cmdline-tools/latest/bin:$PATH"' >> ~/.bashrc
# Reconnectez-vous
sdkmanager "platforms;android-36.1" "build-tools;36.1.0" "platform-tools"
# Note : Flutter nécessite aussi NDK et cmake (et d'autres outils), mais il les installera lui-même
# par la suite lorsque que l'on ferra tourner par exemple `flutter build apk`

# Vérifiez que Flutter trouve bien les outils de dev Android (SDK)
flutter doctor
# Acceptez les licences Android
flutter doctor --android-licenses

Neovim

Installez votre configuration personnelle de Neovim au bon endroit.

Si vous n’avez pas de configuration personnelle, exemple d’installation de Lazyvim (distribution Neovim) avec le plugin pour Flutter :

git clone https://github.com/LazyVim/starter ~/.config/nvim
rm -rf ~/.config/nvim/.git
cat <<EOF > ~/.config/nvim/lua/plugins/flutter.lua
return {
  {
    "nvim-flutter/flutter-tools.nvim",
    lazy = false,
    dependencies = { "nvim-lua/plenary.nvim" },
    config = true,
  },
}
EOF

Commandes de gestion de la VM

# Pour démarrer la VM
virsh --connect qemu:///system start flutter-dev
# Pour arrêter la VM (oui c'est bien `destroy` qu'il faut utiliser)
virsh --connect qemu:///system destroy flutter-dev

# Pour se connecter à la VM, on le rappelle
virsh --connect qemu:///system domifaddr flutter-dev
ssh -i ~/.ssh/id_ed25519_flutter flutter@192.168.122.123

Conseil : utilisez la variable d’environnement LIBVIRT_DEFAULT_URI pour éviter de taper à chaque fois --connect qemu:///system 5.

Ou utilisez virt-manager pour une gestion de la VM via interface graphique.

Tester son application Flutter sur les plateformes Web

Il faut faire une redirection de port.

ssh -i ~/.ssh/id_ed25519_flutter -L 8080:localhost:8080 flutter@192.168.122.123
# Dans la VM
cd /path/to/flutter/project
flutter run -d web-server --web-port 8080

Inconvénients de mon environnement de développement

Mais bon malgré tout ces inconvénients mon répertoire personnel reste propre !

  1. https://docs.flutter.dev/install/manual ↩︎ ↩︎ ↩︎

  2. https://developer.android.com/studio/install#linux ↩︎

  3. https://source.android.com/docs/setup/start/requirements ↩︎

  4. https://docs.flutter.dev/platform-integration/android/setup ↩︎

  5. https://wiki.archlinux.org/title/Libvirt#Management ↩︎

* Suivant >