Bluetooth

Wichtig:Chrome wird die Unterstützung für Chrome-Apps auf allen Plattformen einstellen. Der Chrome-Browser und der Chrome Web Store unterstützen weiterhin Erweiterungen. Lesen Sie die Ankündigung und erfahren Sie mehr über die Migration Ihrer Anwendung.

In diesem Dokument wird beschrieben, wie die Bluetooth, Bluetooth Socket und Bluetooth Low Energy APIs für die Kommunikation mit Bluetooth- und Bluetooth Low Energy-Geräten verwendet werden.

Hintergrundinformationen zu Bluetooth finden Sie in den offiziellen Bluetooth-Spezifikationen.

Hinweis:Mit Chrome 56 können Nutzer Bluetooth Low Energy-Geräte in der Nähe auswählen und für Websites bereitstellen, die die Web Bluetooth API verwenden.

Anforderungen an Manifeste

Fügen Sie bei Chrome-Apps, die Bluetooth verwenden, dem Manifest den Bluetooth-Eintrag hinzu und geben Sie gegebenenfalls die UUIDs der Profile, Protokolle oder Dienste an, die Sie implementieren möchten. Außerdem geben Sie an, ob Sie diese mit der Socket API und/oder Low Energy API implementieren möchten.

Beispiel für eine Socket-Implementierung:

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

Und für eine Low Energy-Implementierung:

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

Wenn Sie nur auf den Adapterstatus zugreifen, Geräte in der Nähe finden und grundlegende Informationen zu Geräten abrufen möchten, ist nur der Eintrag selbst erforderlich:

"bluetooth": {}

Informationen zum Adapter

Adapterstatus abrufen

Verwenden Sie die Methode bluetooth.getAdapterState, um den Status des Bluetooth-Adapters abzurufen:

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

Adapterbenachrichtigungen

Das Ereignis bluetooth.onAdapterStateChanged wird immer dann gesendet, wenn sich der Adapterstatus ändert. Damit lässt sich beispielsweise feststellen, wann die Adapterfunkschnittstelle ein- oder ausgeschaltet wird.

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");
      }
    }
  });

Geräteinformationen

Bekannte Geräte auflisten

Mit der Methode bluetooth.getDevices können Sie eine Liste der Geräte abrufen, die dem Bluetooth-Adapter bekannt sind:

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

Alle Geräte werden zurückgegeben, einschließlich gekoppelter Geräte und Geräte, die kürzlich gefunden wurden. Neue Geräte werden jedoch nicht erkannt (siehe Geräte in der Nähe erkennen).

Erhalten von Gerätebenachrichtigungen

Anstatt bluetooth.getDevices wiederholt aufzurufen, können Sie die Ereignisse bluetooth.onDeviceAdded, bluetooth.onDeviceChanged und bluetooth.onDeviceRemoved verwenden, um Benachrichtigungen zu erhalten.

Das Ereignis bluetooth.onDeviceAdded wird gesendet, wenn der Adapter ein Gerät erkennt oder eine Verbindung zum Adapter herstellt:

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

Durch das Hinzufügen eines Listeners für dieses Ereignis werden Geräte nicht erkannt (siehe Geräte in der Nähe erkennen).

Änderungen an Geräten, einschließlich zuvor erkannter Geräte, die gekoppelt werden, werden durch das Ereignis bluetooth.onDeviceChanged benachrichtigt:

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

Das Ereignis bluetooth.onDeviceRemoved wird immer dann gesendet, wenn ein gekoppeltes Gerät aus dem System entfernt wird oder ein erkanntes Gerät in letzter Zeit nicht erkannt wurde:

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

Geräte in der Nähe werden erkannt

Verwenden Sie die Methode bluetooth.startDiscovery, um Geräte in der Nähe zu erkennen. Die Erkennung kann ressourcenintensiv sein. Rufen Sie danach bluetooth.stopDiscovery auf.

Rufen Sie bluetooth.startDiscovery auf, wenn Ihre App Geräte in der Nähe finden muss. Legen Sie für den Aufruf keine Bedingung für die discovering-Eigenschaft von bluetooth.AdapterState fest. Der Aufruf ist auch dann erfolgreich, wenn eine andere App Geräte in der Nähe erkennt. So wird sichergestellt, dass der Adapter die Erkennung weiterhin durchführt, nachdem die andere App beendet wurde.

Informationen zu jedem neu entdeckten Gerät werden über das Ereignis bluetooth.onDeviceAdded gesendet. Bei Geräten, die bereits vor Kurzem gefunden wurden oder die zuvor gekoppelt oder verbunden wurden, wird das Ereignis nicht gesendet. Stattdessen sollten Sie bluetooth.getDevices aufrufen, um die aktuellen Informationen zu erhalten, und das Ereignis bluetooth.onDeviceChanged verwenden, um über Änderungen an diesen Informationen informiert zu werden, die sich aus der Erkennung ergeben.

Beispiel:

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);
});

Wenn der Nutzer die Bluetooth-Funkverbindung deaktiviert, werden alle Erkennungssitzungen beendet und nicht automatisch fortgesetzt, wenn die Funkverbindung wieder eingeschaltet wird. Wenn das für Ihre App wichtig ist, sollten Sie sich das Ereignis bluetooth.onAdapterStateChanged ansehen. Wenn sich das Attribut discovering zu false ändert, muss deine App bluetooth.startDiscovery noch einmal aufrufen, um fortzufahren. Seien Sie vorsichtig, wenn die Erkennung ressourcenintensiv ist.

Geräte identifizieren

Es gibt eine Reihe von verschiedenen Optionen zum Identifizieren von Geräten, die von bluetooth.getDevices zurückgegeben werden, und der zugehörigen Ereignisse.

Wenn das Gerät die Bluetooth-Geräte-ID-Spezifikation unterstützt, werden dem Geräteobjekt mehrere Eigenschaften hinzugefügt, die die durch diese Spezifikation definierten Felder enthalten. Beispiel:

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));
    }
  }
});

Die Geräte-ID-Spezifikation reicht in der Regel aus, um ein bestimmtes Modell und sogar eine Version eines Geräts von einem Anbieter zu identifizieren. Ist dies nicht der Fall, musst du dich stattdessen auf Informationen zur Klasse oder zum Typ des Geräts verlassen, die optional mit dem Herstellerpräfix in der address kombiniert werden können.

Die meisten Bluetooth-Geräte stellen Informationen zur Geräteklasse als Bitfeld bereit, das gemäß dem Dokument Baseband Assigned Numbers interpretiert wird. Dieses Bitfeld ist im Attribut deviceClass verfügbar.

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));
    }
  }
});

Das Parsen des Felds kann komplex sein. Daher übernimmt Chrome dies bei den gängigsten Gerätetypen und legt das Feld type fest. Wenn dies nicht verfügbar oder für Ihre Anforderungen nicht ausreicht, müssen Sie das deviceClass selbst parsen.

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);
    }
  }
});

RFCOMM und L2CAP verwenden

Chrome-Apps können Verbindungen zu jedem Gerät herstellen, das RFCOMM- oder L2CAP-Dienste unterstützt. Dazu gehören die meisten klassischen Bluetooth-Geräte auf dem Markt.

Mit einer Steckdose verbinden

Zum Herstellen einer Verbindung mit einem Gerät benötigen Sie drei Dinge. Einen mit bluetoothSocket.create erstellten Socket, zu dem die Verbindung hergestellt werden soll, die Adresse des Geräts, zu dem Sie eine Verbindung herstellen möchten, und die UUID des Dienstes selbst

Bevor Sie die Verbindung herstellen, sollten Sie mithilfe von bluetooth.getDevice oder der Device Discovery APIs prüfen, ob der Adapter das Gerät erkennt.

Die zum Herstellen der zugrunde liegenden Verbindung erforderlichen Informationen, z. B. ob das RFCOMM- oder L2CAP-Protokoll verwendet werden soll, und welcher Kanal oder PSM, werden mit der SDP-Erkennung auf dem Gerät abgerufen.

Beispiel:

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);
});

Behalten Sie ein Handle für die SocketId, damit Sie später Daten (bluetoothSocket.send) an diesen Socket senden können.

Empfang von und Senden an Socket

Der Empfang von Daten und das Senden an einen Socket verwenden ArrayBuffer-Objekte. Weitere Informationen zu ArrayBuffers finden Sie in der Übersicht zu Arrays vom Typ JavaScript und in der Anleitung ArrayBuffer in und aus String konvertieren.

Verwende zum Senden von Daten in arrayBuffer 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")
  }
})

Im Gegensatz zur Methode zum Senden von Daten werden Daten in einem Ereignis (bluetoothSocket.onReceive) empfangen. Sockets werden ohne Pause erstellt (siehe bluetoothSocket.setPaused), sodass der Listener für dieses Ereignis in der Regel zwischen bluetoothSocket.create und bluetoothSocket.connect hinzugefügt wird.

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

Socket-Fehler empfangen und Verbindung getrennt

Fügen Sie dem Ereignis bluetoothSocket.onReceiveError einen Listener hinzu, um über Socket-Fehler, einschließlich Trennungen, informiert zu werden.

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

Verbindung zu Socket trennen

Um die Verbindung herzustellen und die Steckdose zu trennen, verwenden Sie bluetoothSocket.disconnect.

chrome.bluetoothSocket.disconnect(socketId);

Verlagsdienste

Neben ausgehenden Verbindungen zu Geräten können Chrome-Apps auch Dienste veröffentlichen, die von jedem Gerät verwendet werden können, das RFCOMM oder L2CAP unterstützt.

Über eine Steckdose hören

Es werden zwei Arten von veröffentlichten Diensten unterstützt. RFCOMM ist das am häufigsten verwendete Gerät und deckt den Großteil der Geräte und Profile ab:

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

L2CAP ist das andere und deckt andere Gerätetypen und anbieterspezifische Anwendungsfälle wie das Hochladen von Firmware ab.

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

In beiden Fällen kann ein optionales bluetoothSocket.ListenOptions übergeben werden, um einen bestimmten Kanal oder PSM zuzuweisen. Der Callback zeigt einen Fehler über chrome.runtime.lastError an, ansonsten über den Erfolg. Behalten Sie ein Handle der SocketId, damit Sie später Verbindungen (bluetoothSocket.onAccept) von diesem Socket annehmen können.

Clientverbindungen akzeptieren

Clientverbindungen werden akzeptiert und über das Ereignis bluetoothSocket.onAccept an Ihre Anwendung übergeben.

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);
});

Keine Clientverbindungen mehr annehmen

Verwenden Sie bluetoothSocket.disconnect, um keine Clientverbindungen mehr anzunehmen und die Veröffentlichung des Dienstes aufzuheben.

chrome.bluetoothSocket.disconnect(serverSocketId);

Umgang mit Geräten mit geringem Stromverbrauch

Bluetooth Low Energy oder (Bluetooth Smart) ist eine Funktechnologie, die auf einen geringeren Energieverbrauch ausgerichtet ist. Mit der Bluetooth Low Energy API können Anwendungen die zentrale Rolle in einer LE-Verbindung zu einem Peripheriegerät implementieren. In den folgenden Abschnitten wird beschrieben, wie Sie Bluetooth Low Energy-Peripheriegeräte erkennen, eine Verbindung zu ihnen herstellen und mit ihnen interagieren.

Peripheriegeräte finden und verbinden

Wie bei herkömmlichen Bluetooth-Geräten können LE-Peripheriegeräte mit den unter Geräte in der Nähe erkennen beschriebenen Methoden erkannt werden . Ein LE-Gerät macht sich selbst sichtbar, indem es Datenpakete mit der Bezeichnung „Werbedaten“ sendet und das Gerät sich im Werbemodus befindet. Die Werbedaten können UUIDs von Diensten enthalten, die auf dem Gerät verfügbar sind. Sofern vorhanden, kann auf diese UUIDs über das Attribut uuids des entsprechenden bluetooth.Device-Objekts zugegriffen werden.

Nach der Erkennung kann durch Aufrufen von bluetoothLowEnergy.connect eine Verbindung zu einem LE-Gerät hergestellt werden, sodass die Anwendung mit ihren Diensten interagieren kann:

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...
    ...
  });
});

Sobald die Verbindung hergestellt ist, hat das Attribut connected des entsprechenden Objekts bluetooth.Device den Wert true. Durch den Aufruf von bluetoothLowEnergy.connect wird von der App ein Anspruch auf die physische Verbindung mit dem Gerät erstellt. Eine physische Verbindung zum Gerät kann bestehen, ohne dass bluetoothLowEnergy.connect jemals aufgerufen wird – etwa aufgrund einer anderen Anwendung. In diesem Fall kann Ihre Anwendung zwar weiterhin mit den Diensten des Geräts interagieren, sollte aber immer bluetoothLowEnergy.connect aufrufen, um zu verhindern, dass eine andere Anwendung die physische Verbindung trennt.

Sobald Ihre Anwendung nicht mehr verbunden sein muss, kann sie ihren Anspruch auf die Verbindung durch Aufrufen von bluetoothLowEnergy.disconnect entfernen:

chrome.bluetoothLowEnergy.disconnect(deviceAddress);

Beachten Sie, dass dadurch nicht unbedingt die physische Verbindung zum Gerät zerstört wird, da es möglicherweise andere Anwendungen mit aktiver Verbindung zum Gerät gibt. Manchmal wird das Gerät aus Gründen getrennt, die außerhalb der Kontrolle der Anwendung liegen, z.B. wenn das Gerät verschwindet oder vom Nutzer explizit über Dienstprogramme des Betriebssystems getrennt wird. Ihre App sollte das Ereignis bluetooth.onDeviceChanged beobachten, um über Änderungen an der Verbindung informiert zu werden und die Verbindung bei Bedarf wiederherzustellen.

Sobald die Verbindung hergestellt ist, hat das Gerät, auf dem Chrome ausgeführt wird, die sogenannte zentrale Rolle und das Remotegerät die Peripherierolle. An dieser Stelle kann Ihre Anwendung mithilfe der im folgenden Abschnitt beschriebenen Methoden mit den Diensten auf dem Gerät interagieren. Hinweis:Die APIs unterstützen derzeit nicht die Nutzung als LE-Peripheriegerät. In Anwendungen können nur die zentrale Rolle implementiert werden.

Dienstleistungen, Merkmale und Beschreibungen

Bluetooth Low Energy basiert auf einem einfachen Anfrage-Antwort-Protokoll namens Attribute Protocol (ATT). Bei Verwendung von ATT interagiert ein zentrales Gerät mit den sogenannten Attributen auf einem Peripheriegerät, indem es einem speziellen Bluetooth-Profil namens Generic Attribute Profile (GATT) entspricht. GATT definiert die folgenden übergeordneten Konzepte:

• Dienst: Ein GATT-Dienst steht für eine Sammlung von Daten und zugehörigen Verhaltensweisen, um eine bestimmte Funktion eines Geräts auszuführen. Ein Herzfrequenzmesser hat in der Regel mindestens einen „Herzfrequenzdienst“. Informationen zu einem GATT-Dienst sind in einem Objekt bluetoothLowEnergy.Service enthalten.
• Merkmal: Ein GATT-Merkmal ist ein grundlegendes Datenelement, das zum Erstellen eines GATT-Dienstes verwendet wird. Es enthält einen Wert und Attribute, die festlegen, wie auf diesen Wert zugegriffen werden kann. Der „Herzfrequenzdienst“ hat beispielsweise die Eigenschaft „Herzfrequenzmessung“, mit der der Wert der Herzfrequenz des Nutzers ermittelt wird. Informationen zu einer GATT-Eigenschaft befinden sich in einem Objekt bluetoothLowEnergy.Characteristic.
• Beschreibung: Eine Beschreibung des GATT-Merkmals enthält weitere Informationen zu einem Merkmal. Informationen zu einem GATT-Merkmalsdeskriptor finden Sie im Objekt bluetoothLowEnergy.Descriptor.

Mit der Bluetooth Low Energy API können Anwendungen Informationen zu den Diensten, Merkmalen und Deskriptoren eines Geräts abrufen. Dazu werden bluetoothLowEnergy.getServices, bluetoothLowEnergy.getCharacteristics und bluetoothLowEnergy.getDescriptors aufgerufen werden. Anwendungen können nach Diensten, Merkmalen und Deskriptoren filtern, indem sie das Feld uuid mit der gewünschten GATT-UUID vergleichen:

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;
    }
  }
  ...
});

Jedem Dienst, jeder Eigenschaft und jedem Deskriptor, auf die über die API zugegriffen werden kann, wird eine eindeutige Instanzkennung zugewiesen, die über das Feld instanceId abgerufen werden kann. Mit dieser Instanz-ID kann ein GATT-Objekt identifiziert und bestimmte Vorgänge dafür ausgeführt werden:

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) {
    ...
  });
});

Dienstereignisse

Sobald ein Gerät verbunden ist, erkennt Chrome die zugehörigen Dienste. Sobald jeder Dienst erkannt und entfernt wird, empfängt die Anwendung die Ereignisse bluetoothLowEnergy.onServiceAdded und 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 erkennt alle Eigenschaften und Deskriptoren eines Dienstes asynchron und sendet das Ereignis bluetoothLowEnergy.onServiceAdded, sobald die Erkennung abgeschlossen ist. Wenn die Verbindung zu einem Peripheriegerät beendet wird, entfernt Chrome alle zugehörigen Dienste und sendet das Ereignis bluetoothLowEnergy.onServiceRemoved.

Einige Peripheriegeräte können ihre Dienste ändern. So können sich z. B. die Eigenschaften eines Dienstes ändern oder Dienste können vollständig hinzugefügt und entfernt werden. Chrome benachrichtigt Apps über diese Änderungen mithilfe der Ereignisse bluetoothLowEnergy.onServiceChanged, bluetoothLowEnergy.onServiceAdded und bluetoothLowEnergy.onServiceRemoved.

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

    updateMyService(service);
  });

Den Wert eines Merkmals lesen und schreiben

Ein GATT-Merkmal codiert einen Aspekt des Dienstes. Eine zentrale Anwendung liest, bearbeitet und ändert den Dienststatus eines Peripheriegeräts, indem sie auf den Wert eines Merkmals eingeht. Der charakteristische Wert ist eine Folge von Byte und seine Bedeutung wird durch die allgemeine Spezifikation definiert, die ein bestimmtes Merkmal definiert. Beispielsweise codiert der Wert der Eigenschaft Herzfrequenzmessung die Herzfrequenz des Nutzers und die Gesamtzahl der verbrannten Kalorien, während die Eigenschaft Körpersensorposition codiert, wo im Körper der Herzfrequenzsensor getragen werden soll.

Chrome bietet die Methode bluetoothLowEnergy.readCharacteristicValue, um den Wert einer Eigenschaft zu lesen:

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.
  ...
});

Einige Eigenschaften sind beschreibbar, insbesondere solche, die sich als „Kontrollpunkte“ verhalten, bei denen das Schreiben des Werts Nebenwirkungen hat. Zum Beispiel wird die Eigenschaft Herzfrequenz-Kontrollpunkt verwendet, um einen Herzfrequenzsensor anzuweisen, die Anzahl der insgesamt verbrannten Kalorien zurückzusetzen, und unterstützt nur Schreibvorgänge. Dazu bietet Chrome die Methode 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.
});

Merkmalsdeskriptoren verhalten sich gleich und können lesbar und/oder beschreibbar sein. Chrome bietet die Methoden bluetoothLowEnergy.readDescriptorValue und bluetoothLowEnergy.writeDescriptorValue zum Lesen und Schreiben des Deskriptorwerts.

Eine Anwendung kann das Feld properties eines Objekts bluetoothLowEnergy.Characteristic prüfen, um zu prüfen, ob ein Merkmal Lese- oder Schreibvorgänge unterstützt. Dieses Feld enthält zwar keine Informationen zu den Sicherheitsanforderungen für den Zugriff auf einen Wert, beschreibt jedoch, welchen Wertvorgang das Merkmal im Allgemeinen unterstützt.

Umgang mit Wertbenachrichtigungen

Einige Merkmale machen ihren Wert durch Benachrichtigungen oder Hinweise bekannt. Beispielsweise ist das Merkmal Herzfrequenzmessung weder lesbar noch beschreibbar, es sendet jedoch regelmäßig Aktualisierungen des aktuellen Werts. Apps können diese Benachrichtigungen mithilfe des Ereignisses bluetoothLowEnergy.onCharacteristicValueChanged abhören.

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

    var bytes = new Uint8Array(chrc.value);

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

Selbst wenn eine Eigenschaft Benachrichtigungen unterstützt, sind diese nicht standardmäßig aktiviert. Eine Anwendung sollte die Methoden bluetoothLowEnergy.startCharacteristicNotifications und bluetoothLowEnergy.stopCharacteristicNotifications aufrufen, um den Empfang des Ereignisses bluetoothLowEnergy.onCharacteristicValueChanged zu starten oder zu beenden.

  // 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);
  }

Sobald Benachrichtigungen gestartet wurden, empfängt die App den bluetoothLowEnergy.onCharacteristicValueChanged jedes Mal, wenn eine Benachrichtigung oder ein Hinweis von der Eigenschaft eingeht. Wenn die Eigenschaft Lesevorgänge unterstützt, wird dieses Ereignis auch nach einem erfolgreichen Aufruf von bluetoothLowEnergy.readCharacteristicValue gesendet. Dadurch können Apps den Steuerungsablauf einer Wertaktualisierung, die durch eine Leseanfrage und Benachrichtigungen ausgelöst wird, vereinheitlichen:

  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.
    });
  });

Wenn ein Merkmal Benachrichtigungen unterstützt, enthält das Feld properties entweder das Attribut "notify" oder "indicate".

HINWEIS: Wenn ein Merkmal Benachrichtigungen/Meldungen unterstützt, verfügt es über die Deskriptor „Client-Characteristic Configuration“, um Benachrichtigungen zu aktivieren bzw. zu deaktivieren. Chrome erlaubt Apps nicht, in diesen Deskriptor zu schreiben. Apps sollten stattdessen die Methoden bluetoothLowEnergy.startCharacteristicNotifications und bluetoothLowEnergy.stopCharacteristicNotifications verwenden, um das Benachrichtigungsverhalten zu steuern.