Cette page fait partie de la documentation de la plate-forme d'applications Chrome, qui a été abandonnée en 2020. Les clients Enterprise et Education sur ChromeOS continueront d'y avoir accès au moins jusqu'en janvier 2025. En savoir plus sur la migration de votre application

Cette page a été traduite par l'API Cloud Translation.

Bluetooth

Ce document explique comment utiliser les fonctionnalités Bluetooth, Bluetooth Socket et Bluetooth Low d'énergie pour communiquer avec les appareils Bluetooth et Bluetooth à basse consommation.

Pour obtenir des informations générales sur le Bluetooth, consultez les caractéristiques Bluetooth officielles.

Exigences concernant le fichier manifeste

Pour les applications Chrome qui utilisent le Bluetooth, ajoutez l'entrée bluetooth au fichier manifeste et indiquez, si appropriés, les UUID des profils, des protocoles ou des services que vous souhaitez implémenter, ainsi que les identifiants vous souhaitez les mettre en œuvre avec les API de sockets et/ou à basse consommation.

Par exemple, pour une implémentation de socket:

"bluetooth": {
  "uuids": [ "1105", "1106" ],
  "socket": true
}

Et pour une implémentation à basse consommation:

"bluetooth": {
  "uuids": [ "180D", "1809", "180F" ],
  "low_energy": true
}

Pour accéder uniquement à l'état de l'adaptateur, détecter les appareils à proximité et obtenir des informations de base sur les appareils, seule l'entrée elle-même est requise:

"bluetooth": {}

Informations sur l'adaptateur

Obtenir l'état de l'adaptateur

Pour connaître l'état de l'adaptateur Bluetooth, utilisez la méthode bluetooth.getAdapterState:

chrome.bluetooth.getAdapterState(function(adapter) {
  console.log("Adapter " + adapter.address + ": " + adapter.name);
});

Notifications de l'adaptateur

L'événement bluetooth.onAdapterStateChanged est envoyé chaque fois que l'état de l'adaptateur change. Cela peut pour déterminer, par exemple, quand le signal radio de l'adaptateur est allumé ou éteint.

var powered = false;
chrome.bluetooth.getAdapterState(function(adapter) {
  powered = adapter.powered;
});

chrome.bluetooth.onAdapterStateChanged.addListener(
  function(adapter) {
    if (adapter.powered != powered) {
      powered = adapter.powered;
      if (powered) {
        console.log("Adapter radio is on");
      } else {
        console.log("Adapter radio is off");
      }
    }
  });

Informations sur l'appareil

Répertorier les appareils connus

Pour obtenir la liste des appareils connus de l'adaptateur Bluetooth, utilisez la méthode bluetooth.getDevices méthode:

chrome.bluetooth.getDevices(function(devices) {
  for (var i = 0; i < devices.length; i++) {
    console.log(devices[i].address);
  }
});

Tous les appareils sont renvoyés, y compris les appareils associés et ceux récemment détectés. Elle ne commencer la détection de nouveaux appareils (voir Détecter les appareils à proximité).

Recevoir des notifications sur l'appareil

Au lieu d'appeler bluetooth.getDevices plusieurs fois, vous pouvez utiliser la méthode bluetooth.onDeviceAdded, bluetooth.onDeviceChanged et bluetooth.onDeviceRemoved pour recevoir des notifications.

L'événement bluetooth.onDeviceAdded est envoyé chaque fois qu'un appareil est détecté par l'adaptateur ou établit une connexion avec l'adaptateur:

chrome.bluetooth.onDeviceAdded.addListener(function(device) {
  console.log(device.address);
});

L'ajout d'un écouteur pour cet événement ne lance pas la détection des appareils (voir la section Détection des appareils à proximité appareils mobiles).

Les modifications apportées aux appareils, y compris les appareils précédemment détectés qui vont être associés, sont notifiées par l'événement bluetooth.onDeviceChanged:

chrome.bluetooth.onDeviceChanged.addListener(function(device) {
  console.log(device.address);
});

Enfin, l'événement bluetooth.onDeviceRemoved est envoyé dès qu'un appareil associé est retiré de le système, ou si aucun appareil détecté n'a été détecté récemment:

chrome.bluetooth.onDeviceRemoved.addListener(function(device) {
  console.log(device.address);
});

Détection des appareils à proximité

Pour commencer la détection des appareils à proximité, utilisez la méthode bluetooth.startDiscovery. La découverte peut utilise beaucoup de ressources. Vous devez donc appeler bluetooth.stopDiscovery lorsque vous avez terminé.

Vous devez appeler bluetooth.startDiscovery chaque fois que votre application a besoin de détecter des appareils à proximité. Ne rendez pas l'appel conditionnel sur la propriété discovering de bluetooth.AdapterState. La l'appel aboutit même si une autre application détecte les appareils à proximité, et garantit que l'adaptateur continue d'effectuer la découverte après l'arrêt de cette autre application.

Les informations concernant chaque appareil nouvellement découvert sont reçues via bluetooth.onDeviceAdded. . Pour les appareils qui ont déjà été découverts récemment ou qui ont été associés à ou auquel vous êtes connecté, l'événement ne sera pas envoyé. Appelez plutôt bluetooth.getDevices pour obtenir les informations actuelles et utiliser l'événement bluetooth.onDeviceChanged pour être informé les modifications de ces informations à la suite de la découverte.

Exemple :

var device_names = {};
var updateDeviceName = function(device) {
  device_names[device.address] = device.name;
};
var removeDeviceName = function(device) {
  delete device_names[device.address];
}

// Add listeners to receive newly found devices and updates
// to the previously known devices.
chrome.bluetooth.onDeviceAdded.addListener(updateDeviceName);
chrome.bluetooth.onDeviceChanged.addListener(updateDeviceName);
chrome.bluetooth.onDeviceRemoved.addListener(removeDeviceName);

// With the listeners in place, get the list of devices found in
// previous discovery sessions, or any currently active ones,
// along with paired devices.
chrome.bluetooth.getDevices(function(devices) {
  for (var i = 0; i < devices.length; i++) {
    updateDeviceName(devices[i]);
  }
});

// Now begin the discovery process.
chrome.bluetooth.startDiscovery(function() {
  // Stop discovery after 30 seconds.
  setTimeout(function() {
    chrome.bluetooth.stopDiscovery(function() {});
  }, 30000);
});

Si l'utilisateur désactive le signal radio Bluetooth, toutes les sessions de découverte seront interrompues et ne seront pas réactivées. automatiquement lorsque la radio est allumée. Si cela est important pour votre application, nous vous conseillons de regarder bluetooth.onAdapterStateChanged. Si la propriété discovering passe à false, alors votre application devra à nouveau appeler bluetooth.startDiscovery pour reprendre. Faites attention aux car la découverte est gourmande en ressources.

Identifier les appareils

Différentes options sont proposées pour identifier les appareils renvoyés par bluetooth.getDevices et des événements associés.

Si l'appareil est compatible avec la spécification de l'ID d'appareil Bluetooth, plusieurs propriétés sont ajoutées au l'objet Device contenant les champs définis par cette spécification. Exemple :

chrome.bluetooth.getDevices(function(devices) {
  for (var i = 0; i < devices.length; i++) {
    if (devices[0].vendorIdSource != undefined) {
      console.log(devices[0].address + ' = ' +
                  devices[0].vendorIdSource + ':' +
                  devices[0].vendorId.toString(16) + ':' +
                  devices[0].productId.toString(16) + ':' +
                  devices[0].deviceId.toString(16));
    }
  }
});

La spécification de l'ID de l'appareil suffit généralement pour identifier un modèle en particulier, voire une révision, d'un appareil auprès d'un fournisseur. En son absence, vous devez vous fier aux informations concernant la classe ou type de l'appareil, éventuellement associé au préfixe du fabricant dans address.

La plupart des appareils Bluetooth fournissent des informations sur la classe d'appareil sous la forme d'un champ de bits interprété selon du document Baseband Assigned Numbers (Numéros attribués par bande de base). Ce champ de bits est disponible dans deviceClass. .

chrome.bluetooth.getDevices(function(devices) {
  for (var i = 0; i < devices.length; i++) {
    if (devices[0].vendorIdSource != undefined) {
      console.log(devices[0].address + ' = ' +
                  devices[0].deviceClass.toString(16));
    }
  }
});

L'analyse des champs peut s'avérer complexe. Pour les types d'appareils les plus courants, Chrome gère cela pour vous et définit le champ type. Lorsque cette fonctionnalité n'est pas disponible ou ne répond pas à vos besoins, vous devez analysez vous-même deviceClass.

chrome.bluetooth.getDevices(function(devices) {
  for (var i = 0; i < devices.length; i++) {
    if (devices[0].vendorIdSource != undefined) {
      console.log(devices[0].address + ' = ' + devices[0].type);
    }
  }
});

Utiliser RFCOMM et L2CAP

Les applications Chrome peuvent établir des connexions avec tout appareil compatible avec les services RFCOMM ou L2CAP. Cela inclut la majorité des appareils Bluetooth classiques sur le marché.

Connexion à une prise

Pour établir une connexion avec un appareil, vous avez besoin de trois éléments. Un socket pour établir la connexion créé à l'aide de bluetoothSocket.create. l'adresse de l'appareil auquel vous souhaitez vous connecter, et l'UUID du service lui-même.

Avant d'établir la connexion, vérifiez que l'adaptateur détecte l'appareil en utilisant bluetooth.getDevice ou via les API de détection d'appareils.

Les informations nécessaires pour établir la connexion sous-jacente, y compris si la communication RFCOMM ou le protocole L2CAP à utiliser et le canal (ou PSM) obtenu à l'aide de la détection SDP sur le appareil.

Exemple :

var uuid = '1105';
var onConnectedCallback = function() {
  if (chrome.runtime.lastError) {
    console.log("Connection failed: " + chrome.runtime.lastError.message);
  } else {
    // Profile implementation here.
  }
};

chrome.bluetoothSocket.create(function(createInfo) {
  chrome.bluetoothSocket.connect(createInfo.socketId,
    device.address, uuid, onConnectedCallback);
});

Gardez un handle vers le socketId afin de pouvoir ultérieurement envoyer des données (bluetoothSocket.send) à ce du socket.

Réception depuis et vers un socket

La réception et l'envoi de données vers un socket utilisent des objets ArrayBuffer. Pour en savoir plus sur les objets ArrayBuffer, consultez la présentation, les tableaux typés JavaScript et le tutoriel Convertir un objet ArrayBuffer. vers et depuis une chaîne.

Pour envoyer les données présentes dans arrayBuffer, utilisez bluetoothSocket.send:

chrome.bluetoothSocket.send(socketId, arrayBuffer, function(bytes_sent) {
  if (chrome.runtime.lastError) {
    console.log("Send failed: " + chrome.runtime.lastError.message);
  } else {
    console.log("Sent " + bytes_sent + " bytes")
  }
})

Contrairement à la méthode d'envoi de données, les données sont reçues dans un événement (bluetoothSocket.onReceive. Les sockets sont créés à nouveau (voir bluetoothSocket.setPaused). L'écouteur de cet événement est donc généralement ajouté entre bluetoothSocket.create et bluetoothSocket.connect.

chrome.bluetoothSocket.onRecieve.addListener(function(receiveInfo) {
  if (receiveInfo.socketId != socketId)
    return;
  // receiveInfo.data is an ArrayBuffer.
});

Réception d'erreurs de socket et déconnexion

Pour être averti des erreurs de socket, y compris des déconnexions, ajoutez un écouteur au paramètre l'événement bluetoothSocket.onReceiveError.

chrome.bluetoothSocket.onReceiveError.addListener(function(errorInfo) {
  // Cause is in errorInfo.error.
  console.log(errorInfo.errorMessage);
});

Déconnexion d'une prise

Pour raccrocher et déconnecter le socket, utilisez bluetoothSocket.disconnect.

chrome.bluetoothSocket.disconnect(socketId);

Services de publication

En plus d'établir des connexions sortantes vers les appareils, les applications Chrome peuvent publier des services qui peuvent être utilisé par tout appareil prenant en charge RFCOMM ou L2CAP.

Écoute via une prise

Deux types de services publiés sont acceptés. RFCOMM est la plus couramment utilisée et couvre la majorité des appareils et des profils:

var uuid = '1105';
chrome.bluetoothSocket.create(function(createInfo) {
  chrome.bluetoothSocket.listenUsingRfcomm(createInfo.socketId,
    uuid, onListenCallback);
});

L2CAP (L2CAP) est l'autre. Il couvre d'autres types d'appareils et des utilisations spécifiques aux fournisseurs, comme les micrologiciels l'importation.

var uuid = '0b87367c-f188-47cd-bc20-a5f4f70973c6';
chrome.bluetoothSocket.create(function(createInfo) {
  chrome.bluetoothSocket.listenUsingL2cap(createInfo.socketId,
    uuid, onListenCallback);
});

Dans les deux cas, vous pouvez transmettre une option bluetoothSocket.ListenOptions facultative pour attribuer une valeur ou PSM. Le rappel indique une erreur via chrome.runtime.lastError et une réussite sinon. Conservez un handle vers le socketId afin de pouvoir accepter plus tard les connexions (bluetoothSocket.onAccept) à partir de ce socket.

Accepter les connexions client

Les connexions client sont acceptées et transmises à votre application via la bluetoothSocket.onAccept.

chrome.bluetoothSocket.onAccept.addListener(function(acceptInfo) {
  if (info.socketId != serverSocketId)
    return;

  // Say hello...
  chrome.bluetoothSocket.send(acceptInfo.clientSocketId,
    data, onSendCallback);

  // Accepted sockets are initially paused,
  // set the onReceive listener first.
  chrome.bluetoothSocket.onReceive.addListener(onReceive);
  chrome.bluetoothSocket.setPaused(false);
});

Ne plus accepter les connexions client

Pour ne plus accepter de connexions client et annuler la publication du service, utilisez bluetoothSocket.disconnect.

chrome.bluetoothSocket.disconnect(serverSocketId);

Interaction avec les appareils à basse consommation

Bluetooth Low Energy ou (Bluetooth Smart) est une technologie sans fil conçue pour réduire la consommation d'énergie leur consommation. L'API Bluetooth Low Energy permet aux applications de jouer le rôle central une connexion LE à un périphérique. Les sections suivantes décrivent comment découvrir des ressources, interagir avec les périphériques Bluetooth basse consommation.

Détection de périphériques et connexion à ces périphériques

Comme pour les appareils Bluetooth traditionnels, les périphériques LE peuvent être détectés à l'aide des méthodes décrites dans Identifier les appareils à proximité . Un appareil LE se rend visible en envoyant des paquets de données appelé "Données publicitaires", L'appareil est alors considéré comme étant en mode annonce. Les données publicitaires peut contenir des UUID des services disponibles sur l'appareil. S'ils sont présents, ces UUID seront accessible à l'aide de la propriété uuids de l'objet bluetooth.Device correspondant.

Une fois découvert, un appareil LE peut être connecté en appelant bluetoothLowEnergy.connect : que l'application puisse interagir avec ses services:

chrome.bluetooth.onDeviceAdded.addListener(function(device) {
  var uuid = '0000180d-0000-1000-8000-00805f9b34fb';
  if (!device.uuids || device.uuids.indexOf(uuid) < 0)
    return;

  // The device has a service with the desired UUID.
  chrome.bluetoothLowEnergy.connect(device.address, function () {
    if (chrome.runtime.lastError) {
      console.log('Failed to connect: ' + chrome.runtime.lastError.message);
      return;
    }

    // Connected! Do stuff...
    ...
  });
});

Une fois la connexion établie, la propriété connected de l'objet bluetooth.Device correspondant prennent la valeur true. L'appel de bluetoothLowEnergy.connect établit une réclamation sur la connexion physique à l'appareil. Une connexion physique à l'appareil peut être établie sans jamais appeler bluetoothLowEnergy.connect (en raison d'une autre application, par exemple). Dans Dans ce cas, même si votre application peut toujours interagir avec les services de l'appareil, appelez toujours bluetoothLowEnergy.connect pour empêcher une autre application de déconnecter lien physique.

Une fois que votre application n'a plus besoin d'être associée, elle peut supprimer sa revendication concernant la connexion en appelant bluetoothLowEnergy.disconnect:

chrome.bluetoothLowEnergy.disconnect(deviceAddress);

Notez que cela ne supprimera pas nécessairement le lien physique vers l'appareil, car d'autres applications ayant des connexions actives à l'appareil. Parfois, l’appareil peut devenir déconnectée pour une raison échappant au contrôle de l'application (par exemple, si l'appareil disparaît ou est explicitement déconnecté par l'utilisateur via les utilitaires du système d'exploitation). Votre application doit suivre l'événement bluetooth.onDeviceChanged pour être informé des modifications. à la connexion, puis reconnectez-vous si nécessaire.

Une fois connecté, l'appareil qui exécute Chrome se voit attribuer le rôle central, tandis que l'appareil distant se trouve dans le rôle de périphérique. À ce stade, votre application peut interagir avec les services de l'appareil à l'aide des méthodes décrites dans la section suivante. Remarque : Les API ne permettent actuellement pas d'agir en tant que périphérique LE. les applications peuvent uniquement implémenter le rôle central.

Services, caractéristiques et descripteurs

Le Bluetooth à basse consommation est basé sur un protocole simple de requête/réponse appelé Attribute Protocol (protocole d'attribut). (ATT). À l'aide de l'ATT, un appareil central interagit avec ce que l'on appelle des attributs sur un appareil périphérique en suivant un profil Bluetooth spécial appelé profil d'attribut générique (GATT). GATT définit les concepts généraux suivants:

Service: un service GATT représente un ensemble de données et les comportements associés pour effectuer une fonction particulière d'un appareil. Par exemple, un moniteur de fréquence cardiaque aura généralement au moins un "Service de fréquence cardiaque". Les informations sur un service GATT sont contenues dans un bluetoothLowEnergy.Service.
Caractéristique: une caractéristique GATT est un élément de données de base utilisé pour construire un service GATT. contenant une valeur ainsi que des propriétés qui définissent son mode d'accès. Par exemple : le service de fréquence cardiaque contient la « Mesure de la fréquence cardiaque » qui permet d'obtenir la valeur de la fréquence cardiaque de l'utilisateur. Les informations concernant une caractéristique GATT sont contenues dans un bluetoothLowEnergy.Characteristic.
Descripteur: un descripteur de caractéristique GATT contient des informations supplémentaires sur une caractéristique. Les informations concernant un descripteur de caractéristique GATT sont contenues dans un un objet bluetoothLowEnergy.Descriptor.

L'API Bluetooth à basse consommation permet aux applications de rechercher des informations sur les des services, des caractéristiques et des descripteurs en appelant bluetoothLowEnergy.getServices bluetoothLowEnergy.getCharacteristics et bluetoothLowEnergy.getDescriptors. Les applications peuvent filtrer les services, les caractéristiques et les descripteurs en comparant leur champ uuid au UUID GATT souhaité:

chrome.bluetoothLowEnergy.getServices(deviceAddress, function(services) {
  ...
  for (var i = 0; i < services.length; i++) {
    if (services[i].uuid == HEART_RATE_SERVICE_UUID) {
      heartRateService = services[i];
      break;
    }
  }
  ...
});

Chaque service, caractéristique et descripteur accessible via l'API se voit attribuer un l'identifiant d'instance, que vous pouvez obtenir à l'aide du champ instanceId. Cet ID d'instance peut être permettant d'identifier un objet GATT et d'y effectuer des opérations spécifiques:

chrome.bluetoothLowEnergy.getCharacteristics(heartRateService.instanceId,
                                             function(chracteristics) {
  ...
  for (var i = 0; i < characteristics.length; i++) {
    if (characteristics[i].uuid == HEART_RATE_MEASUREMENT_UUID) {
      measurementChar = characteristics[i];
      break;
    }
  }
  ...
  chrome.bluetoothLowEnergy.getDescriptors(measurementChar.instanceId,
                                           function(descriptors) {
    ...
  });
});

Événements de service

Une fois un appareil connecté, Chrome détecte ses services. Au fur et à mesure que chaque service est découvert et l'application reçoit le signal bluetoothLowEnergy.onServiceAdded et Événements bluetoothLowEnergy.onServiceRemoved:

  var initializeService = function(service) {
    if (!service) {
      console.log('No service selected!');
      // Reset UI, etc.
      ...
      return;
    }

    myService = service;

    // Get all the characteristics and descriptors and bootstrap the app.
    ...
  };

  chrome.bluetoothLowEnergy.onServiceAdded.addListener(function(service) {
    if (service.uuid == MY_SERVICE_UUID)
      initializeService(service);
  });

  chrome.bluetoothLowEnergy.onServiceRemoved.addListener(function(service) {
    if (service.instanceId == myService.instanceId)
      initializeService(null);
  });

Chrome détecte toutes les caractéristiques et tous les descripteurs d'un service de manière asynchrone, puis envoie le bluetoothLowEnergy.onServiceAdded une fois la découverte terminée. Si la connexion à un périphérique s'arrête, Chrome supprime tous les services associés et envoie le bluetoothLowEnergy.onServiceRemoved.

Certains périphériques peuvent modifier leurs services, par exemple les caractéristiques d'un service peuvent changer ou services peuvent être ajoutés et supprimés complètement. Chrome informe les applications de ces modifications à l'aide de l' bluetoothLowEnergy.onServiceChanged, bluetoothLowEnergy.onServiceAdded et bluetoothLowEnergy.onServiceRemoved.

  chrome.bluetoothLowEnergy.onServiceChanged.addListener(function(service) {
    if (service.instanceId != myService.instanceId)
      return;

    updateMyService(service);
  });

Lire et écrire la valeur d'une caractéristique

Une caractéristique GATT encode un aspect de son service. Une application centrale lit, agit et modifie l'état du service d'un périphérique en opérant sur la valeur d'une caractéristique. La caractéristique valeur est une séquence d'octets et sa signification est définie par la spécification de haut niveau qui définit une certaine caractéristique. Par exemple, la valeur de la caractéristique Mesure de la fréquence cardiaque encode la fréquence cardiaque de l'utilisateur et la quantité totale de calories brûlées, tandis que le capteur Body Sensor Le lieu encode l'endroit où le capteur de fréquence cardiaque doit être porté dans le corps.

Chrome fournit la méthode bluetoothLowEnergy.readCharacteristicValue pour lire la valeur d'une caractéristique:

chrome.bluetoothLowEnergy.readCharacteristicValue(chrc.instanceId,
                                                  function(result) {
  if (chrome.runtime.lastError) {
    console.log('Failed to read value: ' + chrome.runtime.lastError.message);
    return;
  }

  var bytes = new Uint8Array(result.value);

  // Do stuff with the bytes.
  ...
});

Certaines caractéristiques sont accessibles en écriture, en particulier celles qui se comportent comme des "points de contrôle", où l'écriture la valeur a des effets secondaires. Par exemple, la caractéristique Point de contrôle de la fréquence cardiaque est utilisée pour demande à un capteur de fréquence cardiaque de réinitialiser le nombre total de calories brûlées et ne prend en charge que les écritures. À Pour ce faire, Chrome fournit la méthode bluetoothLowEnergy.writeCharacteristicValue:

var myBytes = new Uint8Array([ ... ]);
chrome.bluetoothLowEnergy.writeCharacteristicValue(chrc.instanceId,
                                                   myBytes.buffer,
                                                   function() {
  if (chrome.runtime.lastError) {
    console.log('Failed to write value: ' +
                chrome.runtime.lastError.message);
    return;
  }

  // Value is written now.
});

Les descripteurs de caractéristique se comportent de la même manière et peuvent être lisibles et/ou accessibles en écriture. Avantages de Chrome bluetoothLowEnergy.readDescriptorValue et bluetoothLowEnergy.writeDescriptorValue pour lire et écrire la valeur d'un descripteur.

Pour vérifier si une caractéristique est compatible avec les lectures ou les écritures, une application peut vérifier le properties d'un objet bluetoothLowEnergy.Characteristic. Ce champ ne contient pas des informations sur les exigences de sécurité pour accéder à une valeur, elle indique quelle valeur fonctionnement général pris en charge par la caractéristique.

Gérer les notifications de valeur

Certaines caractéristiques font connaître leur valeur à l'aide de notifications ou d'indications. Par exemple, La caractéristique Mesure de la fréquence cardiaque n'est ni lisible, ni accessible en écriture, mais elle envoie des mises à jour sur sa la valeur actuelle à intervalles réguliers. Les applications peuvent écouter ces notifications à l'aide des bluetoothLowEnergy.onCharacteristicValueChanged.

  chrome.bluetoothLowEnergy.onCharacteristicValueChanged.addListener(
      function(chrc) {
    if (chrc.instanceId != myCharId)
      return;

    var bytes = new Uint8Array(chrc.value);

    // Do stuff with the bytes.
    ...
  });

Même si une caractéristique prend en charge les notifications/indications, celles-ci ne sont pas activées par défaut. Une application doit appeler le service bluetoothLowEnergy.startCharacteristicNotifications et bluetoothLowEnergy.stopCharacteristicNotifications pour démarrer ou arrêter la réception des l'événement bluetoothLowEnergy.onCharacteristicValueChanged.

  // Start receiving characteristic value notifications.
  var notifying = false;
  chrome.bluetoothLowEnergy.startCharacteristicNotifications(chrc.instanceId,
                                                             function() {
    if (chrome.runtime.lastError) {
      console.log('Failed to enable notifications: ' +
                  chrome.runtime.lastError.message);
      return;
    }

    notifying = true;
  });

  ...

  // No longer interested in notifications from this characteristic.
  if (notifying) {
    chrome.bluetoothLowEnergy.stopCharacteristicNotifications(
        chrc.instanceId);
  }

Une fois les notifications lancées, l'application reçoit les bluetoothLowEnergy.onCharacteristicValueChanged chaque fois qu'une notification ou une indication est de la caractéristique. Si la caractéristique est compatible avec les lectures, cet événement sera également envoyé après un appel réussi à bluetoothLowEnergy.readCharacteristicValue. Cela permet aux applications pour unifier le flux de contrôle d'une mise à jour de valeur déclenchée par une requête de lecture et des notifications:

  chrome.bluetoothLowEnergy.onCharacteristicValueChanged.addListener(
      function(chrc) {
    // Process the value.
    ...
  });

  chrome.bluetoothLowEnergy.startCharacteristicNotifications(chrc.instanceId,
                                                             function() {
    // Notifications started. Read the initial value.
    chrome.bluetoothLowEnergy.readCharacteristicValue(chrc.instanceId,
                                                      function(result) {
      ...
      // No need to do anything here since onCharacteristicValueChanged
      // will handle it.
    });
  });

Si une caractéristique accepte les notifications, son champ properties contient soit le "notify" ou "indicate".

REMARQUE: Si une caractéristique prend en charge les notifications/indications, elle aura le statut « Client Configuration des caractéristiques" pour activer/désactiver les notifications. Chrome n'autorise pas applications pour écrire dans ce descripteur. Les applications doivent plutôt utiliser la méthode bluetoothLowEnergy.startCharacteristicNotifications et bluetoothLowEnergy.stopCharacteristicNotifications pour contrôler le comportement des notifications.