De nom­breuses options s’offrent aux personnes sou­hai­tant pro­gram­mer leur propre ap­pli­ca­tion. Les kits de cons­truc­tion avec des com­po­sants d’ap­pli­ca­tion prêts à l’emploi sont par­ti­cu­liè­re­ment appréciés en raison de leur facilité d’uti­li­sa­tion, cependant les fra­me­works se dé­mar­quent de plus en plus dans leur manière d’organiser le processus de dé­ve­lop­pe­ment de façon aussi simple que possible pour l’uti­li­sa­teur. L’un des fra­me­works les plus modernes est le Software De­ve­lop­ment Kit (SDK) (kit de dé­ve­lop­pe­ment logiciel) Flutter développé par Google. Ce framework ouvert permet de dé­ve­lop­per des ap­pli­ca­tions mobiles hautement per­for­mantes (pour iOS et Android) ainsi que des ap­pli­ca­tions Web et PC dans le langage Google Dart.

Dans notre tutoriel Flutter, nous vous pré­sen­tons les prin­ci­pales étapes pour débuter avec le SDK de Google.

Apprendre Flutter : con­di­tions requises

Pour apprendre à pro­gram­mer avec Flutter, il n’est pas in­dis­pen­sable de disposer de con­nais­sances préa­lables en dé­ve­lop­pe­ment d’ap­pli­ca­tions et Web. De la même manière, vous n’avez en principe pas besoin de connaître le langage Google Dart évoqué pré­cé­dem­ment. Si vous êtes fa­mi­lia­risé avec le code orienté objet et les concepts de pro­gram­ma­tion fon­da­men­taux comme les variables, les boucles et les con­di­tions, vous êtes déjà bien équipé pour tra­vail­ler avec ce framework.

Dans ce tutoriel Flutter, nous allons tout d’abord nous pencher sur le dé­ve­lop­pe­ment avec le Software De­ve­lop­ment Kit et écrire à cet effet une ap­pli­ca­tion simple qui associera des mots selon un modèle aléatoire et nous affichera ensuite ces as­so­cia­tions. Pour ce faire, vous devrez disposer des outils in­dis­pen­sables à la pro­gram­ma­tion avec Flutter : le SDK Flutter et un éditeur. Le premier est dis­po­nible pour Windows, macOS et Linux. Vous pouvez té­lé­char­ger di­rec­te­ment le package d’ins­tal­la­tion sur le site Web officiel de Flutter.

En principe, vous pouvez choisir l’éditeur librement. Cependant, pour une ex­pé­rience uti­li­sa­teur optimale avec la com­plé­tion de code au­to­ma­tique, la co­lo­ra­tion syn­taxique ainsi que l’as­sis­tance au débogage et le trai­te­ment des widgets, Google re­com­mande l’uti­li­sa­tion d’un éditeur de code pour lequel la mul­ti­na­tio­nale propose également un plugin Flutter officiel : c’est la raison pour laquelle nous utilisons Android Studio dans notre tutoriel Flutter. Après avoir installé cet en­vi­ron­ne­ment optimisé pour le dé­ve­lop­pe­ment d’ap­pli­ca­tions sous Android, lancez le Plugin Flutter de la manière suivante :

  1. Cliquez sur l’entrée de menu « Fichier ».
  2. Cliquez sur « Pa­ra­mètres » puis sé­lec­tion­nez la rubrique « Plugins ».
  3. Saisissez « Dart » dans le champ de recherche et cliquez sur le bouton « Installer » pour le résultat du même nom afin d’installer l’extension né­ces­saire pour le langage de pro­gram­ma­tion Dart.
  4. Confirmez l’uti­li­sa­tion de l’extension de tiers avec « Accepter ».
  5. Répétez la procédure en re­cher­chant l’élément « Flutter ». Après l’ins­tal­la­tion, cliquez sur « Re­dé­mar­rer IDE » afin d’appliquer les mo­di­fi­ca­tions.
Note

Comme al­ter­na­tive à Android Studio, Google propose d’utiliser GNU Emacs, Visual Studio Code et IntelliJ IDEA, des ap­pli­ca­tions pour les­quelles il existe également un plugin Flutter officiel.

Étape 1 : créez votre première ap­pli­ca­tion Flutter

Une fois Flutter et l’en­vi­ron­ne­ment de dé­ve­lop­pe­ment souhaité (c’est-à-dire l’éditeur) installés, vous pouvez créer votre première ap­pli­ca­tion Flutter. Comme indiqué pré­cé­dem­ment, nous utilisons Android Studio pour ce tutoriel Flutter. Par con­sé­quent, nous démarrons IDE à cet effet. Dans le menu « Fichier », sé­lec­tion­nez tout d’abord « Nouveau » puis « Nouveau projet Flutter » afin de démarrer un nouveau projet à partir du framework de l’ap­pli­ca­tion.

Sé­lec­tion­nez « Ap­pli­ca­tion Flutter » comme type de projet souhaité puis cliquez sur « Suivant ». Dans le menu de con­fi­gu­ra­tion, donnez un titre à votre travail et dé­fi­nis­sez l’em­pla­ce­ment d’en­re­gis­tre­ment de votre ap­pli­ca­tion. Si vous le souhaitez, vous pouvez également ajouter une des­crip­tion du projet. À la ligne « Chemin SDK Flutter », indiquez le chemin vers le framework Flutter pré­cé­dem­ment installé.

Pour finir, cliquez sur « Terminer » afin de créer la nouvelle ap­pli­ca­tion Flutter. Dans le fichier main.dart – le fichier de travail de base pour vos projets ainsi que pour ce tutoriel Flutter –, ajoutez le code suivant pour que l’ap­pli­ca­tion affiche le message simple « Hello World » (vous pouvez supprimer le code déjà présent dans le fichier main.dart) :

// Copyright 2018 The Flutter team. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'package:flutter/material.dart';
void main() => runApp(MyApp());
class MyApp extends StatelessWidget {
	@override
	Widget build(BuildContext context) {
		return MaterialApp(
			title: 'Welcome to Flutter',
			home: Scaffold(
				appBar: AppBar(
					title: Text('Welcome to Flutter'),
				),
				body: Center(
					child: Text('Hello World'),
				),
			),
		);
	  }
}

Dès que vous avez ajouté l’extrait, vous pouvez procéder à l’affichage de cette première version de votre propre ap­pli­ca­tion. Dans Android Studio, sé­lec­tion­nez pour ce faire la machine virtuelle (sous « Sélection d’appareil Flutter ») puis cliquez enfin sur le bouton de lecture (« Run main.dart ») :

Note

Pour l’aperçu d’une ap­pli­ca­tion dans Android Studio, une image de la plate-forme cible souhaitée doit être installée. Dans le cas contraire, vous ne pourrez sé­lec­tion­ner aucun appareil de test virtuel dans « Flutter Device Selection » afin de procéder au test de l’ap­pli­ca­tion. Pour ajouter une image, sé­lec­tion­nez les entrées de menu « Outils » puis « AVD Manager ». Cliquez enfin sur « Create Virtual Device » (créer l’appareil virtuel) et installez l’appareil virtuel de votre choix. Vous trouverez une ex­pli­ca­tion complète de l’exécution et de la gestion d’appareils virtuels dans Android Studio sur le forum dé­ve­lop­peurs Android.

Le premier démarrage ou débogage de l’ap­pli­ca­tion prendra un peu de temps. Vous devrez patienter quelques instants avant de voir le message d’accueil ap­pa­raître sur l’écran de votre en­vi­ron­ne­ment de test.

Étape 2 : intégrer un pack externe

Après avoir lancé notre première ap­pli­ca­tion simple dans la première étape de notre tutoriel Flutter, nous allons main­te­nant la compléter avec un pack externe. Plus pré­ci­sé­ment, nous sou­hai­tons à présent intégrer le pack de mots né­ces­saire pour atteindre l’objectif de notre projet, à savoir créer une ap­pli­ca­tion associant des mots selon un modèle aléatoire. Ici, nous utilisons le pack open source « english_words » (licence MIT), dis­po­nible en open source sur la plate-forme pub.dev à l’instar de beaucoup d’autres packs. Le module comporte plus de 5 000 mots anglais parmi les plus courants et est donc idéal pour atteindre l’objectif de ce tutoriel Flutter.

Pour la gestion des packs et des in­ter­dé­pen­dances, les ap­pli­ca­tions Flutter utilisent le fichier pubspec.yaml. Ouvrez ce fichier et ajoutez à la liste des in­ter­dé­pen­dances une entrée pour le pack lin­guis­tique (faites attention à la version actuelle ; ici : 3.1.5) :

dependencies:
	flutter:
		sdk: flutter
	cupertino_icons: ^0.1.2
english_words: ^3.1.5

Exécutez ensuite la commande « flutter pub get ». Android Studio dispose même d’un bouton prévu à cet effet intitulé « Pub get ».

Revenez au fichier de travail principal main.dart et importez le pack lin­guis­tique :

import 'package:flutter/material.dart';
import 'package:english_words/english_words.dart';

Ajoutez par ailleurs les lignes suivantes dans le code de l’ap­pli­ca­tion :

final wordPair = WordPair.random();

Pour finir, remplacez l’entrée child res­pon­sable de l’affichage du texte « Hello World » par l’entrée suivante :

child: Text(wordPair.asPascalCase),

À chaque exécution de ce nouveau code d’ap­pli­ca­tion actualisé, vous obtenez une paire de mots anglais générée de manière aléatoire.

Étape 3 : ajouter un widget avec état

Les widgets sans état (Stateless Widgets), utilisés jusqu’à présent dans ce tutoriel Google Flutter, sont in­va­riables. Pendant la durée de vie d’une ap­pli­ca­tion, ces widgets ne peuvent pas changer de statut car ce type de widgets ne peut pas être réécrit pendant l’exécution de l’ap­pli­ca­tion. À l’inverse, les widgets avec état (Stateful Widgets) peuvent modifier leur statut même pendant l’exécution de l’ap­pli­ca­tion, de sorte qu’il n’est pas né­ces­saire de le définir dès l’exécution. Si vous souhaitez attribuer des éléments par­ti­cu­liers, c’est-à-dire de l’in­te­rac­ti­vité, à votre ap­pli­ca­tion Flutter, vous aurez besoin de widgets avec état.

Note

Dans Flutter, les widgets sont toujours avec ou sans état. Les icônes, les boutons ou les blocs de texte cons­ti­tuent des exemples clas­siques de com­po­sants sans état. Les cases à cocher, les for­mu­laires ou les curseurs sont en revanche des exemples clas­siques de widgets simples avec état.

L’ap­pli­ca­tion de notre exemple doit également recevoir un widget in­te­rac­tif à cet endroit. Deux ca­té­go­ries sont requises au minimum pour l’im­plé­men­ta­tion : une catégorie de widget avec état, qui génère de son côté une instance de catégorie d’état.

Pour commencer, nous allons créer une catégorie d’état mi­ni­ma­liste intitulée « Ran­dom­Word­sS­tate » en ajoutant le code suivant à la fin du fichier main.dart :

class RandomWordsState extends State<randomwords> {</randomwords>
	// TODO Add build() method
}

Dans ce cas, la catégorie d’état générique est attribuée ex­pli­ci­te­ment à l’uti­li­sa­tion du widget « Ran­dom­Words ». Le widget avec état à pro­pre­ment parler est écrit à l’étape suivante en ajoutant l’entrée ci-dessous dans le fichier main.dart (dans le code : avant la catégorie « Ran­dom­Word­sS­tate ») :

class RandomWords extends StatefulWidget {
	@override
	RandomWordsState createState() => RandomWordsState();
}

Si vous exécutez ce nouveau code d’ap­pli­ca­tion, Flutter vous indique qu’aucune fonction build() n’est ac­tuel­le­ment définie pour « Ran­dom­Word­sS­tate ».

Le com­men­taire de texte de subs­ti­tu­tion « //TODO Add build() method » se trouve à l’em­pla­ce­ment décidé dans l’extrait de catégorie d’état ajouté et est à présent remplacé par le code pour la fonction build() :

class RandomWordsState extends State<randomwords> {</randomwords>
	@override
	Widget build(BuildContext context) {
		final wordPair = WordPair.random();
		return Text(wordPair.asPascalCase);
	}
}

Pour finir, supprimez la ligne « final wordPair = WordPair.random(); » de la catégorie MyApp et remplacez l’entrée child « child: Text(wordPair.as­Pas­cal­Case), » par « child: Ran­dom­Words(), ».

Si vous exécutez ce nouveau code, l’appareil de test virtuel devrait comme pré­cé­dem­ment afficher une paire de mots en s’appuyant toutefois sur un widget avec état per­met­tant une in­te­rac­tion po­ten­tielle de l’uti­li­sa­teur actif.

Étape 4 : créer une liste dé­rou­lante à l’infini

Afin de donner un premier exemple de widget Flutter in­te­rac­tif, nous allons encore étendre notre ap­pli­ca­tion dans la dernière partie de ce tutoriel Google Flutter : plus pré­ci­sé­ment, nous allons adapter la catégorie « Ran­dom­Word­sS­tate », afin qu’elle ne présente plus seulement des paires de mots in­di­vi­duelles, mais une liste infinie de paires de mots que l’uti­li­sa­teur peut faire défiler. En outre, les paires de mots déjà proposées doivent être en­re­gis­trées (pour éviter les doublons) et la taille de la police des résultats doit être augmentée.

Com­men­çons par les deux points men­tion­nés en dernier (en­re­gis­tre­ment des résultats présentés et ajus­te­ment de la police), en intégrant une liste _sug­ges­tions et une variable _big­ger­Font :

class RandomWordsState extends State<randomwords> {</randomwords>
	final _suggestions = <wordpair>[];</wordpair>
	final _biggerFont = const TextStyle(fontSize: 18.0);
}

Ajoutez ensuite la fonction _build­Sug­ges­tions() adéquate dans la catégorie « Ran­dom­Word­sS­tate ») :

Widget _buildSuggestions() {
	return ListView.builder(
		padding: const EdgeInsets.all(16.0),
		itemBuilder: (context, i) {
			if (i.isOdd) return Divider();
			final index = i ~/ 2;
			if (index >= _suggestions.length) {
			_suggestions.addAll(generateWordPairs().take(10));
			}
			return _buildRow(_suggestions[index]);
		});
}

La fonction présentée complète l’ap­pli­ca­tion avec plusieurs pro­prié­tés : la liste de paires de mots (List.View) est notamment intégrée et gagne en vi­si­bi­lité grâce à une ligne de sé­pa­ra­tion d’un pixel (divider). En outre, cette fonction impose de fournir dix autres pro­po­si­tions (ligne : _sug­ges­tions.addAll) dès que l’uti­li­sa­teur est parvenu à la fin de liste ac­tuel­le­ment affichée.

Le widget étendu comporte une autre com­po­sante de base : la fonction _buildRow(), qui est appelée une fois par paire de mots et présente la paire sous forme de ListTitle. Cette fonction est donc im­plé­men­tée dès l’étape suivante :

Widget _buildRow(WordPair pair) {
	return ListTile(
		title: Text(
			pair.asPascalCase,
			style: _biggerFont,
		),
	);
}

La méthode build(), que nous avons im­plé­men­tée lorsque le widget avec état a été généré (étape 3), doit encore recevoir l’ordre d’utiliser la fonction build­Sug­ges­tions(). L’ancien contenu de la méthode doit donc être remplacé par le code suivant :

@override
Widget build(BuildContext context) {
	return Scaffold(
		appBar: AppBar(
			title: Text(‘Word Generator’),
		),
		body: _buildSuggestions(),
	);
}

Pour finir, ac­tua­li­sez également la méthode build() dans la catégorie MyApp en modifiant le titre et en dé­fi­nis­sant qu’il s’agit d’un widget Ran­dom­Words dans l’entrée accueil :

title: ‘Word Generator’,
home: RandomWords(),

Si vous exécutez de nouveau le code, l’ap­pli­ca­tion démarre sous le nouveau titre « Word Generator ». De plus, une liste complète d’as­so­cia­tions de mots est présentée et vous pouvez afficher d’autres résultats en faisant défiler.

Tutoriel Flutter : synthèse

Dans le cadre du tutoriel Google Flutter précédent, vous avez appris les bases es­sen­tielles pour tra­vail­ler avec Flutter et avez pu les mettre en pratique dans un exemple d’ap­pli­ca­tion simple. Na­tu­rel­le­ment, vous pouvez dé­ve­lop­per vos propres ap­pli­ca­tions Flutter de manière nettement plus détaillée et complète. Une fois que vous vous serez davantage fa­mi­lia­risé avec ce framework, vous pourrez notamment per­son­na­li­ser le design de votre ap­pli­ca­tion.

Pour conclure, nous vous pré­sen­tons une nouvelle fois le code complet de l’ap­pli­ca­tion de notre exemple dé­ve­lop­pée pour Android dans le fichier main.dart :

import ‘package:english_words/english_words.dart’;
void main() => runApp(MyApp());
class MyApp extends StatelessWidget {
	@override
	Widget build(BuildContext context) {
		return MaterialApp(
			title: ‘Word Generator’,
			home: RandomWords(),
		);
	}
}
class RandomWords extends StatefulWidget {
	@override
	RandomWordsState createState() => RandomWordsState();
}
class RandomWordsState extends State<randomwords> {</randomwords>
	final _suggestions = <wordpair>[];</wordpair>
	final _biggerFont = const TextStyle(fontSize: 18.0);
	@override
	Widget build(BuildContext context) {
		return Scaffold(
			appBar: AppBar(
				title: Text(‘Word Generator’),
			),
			body: _buildSuggestions(),
		);
}
Widget _buildSuggestions() {
		return ListView.builder(
			padding: const EdgeInsets.all(16.0),
			itemBuilder: (context, i) {
				if (i.isOdd) return Divider();
				final index = i ~/ 2;
				if (index >= _suggestions.length) {
				_suggestions.addAll(generateWordPairs().take(10));
				}
				return _buildRow(_suggestions[index]);
			});
}
Widget _buildRow(WordPair pair) {
		return ListTile(
			title: Text(
				pair.asPascalCase,
				style: _biggerFont,
			),
		);
	}
}
Aller au menu principal