Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
Flutter

Temps réel avec les WebSockets

Recevoir des données en temps réel dans Flutter avec web_socket_channel : mini-chat et prix en direct....

0 chapitres 0 QCM Accès gratuit

À propos de ce cours

Recevoir des données en temps réel dans Flutter avec web_socket_channel : mini-chat et prix en direct.

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, jamais ws://.
  • 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 onDone ou onError se 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)

  1. 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).
  2. Affichez dans l'AppBar un point vert « connecté » qui devient rouge quand la connexion se ferme.
  3. 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.
  4. 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é ?