À propos de ce cours
Objectif : recevoir des données dès qu'elles changent, sans que l'application ait à redemander.
HTTP = une lettre, WebSocket = un appel téléphonique
Avec HTTP, l'application pose une question et attend la réponse, puis la connexion se ferme : comme une lettre. Pour savoir si le livreur a bougé, il faudrait renvoyer une lettre toutes les secondes. Avec un WebSocket, la connexion reste ouverte dans les deux sens, comme un appel : le serveur peut parler à tout moment sans qu'on lui demande.
Exemples de tous les jours : messages WhatsApp ou Messenger, position du livreur ou du chauffeur VTC sur la carte, cours des cryptomonnaies ou de la bourse, scores sportifs en direct, jeux multijoueurs, commentaires d'un live TikTok.
| Approche | Fonctionnement | Avantage | Inconvénient |
|---|---|---|---|
| Polling HTTP | Une requête GET toutes les X secondes | Simple | Gaspille données et batterie, retard |
| WebSocket | Connexion permanente (wss://) |
Instantané, bidirectionnel | Connexion à gérer (fermeture, reconnexion) |
| Firestore (chap. 23) | snapshots() écoute la base |
Temps réel sans serveur à coder | Lié à Firebase |
Rappel : les Stream
Un Future donne une valeur, plus tard. Un Stream donne une suite de valeurs dans le temps, comme un tuyau. Un WebSocket se lit comme un Stream, et Flutter fournit StreamBuilder pour l'afficher (même logique que FutureBuilder).
Mini-chat avec un serveur « écho »
Le serveur de test wss://echo.websocket.org renvoie chaque message reçu (il peut aussi envoyer un message d'accueil à la connexion).
flutter pub add web_socket_channel
import 'package:flutter/material.dart';
import 'package:web_socket_channel/web_socket_channel.dart';
class ChatPage extends StatefulWidget {
const ChatPage({super.key});
@override
State<ChatPage> createState() => _ChatPageState();
}
class _ChatPageState extends State<ChatPage> {
final _channel = WebSocketChannel.connect(Uri.parse('wss://echo.websocket.org'));
final _controller = TextEditingController();
final List<String> _messages = [];
@override
void initState() {
super.initState();
_channel.stream.listen(
(message) => setState(() => _messages.add('Serveur : $message')),
onError: (e) => setState(() => _messages.add('Erreur : $e')),
onDone: () => setState(() => _messages.add('Connexion fermée')),
);
}
void _envoyer() {
if (_controller.text.trim().isEmpty) return;
_channel.sink.add(_controller.text); // envoyer au serveur
setState(() => _messages.add('Moi : ${_controller.text}'));
_controller.clear();
}
@override
void dispose() {
_channel.sink.close(); // ✅ toujours fermer la connexion
_controller.dispose();
super.dispose();
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(title: const Text('Chat temps réel')),
body: Column(children: [
Expanded(
child: ListView.builder(
itemCount: _messages.length,
itemBuilder: (_, i) => ListTile(title: Text(_messages[i])),
),
),
Padding(
padding: const EdgeInsets.all(8),
child: Row(children: [
Expanded(child: TextField(controller: _controller, onSubmitted: (_) => _envoyer())),
IconButton(icon: const Icon(Icons.send), onPressed: _envoyer),
]),
),
]),
);
}
}
Exemple réel : le prix du Bitcoin en direct
Certaines plateformes publient des flux publics, sans clé. Par exemple Binance diffuse chaque transaction BTC/USDT ; le prix est dans le champ p du JSON reçu.
final channel = WebSocketChannel.connect(
Uri.parse('wss://stream.binance.com:9443/ws/btcusdt@trade'),
);
// Dans build() :
StreamBuilder(
stream: channel.stream,
builder: (context, snapshot) {
if (snapshot.hasError) return const Text('Flux indisponible');
if (!snapshot.hasData) return const CircularProgressIndicator();
final data = jsonDecode(snapshot.data as String);
final prix = double.parse(data['p']);
return Text('${prix.toStringAsFixed(2)} \$',
style: const TextStyle(fontSize: 40, fontWeight: FontWeight.bold));
},
)
Le chiffre change plusieurs fois par seconde, sans aucune requête de l'application : c'est le serveur qui pousse les données. (Exemple pédagogique sur des données publiques, pas un conseil d'investissement. Si ce flux est bloqué sur le réseau de l'établissement, utilisez le serveur écho.)
Bonnes pratiques
- Toujours
wss://(chiffré) en production, jamaisws://. - Fermer le canal dans
dispose(), sinon la connexion continue en arrière-plan. - Prévoir une reconnexion automatique (avec un délai qui augmente) quand
onDoneouonErrorse déclenche : les connexions mobiles coupent souvent (tunnel, ascenseur, changement Wi-Fi / 4G). - Échanger des messages en JSON avec un champ
type({"type": "message", "texte": "…"}) pour distinguer les événements.
Activité 24.9 — « Live » (1 h)
- Lancez le mini-chat et envoyez plusieurs messages. Affichez les messages « Moi » à droite et « Serveur » à gauche dans des bulles de couleurs différentes (comme WhatsApp).
- Affichez dans l'
AppBarun point vert « connecté » qui devient rouge quand la connexion se ferme. - Créez un écran « Prix en direct » avec le flux BTC/USDT. Colorez le prix en vert s'il monte, en rouge s'il baisse par rapport à la valeur précédente.
- Question de réflexion : pour une application de suivi de colis mise à jour deux fois par jour, faut-il un WebSocket ou une simple requête HTTP ? Justifiez.
Cet article vous a-t-il aidé ?
Merci pour votre avis sur cet article 🙏
Merci, votre message nous a bien été transmis 🙏
Cette leçon vous a été utile ? Partagez-la !