GATT — qu'est-ce que c'est, Generic Attribute Profile et implémentation sous Android

Qu'est-ce que GATT ?

GATT (Generic Attribute Profile) est un profil Bluetooth Low Energy (BLE) qui définit comment deux périphériques BLE échangent des données via le protocole d'attributs (ATT). GATT standardise la structure des données : toutes les données sont organisées dans une hiérarchie « service → caractéristique → descripteur ». Le profil a été introduit dans la spécification Bluetooth 4.0 (2010) avec le BLE et reste depuis le mécanisme principal de transfert de données pour les périphériques Bluetooth économes en énergie. Contrairement au Bluetooth classique, où les données sont transmises via un port série (SPP), GATT fournit un accès structuré aux données via des opérations de lecture, d'écriture et de notification.

Le rôle de GATT dans la pile BLE

La pile BLE se compose de plusieurs couches : couche physique (radio), couche de liaison (gestion de connexion), L2CAP (contrôle de canal logique), ATT (protocole d'attributs — accès aux attributs) et GATT (profil basé sur ATT). GATT est la couche la plus haute avec laquelle travaillent les développeurs d'applications. L'ATT sous-jacent fournit des opérations de base : lecture, écriture, notification et indication d'attributs. GATT ajoute de la sémantique : il définit ce qu'est un service et une caractéristique, comment ils sont regroupés et quelles règles s'appliquent lors de leur lecture et écriture. Selon la Bluetooth Core Specification 5.4 (2023), GATT prend en charge jusqu'à 65 535 attributs (services + caractéristiques + descripteurs) sur un seul périphérique.

Architecture GATT : services, caractéristiques et descripteurs

La hiérarchie GATT se compose de trois niveaux. Un service est un groupe logique de caractéristiques qui résout une tâche (par exemple, « Service de batterie » ou « Service de fréquence cardiaque »). Une caractéristique est une unité de données avec un type connu : niveau de batterie actuel, lecture de capteur, état d'interrupteur. Chaque caractéristique a une valeur et un ou plusieurs descripteurs qui décrivent les métadonnées : unités de mesure, paramètres de notification, plage de valeurs. Un UUID (identifiant universel unique) identifie de manière unique chaque service et chaque caractéristique.

Types d'opérations avec les caractéristiques

GATT prend en charge quatre types d'opérations pour interagir avec les caractéristiques. Read — le client demande la valeur actuelle d'une caractéristique au serveur. Write — le client envoie une nouvelle valeur au serveur. Notify — le serveur envoie une valeur au client sans accusé de réception (plus rapide mais moins fiable). Indicate — le serveur envoie une valeur avec accusé de réception (plus fiable mais plus lent). Le développeur choisit le type en fonction du scénario : pour les lectures de capteur de fréquence cardiaque, Notify est suffisant ; pour écrire la configuration d'une serrure intelligente, Write avec accusé de réception est nécessaire.

// Structure de données GATT dans le code Android
data class BleService(
    val uuid: UUID,
    val characteristics: List<BleCharacteristic>
)

data class BleCharacteristic(
    val uuid: UUID,
    val properties: Int, // READ, WRITE, NOTIFY, INDICATE
    val descriptors: List<BleDescriptor>,
    var value: ByteArray?
)

GATT et GAP : différences entre les profils BLE

La spécification BLE définit deux profils principaux : GAP (Generic Access Profile) et GATT (Generic Attribute Profile). GAP est responsable de la découverte des périphériques, de l'établissement de connexion et de la gestion de la visibilité — c'est la « couche réseau » du BLE. GATT est responsable de l'échange de données après l'établissement de la connexion — la « couche application ». Le développeur utilise GAP pour scanner et se connecter à un périphérique, et GATT pour lire, écrire et recevoir des notifications du périphérique connecté.

Rôles dans GATT

GATT définit deux rôles : Serveur GATT et Client GATT. Le serveur est un périphérique qui fournit des données (par exemple, un tracker d'activité envoyant des lectures de fréquence cardiaque). Le client est un périphérique qui demande des données (par exemple, un smartphone lisant les lectures). Dans la plupart des scénarios, l'application Android agit en tant que Client GATT et le périphérique BLE agit en tant que Serveur GATT. Cependant, Android peut également être un Serveur GATT — par exemple, lorsqu'une application émule un périphérique BLE pour d'autres appareils. Le rôle est déterminé lors de la phase de configuration de la connexion GATT et ne change pas pendant la session.

Comment fonctionne la communication GATT en BLE

Le processus de communication GATT commence après l'établissement de la connexion BLE entre les périphériques. D'abord, le Client GATT découvre les services sur le Serveur GATT via la découverte de services — Android le fait automatiquement lors de la connexion via BluetoothGatt.discoverServices(). Après la découverte, le client obtient une liste des services, caractéristiques et descripteurs disponibles. Ensuite, le client peut lire les valeurs des caractéristiques (Read), écrire de nouvelles valeurs (Write) ou s'abonner aux notifications (Set Notify/Indicate). Le Serveur GATT peut envoyer Notify/Indicate au client à tout moment après l'établissement de la connexion.

MTU — Unité maximale de transmission

Par défaut, la taille d'un seul paquet GATT (MTU) en BLE est de 23 octets, dont 3 octets d'en-tête ATT et 20 octets de données utiles. Si l'application doit transmettre plus de données (par exemple, une mise à jour OTA du firmware), il est possible de demander une augmentation du MTU jusqu'à 517 octets via requestMtu() dans Android. Un MTU accru réduit le nombre de paquets nécessaires pour transmettre un bloc de données — au lieu de 50 petits paquets, vous pouvez envoyer 2 gros paquets, ce qui réduit la consommation d'énergie et accélère la transmission. Le MTU maximum dépend de la version BLE et des capacités de la puce — Bluetooth 5.0 prend en charge jusqu'à 517 octets, les versions plus anciennes jusqu'à 247 octets.

// S'abonner aux notifications de caractéristiques
fun enableNotifications(gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic) {
    gatt.setCharacteristicNotification(characteristic, true)

    // Activer CCCD (Descripteur de configuration de caractéristique client)
    val cccdUuid = UUID.fromString("00002902-0000-1000-8000-00805f9b34fb")
    val descriptor = characteristic.getDescriptor(cccdUuid)
    descriptor?.let {
        it.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE)
        gatt.writeDescriptor(it)
    }
}

Gestion des notifications

Pour recevoir des notifications du Serveur GATT sur Android, vous devez implémenter le rappel BluetoothGattCallback.onCharacteristicChanged(). Dans cette méthode, l'application reçoit la valeur mise à jour de la caractéristique chaque fois que le serveur envoie Notify ou Indicate. Pour le traitement des données en temps réel, utilisez un tampon et les coroutines Kotlin — cela évite de bloquer le thread UI lors de notifications intensives (par exemple, plus de 100 lectures de fréquence cardiaque par seconde). Pour les Indications, vous devez appeler gatt.sendResponse() côté serveur — sur le client Android, cela est géré automatiquement.

Implémentation de GATT sur Android

Sur Android, le travail avec GATT est implémenté via les classes du package android.bluetooth : BluetoothGatt (connexion), BluetoothGattService (service), BluetoothGattCharacteristic (caractéristique) et BluetoothGattDescriptor (descripteur). La connexion à un périphérique BLE commence par l'appel de BluetoothDevice.connectGatt() — cette méthode retourne un BluetoothGatt via lequel toutes les opérations ultérieures sont effectuées. Tous les rappels GATT arrivent dans BluetoothGattCallback — c'est une interface asynchrone qui est appelée sur le même thread où BluetoothGatt a été créé. Important : toutes les opérations GATT doivent être effectuées séquentiellement — appeler plusieurs opérations simultanément sur le même BluetoothGatt entraîne des erreurs.

Cycle de vie de la connexion GATT

La gestion appropriée du cycle de vie de la connexion GATT est essentielle pour la stabilité de l'application BLE. Après avoir appelé connectGatt(), l'application attend le rappel onConnectionStateChange() avec l'état STATE_CONNECTED. Ensuite, le système lance automatiquement la découverte de services, après quoi onServicesDiscovered() est appelé. Ce n'est qu'après cela que vous pouvez effectuer des lectures, écritures et abonnements. Lors de la fin, appelez toujours gatt.close() dans onDestroy() ou onPause() — les connexions GATT non fermées consomment la batterie et peuvent bloquer la reconnexion au même périphérique sur Android.

// Se connecter au périphérique BLE via GATT
private val gattCallback = object : BluetoothGattCallback() {
    override fun onConnectionStateChange(
        gatt: BluetoothGatt, status: Int, newState: Int
    ) {
        if (newState == BluetoothProfile.STATE_CONNECTED) {
            gatt.discoverServices()
        }
    }

    override fun onServicesDiscovered(gatt: BluetoothGatt, status: Int) {
        val service = gatt.getService(UUID.fromString("180D"))
        val characteristic = service?.getCharacteristic(
            UUID.fromString("2A37")
        )
        characteristic?.let { enableNotifications(gatt, it) }
    }
}

Profils et services GATT standard

Bluetooth SIG définit des dizaines de profils et services GATT standard avec des UUID 16 bits fixes. Les plus courants : Battery Service (UUID 180F, caractéristique Battery Level 2A19), service Heart Rate (UUID 180D, caractéristique Heart Rate Measurement 2A37), service Device Information (UUID 180A, caractéristiques Manufacturer Name et Serial Number). L'utilisation de services standard garantit la compatibilité entre les périphériques de différents fabricants — tout bracelet de fitness avec un service Heart Rate devrait fonctionner avec toute application Android qui le prend en charge.

Conception de services GATT personnalisés

Si les services standard ne couvrent pas la tâche, le développeur peut créer des services GATT personnalisés avec des UUID 128 bits. Lors de la conception d'un service personnalisé, vous devez : définir un groupe logique de caractéristiques (par exemple, « Service de contrôle de serrure »), attribuer à chaque caractéristique les propriétés correctes (Read, Write, Notify), définir les valeurs autorisées et les unités de mesure via le descripteur Characteristic Presentation Format. Pour les protocoles complexes, il est recommandé d'inclure une caractéristique Command avec propriété Write et une caractéristique Status avec Notify — cela suit le modèle Command/Status adopté dans les applications BLE industrielles.

// Créer un service GATT personnalisé (Android comme Serveur GATT)
private fun createCustomService(): BluetoothGattService {
    val serviceUuid = UUID.fromString("12345678-1234-5678-1234-56789abcdef0")
    val service = BluetoothGattService(
        serviceUuid, BluetoothGattService.SERVICE_TYPE_PRIMARY
    )

    val charUuid = UUID.fromString("12345678-1234-5678-1234-56789abcdef1")
    val characteristic = BluetoothGattCharacteristic(
        charUuid,
        BluetoothGattCharacteristic.PROPERTY_READ or
        BluetoothGattCharacteristic.PROPERTY_NOTIFY,
        BluetoothGattCharacteristic.PERMISSION_READ
    )
    service.addCharacteristic(characteristic)
    return service
}