Aller au contenu

Vue d'ensemble du Flux de Connexion et de Données BLE

Ce diagramme décrit le cycle de vie complet d'une opération BLE dans l'application, depuis la vérification de l'état BLE du téléphone, jusqu'au scan et à la connexion, en passant par la lecture et l'écriture des données une fois l'appareil prêt. 

┌──────────┐
│   START  │
└────┬─────┘
     │
     ▼
┌─────────────────────┐
│Check BLE Status     │ ──────> getPhoneBleStatus()
└────┬────────────────┘
     │
     ▼
┌─────────────────────┐
│ Register Callbacks  │
│ - findDeviceCallback│
│ - connectSuccess    │
│ - connectFail       │
└────┬────────────────┘
     │
     ▼
┌─────────────────────┐
│  Start BLE Scan     │ ──────> startBleScan()
└────┬────────────────┘         ↓
     │                           ↓ (Scanning...)
     │                    findDeviceCallback
     │                      ↓  ↓  ↓  ↓  ↓
     │                    [Device List]
     ▼
┌─────────────────────┐
│   Stop Scan         │ ──────> stopBleScan()
└────┬────────────────┘
     │
     ▼
┌─────────────────────┐
│ Connect to Device   │ ──────> connBleByMacAddress()
└────┬────────────────┘
     │
     ├──────────────┬──────────────┐
     ▼              ▼              ▼
  Success      connectFail    Timeout
     │
     ▼
┌─────────────────────┐
│ Initialize Data     │ ──────> initBleData()
└────┬────────────────┘         ↓
     │                    Progress Updates
     │                      ↓  ↓  ↓  ↓
     │                    [Loading...]
     ▼
┌─────────────────────┐
│ Data Ready          │ ──────> onCompleteCallback
└────┬────────────────┘
     │
     ├──────────────┬──────────────┐
     ▼              ▼              ▼
┌─────────┐   ┌─────────┐   ┌─────────┐
│  Read   │   │  Write  │   │ Notify  │
│  Data   │   │  Data   │   │  Enable │
└─────────┘   └─────────┘   └─────────┘
     │              │              │
     └──────────────┴──────────────┘
                    │
                    ▼
              ┌──────────┐
              │   END    │
              └──────────┘
À un niveau élevé, le flux est :

1. Vérification de l'état BLE → getPhoneBleStatus()

  • Vérifier que le téléphone prend en charge BLE et que le Bluetooth est activé (et que les permissions requises sont accordées).
  • Si BLE n'est pas disponible ou désactivé, le flux doit s'arrêter ici et inviter l'utilisateur à agir.

2. Enregistrement des Rappels

  • Enregistrer les gestionnaires JavaScript afin que la couche native puisse renvoyer des événements dans WebView :
    • findDeviceCallback – appelé chaque fois qu'un appareil est découvert lors du scan.
    • connectSuccess – appelé lorsqu'une connexion à un appareil réussit.
    • connectFail – appelé lorsqu'une tentative de connexion échoue (y compris les expirations ou les erreurs). Cela rend l'ensemble du processus piloté par événements plutôt que par sondage.

3. Démarrage du Scan BLE → startBleScan()

  • Commencer à scanner les appareils BLE à proximité.
  • Pendant le scan :
    • Le code natif découvre les appareils.
    • Pour chaque appareil, la couche native appelle findDeviceCallback avec les détails (ex. nom, adresse MAC, RSSI).
    • WebView met à jour la liste des appareils affichée à l'utilisateur.

4. Arrêt du Scan → stopBleScan()

  • Une fois que l'utilisateur a sélectionné un appareil dans la liste, le scan est arrêté pour économiser de l'énergie et réduire le bruit.
  • L'appareil sélectionné (typiquement identifié par son adresse MAC) est ensuite utilisé pour l'étape de connexion.

5. Connexion à l'Appareil → connBleByMacAddress()

  • Initier une connexion à l'appareil sélectionné en utilisant son adresse MAC.
  • À partir de là, il y a trois résultats possibles :
    • Success → le rappel connectSuccess est invoqué par le code natif.
    • Failure → le rappel connectFail est invoqué (ex. appareil rejeté, hors de portée).
    • Timeout → traité comme un échec, souvent signalé via connectFail avec une raison d'expiration.
  • En cas de succès, le flux passe à l'initialisation des données.

6. Initialisation des Données → initBleData()

  • Après une connexion réussie, l'application prépare l'appareil pour utilisation :
    • Découverte des services et des caractéristiques.
    • Configuration des mappages internes pour les opérations de lecture/écriture/notification.
    • Chargement optionnel de certaines valeurs initiales depuis l'appareil. Pendant cette étape, l'IU affiche généralement Chargement… avec des mises à jour de progression au fur et à mesure que le code natif signale la progression de l'initialisation.

7. Données Prêtes → onCompleteCallback

  • Lorsque l'initialisation est terminée, le natif notifie WebView (ex. via onCompleteCallback).
  • À ce stade :
    • L'état de chargement est supprimé.
    • Les contrôles principaux de l'appareil sont activés, et l'utilisateur peut désormais interagir avec l'appareil.

8. Lecture / Écriture / Notification

  • Avec l'appareil entièrement initialisé, l'application prend en charge trois types d'interactions principales :
    • Read Data – lire les valeurs actuelles d'une caractéristique (ex. valeurs de capteurs, niveau de batterie).
    • Write Data – envoyer des commandes ou des valeurs de configuration à l'appareil.
    • Notify Enable – s'abonner aux notifications de caractéristiques afin que l'appareil puisse envoyer des mises à jour automatiquement.
  • Ces opérations peuvent être répétées autant que nécessaire jusqu'à ce que l'utilisateur se déconnecte ou quitte l'écran, auquel point le flux atteint effectivement END et peut être redémarré si nécessaire.

Ce flux assure un flux BLE clair, étape par étape : Vérification d'état → Rappels → Scan → Connexion → Initialisation → Interaction (Lecture/Écriture/Notification).