Diese Seite ist Teil der Dokumentation für die Chrome Apps-Plattform, die 2020 eingestellt wurde. Für Enterprise- und Education-Kunden wird sie mindestens bis Januar 2025 auf ChromeOS-Geräten unterstützt. Weitere Informationen zum Migrieren von Apps

Diese Seite wurde von der Cloud Translation API übersetzt.

für Bluetooth

In diesem Dokument wird die Verwendung von Bluetooth, Bluetooth Socket und Bluetooth Low Energy APIs für die Kommunikation mit Bluetooth- und Bluetooth Low Energy-Geräten

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

Manifestanforderungen

Fügen Sie für Chrome-Apps mit Bluetooth den Eintrag bluetooth in das Manifest hinzu und geben Sie an, ob die UUIDs der Profile, Protokolle oder Dienste, die Sie implementieren möchten, sowie Sie diese mit der Socket API und/oder der Low Energy API implementieren möchten.

Zum Beispiel für eine Socket-Implementierung:

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

Und für eine energiesparende 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 über Geräte abrufen möchten, nur der Eintrag selbst ist erforderlich:

"bluetooth": {}

Informationen zum Adapter

Adapterstatus wird abgerufen

Rufen Sie den Status des Bluetooth-Adapters mit der Methode bluetooth.getAdapterState ab:

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

Adapterbenachrichtigungen

Das Ereignis bluetooth.onAdapterStateChanged wird gesendet, wenn sich der Adapterstatus ändert. Dies kann kann beispielsweise verwendet werden, um festzustellen, wann das Netzteil 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

Eine Liste der Geräte, die dem Bluetooth-Adapter bekannt sind, erhältst du über bluetooth.getDevices :

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 kürzlich entdeckter Geräte. Es wird nicht mit der Erkennung neuer Geräte beginnen (siehe Geräte in der Nähe finden).

Erhalt von Gerätebenachrichtigungen

Anstatt wiederholt bluetooth.getDevices aufzurufen, kannst du die bluetooth.onDeviceAdded, bluetooth.onDeviceChanged und bluetooth.onDeviceRemoved um Benachrichtigungen zu erhalten.

Das Ereignis bluetooth.onDeviceAdded wird gesendet, wenn ein Gerät vom Adapter oder von stellt eine Verbindung zum Adapter her:

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

Durch das Hinzufügen eines Listeners für dieses Ereignis werden noch keine Geräte erkannt (siehe In der Nähe werden ermittelt) Geräte).

Änderungen an Geräten, einschließlich zuvor gefundener Geräte, die gekoppelt werden, werden vom Ereignis bluetooth.onDeviceChanged:

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

Schließlich wird das Ereignis bluetooth.onDeviceRemoved gesendet, wenn ein gekoppeltes Gerät aus oder ein erkanntes Gerät wurde in letzter Zeit nicht erkannt:

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

Geräte in der Nähe werden ermittelt

Verwenden Sie die Methode bluetooth.startDiscovery, um Geräte in der Nähe zu finden. Discovery-Anzeigen rufen Sie anschließend bluetooth.stopDiscovery auf.

Du solltest bluetooth.startDiscovery aufrufen, wenn deine App Geräte in der Nähe finden muss. Setze den Aufruf nicht an das Attribut discovering von bluetooth.AdapterState. Die ist auch dann erfolgreich, wenn eine andere App Geräte in der Nähe erkennt. Außerdem wird sichergestellt, dass der Adapter und führt die Erkennung auch nach dem Beenden der anderen App weiter.

Informationen zu jedem neu gefundenen Gerät werden über die Methode bluetooth.onDeviceAdded empfangen . Bei Geräten, die vor Kurzem erkannt wurden oder zuvor mit oder verbunden sind, wird das Ereignis nicht gesendet. Rufe stattdessen bluetooth.getDevices auf: die aktuellen Informationen abrufen und über das Ereignis bluetooth.onDeviceChanged benachrichtigt werden diese Informationen infolge der Feststellung geändert werden.

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-Funkschnittstelle deaktiviert, werden alle Erkennungssitzungen beendet und nicht fortgesetzt automatisch, wenn das Radio eingeschaltet wird. Wenn dies für Ihre App relevant ist, sollten Sie sich bluetooth.onAdapterStateChanged. Wenn sich das Attribut discovering in false ändert, dann gilt: muss deine App bluetooth.startDiscovery noch einmal aufrufen, um fortzufahren. Achten Sie darauf, ressourcenintensiven Charakter der Erkennung.

Geräte identifizieren

Es gibt eine Reihe verschiedener Optionen, mit denen die von einem Nutzer zurückgegebenen Geräte identifiziert werden können. bluetooth.getDevices und die zugehörigen Ereignisse

Wenn das Gerät die Geräte-ID-Spezifikation von Bluetooth unterstützt, werden mehrere Eigenschaften hinzugefügt. Das Device-Objekt, das die durch diese Spezifikation definierten Felder enthält. 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 zu identifizieren, eines Anbieters. Ist dies nicht der Fall, müssen Sie sich stattdessen auf Informationen über Klasse oder Typ des Geräts, optional kombiniert mit dem Herstellerpräfix im address.

Die meisten Bluetooth-Geräte stellen Informationen zur Geräteklasse als Bitfeld bereit, Baseband Assigned Numbers (in englischer Sprache) Dieses Bitfeld ist in deviceClass verfügbar Property.

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, sodass Chrome dies bei den gängigsten Gerätetypen für Sie und legt das Feld type fest. Ist dies nicht möglich oder für Ihre Anforderungen nicht ausreichend, müssen Sie Sie können die 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 der meisten klassischen Bluetooth-Geräte auf dem Markt.

Verbindung zu einer Steckdose herstellen

Um eine Verbindung mit einem Gerät herzustellen, sind drei Dinge erforderlich. Ein Socket zum Herstellen der Verbindung mit, erstellt mit bluetoothSocket.create. die Adresse des Geräts, mit dem Sie eine Verbindung herstellen möchten, und die UUID des Dienstes selbst.

Bevor Sie die Verbindung herstellen, sollten Sie überprüfen, ob das Netzteil das Gerät erkennt. Hierzu verwenden Sie bluetooth.getDevice oder den APIs für die Geräteerkennung nutzen.

Die Informationen, die zum Aufbau der zugrunde liegenden Verbindung erforderlich sind, einschließlich der Angabe, ob das RFCOMM- oder das L2CAP-Protokoll verwendet werden sollte und welcher Kanal oder PSM über die SDP-Erkennung auf der .

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 bei, damit Sie später Daten (bluetoothSocket.send) an dieses senden können Socket haben.

Von einem Socket empfangen und an diesen senden

Für den Empfang von Daten von einem Socket und das Senden an einen Socket werden ArrayBuffer-Objekte verwendet. Um mehr über ArrayBuffers zu erfahren, erhalten Sie in der Übersicht, zu JavaScript-typisierten Arrays und zum Tutorial So konvertieren Sie ArrayBuffer zu und vom String.

Zum Senden von Daten in arrayBuffer verwende 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 die Daten bei einem Ereignis (bluetoothSocket.onReceive. Sockets werden ohne Pausierung erstellt (siehe bluetoothSocket.setPaused). Daher wird der Listener für dieses Ereignis normalerweise zwischen bluetoothSocket.create und bluetoothSocket.connect eine Verbindung herstellen.

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

Socket-Fehler werden empfangen und Verbindung getrennt

Fügen Sie für Socket-Fehler einschließlich Trennungen einen Listener zum bluetoothSocket.onReceiveError.

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

Von einer Steckdose trennen

Verwenden Sie bluetoothSocket.disconnect, um die Verbindung zu beenden und den Socket zu trennen.

chrome.bluetoothSocket.disconnect(socketId);

Verlagsdienstleistungen

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

Auf eine Steckdose warten

Es werden zwei Typen veröffentlichter Dienste unterstützt. RFCOMM ist die am häufigsten verwendete Methode und deckt den den meisten Geräten und Profilen:

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

L2CAP ist das andere. Es deckt andere Gerätetypen und anbieterspezifische Anwendungsfälle ab, z. B. für Firmware wird hochgeladen.

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

In beiden Fällen kann eine optionale bluetoothSocket.ListenOptions übergeben werden, um eine bestimmte Kanal oder PSM. Der Callback zeigt einen Fehler durch chrome.runtime.lastError und Erfolg an. sonst. Behalten Sie ein Handle für die SocketId bei, damit Sie später Verbindungen annehmen können (bluetoothSocket.onAccept) von diesem Socket ausgeht.

Clientverbindungen akzeptieren

Clientverbindungen werden angenommen und über die 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);
});

Keine Clientverbindungen mehr annehmen

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

chrome.bluetoothSocket.disconnect(serverSocketId);

Mit energiesparenden Geräten interagieren

Bluetooth Low Energy oder (Bluetooth Smart) ist eine kabellose Technologie mit dem Ziel, den Energieverbrauch zu reduzieren. konsumiert wird. Mit der Bluetooth Low Energy API können Anwendungen die zentrale Rolle eine LE-Verbindung zu einem Peripheriegerät. In den folgenden Abschnitten wird beschrieben, wie Sie mit Bluetooth Low Energy-Peripheriegeräten interagieren.

Peripheriegeräte finden und verbinden

Wie bei herkömmlichen Bluetooth-Geräten können LE-Peripheriegeräte mit den beschriebenen Methoden gefunden werden. unter Geräte in der Nähe finden . Ein LE-Gerät wird durch das Senden von Datenpaketen sichtbar. namens „Werbedaten“ und sich das Gerät im Werbemodus befindet. Werbedaten kann UUIDs von Diensten enthalten, die auf dem Gerät verfügbar sind. Falls vorhanden, sind diese UUIDs zugänglich über das Attribut uuids des entsprechenden bluetooth.Device-Objekts.

Nach der Erkennung kann ein LE-Gerät durch Aufrufen von bluetoothLowEnergy.connect verbunden werden. damit 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, wird das Attribut connected des entsprechenden bluetooth.Device-Objekts den Wert true haben. Durch den Aufruf von bluetoothLowEnergy.connect wird ein Anspruch durch das über die physische Verbindung zum Gerät. Eine physische Verbindung zum Gerät kann bestehen. ohne dass dabei bluetoothLowEnergy.connect aufgerufen wird, beispielsweise aufgrund einer anderen Anwendung. In Ihre App kann zwar weiterhin mit den Diensten des Geräts interagieren, Rufen Sie immer bluetoothLowEnergy.connect auf, um zu verhindern, dass eine andere Anwendung die Verbindung ein physischer Link.

Sobald Ihre Anwendung nicht mehr verbunden sein muss, kann sie den Anspruch auf die Verbindung entfernen, indem Sie ruft bluetoothLowEnergy.disconnect auf:

chrome.bluetoothLowEnergy.disconnect(deviceAddress);

Beachten Sie, dass dadurch nicht unbedingt die physische Verbindung zum Gerät zerstört wird, da andere Verbindungen Apps mit aktiven Verbindungen zu dem Gerät. Manchmal wird das Gerät aus Gründen, die außerhalb der Kontrolle der App liegen, z.B. wenn das Gerät nicht verbunden ist verschwindet oder wird vom Nutzer über Dienstprogramme des Betriebssystems explizit getrennt. Ihre App sollte das Ereignis bluetooth.onDeviceChanged beobachten, um über Änderungen benachrichtigt zu werden und bei Bedarf die Verbindung wiederherstellen.

Sobald die Verbindung hergestellt ist, erhält das Gerät, auf dem Chrome ausgeführt wird, die sogenannte zentrale Rolle. ein Remote-Gerät gilt als Peripheriegerät. Jetzt kann Ihre Anwendung mit der mit den Diensten auf dem Gerät kommunizieren können. Gehen Sie dazu wie im folgenden Abschnitt beschrieben vor. Hinweis: Das APIs unterstützen derzeit die Funktion als LE-Peripheriegerät nicht. Apps können nur die zentrale Rolle implementieren.

Dienste, Merkmale und Beschreibungen

Bluetooth Low Energy basiert auf einem einfachen Anfrage-Antwort-Protokoll namens Attributprotokoll. (ATT). Mithilfe von ATT interagiert ein zentrales Gerät auf einem Peripheriegerät mit den sogenannten Attributen. durch ein spezielles Bluetooth-Profil namens Generic Attribute Profile (GATT). GATT definiert die folgenden übergeordneten Konzepte:

Dienst: Ein GATT-Dienst stellt eine Sammlung von Daten und damit verbundenes Verhalten dar, um ein bestimmte Funktion eines Geräts. Ein Herzfrequenzmesser beispielsweise einen „Herzfrequenzdienst“. Informationen zu einem GATT-Dienst sind in einem bluetoothLowEnergy.Service.
Merkmal: Ein GATT-Merkmal ist ein grundlegendes Datenelement, das zur Erstellung eines GATT-Dienstes verwendet wird. die einen Wert und Eigenschaften enthalten, die festlegen, wie auf diesen Wert zugegriffen werden kann. Beispiel: „Herzfrequenzdienst“ die Funktion zur Messung der Herzfrequenz Eigenschaft, die verwendet wird, den Wert der Herzfrequenz der Nutzenden. Informationen zu einem GATT-Merkmal sind in einem bluetoothLowEnergy.Characteristic-Objekt.
Deskriptor: Ein GATT-Merkmalsdeskriptor enthält weitere Informationen zu einem Merkmal. Informationen zu einem GATT-Merkmalsdeskriptor sind in einem Das Objekt bluetoothLowEnergy.Descriptor.

Mit der Bluetooth Low Energy API können Anwendungen Informationen zum Dienste, Eigenschaften und Deskriptoren durch Aufrufen von bluetoothLowEnergy.getServices bluetoothLowEnergy.getCharacteristics und bluetoothLowEnergy.getDescriptors. Apps können Dienste, Merkmale und Deskriptoren filtern, indem Sie das Feld uuid mit dem gewünschte GATT-UUID:

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, jedem Merkmal und jedem Deskriptor, auf das über die API zugegriffen werden kann, wird eine eindeutige Instanz-ID, die Sie über das Feld instanceId abrufen können. Diese Instanz-ID kann wird verwendet, um ein GATT-Objekt zu identifizieren und bestimmte Vorgänge daran durchzuführen:

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 seine Dienste. Wenn jeder Dienst erkannt und entfernt wird, empfängt die Anwendung bluetoothLowEnergy.onServiceAdded und bluetoothLowEnergy.onServiceRemoved-Ereignisse:

  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 asynchron alle Merkmale und Deskriptoren eines Dienstes und sendet den bluetoothLowEnergy.onServiceAdded, sobald die Erkennung abgeschlossen ist. Wenn die Verbindung zu einem Peripheriegerät wird beendet, entfernt Chrome alle zugehörigen Dienste und sendet bluetoothLowEnergy.onServiceRemoved.

Einige Peripheriegeräte verändern möglicherweise ihre Dienste, z.B. die Merkmale eines Dienstes sich ändern oder werden möglicherweise komplett hinzugefügt oder entfernt. Chrome benachrichtigt Apps über diese Änderungen mithilfe der bluetoothLowEnergy.onServiceChanged, bluetoothLowEnergy.onServiceAdded und bluetoothLowEnergy.onServiceRemoved-Ereignissen.

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

    updateMyService(service);
  });

Wert eines Merkmals lesen und schreiben

Ein GATT-Merkmal codiert einen Aspekt seines Dienstes. Eine zentrale App liest, agiert darauf und verändert sie Status eines Diensts eines Peripheriegeräts, indem er auf den Wert eines Merkmals ausarbeitet. Das Merkmal value ist eine Byte-Sequenz und ihre Bedeutung wird durch die allgemeine Spezifikation definiert, die ein bestimmtes Merkmal. Zum Beispiel der Wert der Eigenschaft Herzfrequenzmessung codiert die Herzfrequenz und die verbrannten Kalorien. Der Körpersensor Die Standorteigenschaft codiert, wo am Körper der Herzfrequenzsensor getragen werden sollte.

Chrome bietet die Methode bluetoothLowEnergy.readCharacteristicValue, um den Wert eines Eigenschaft:

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 Merkmale sind beschreibbar, insbesondere solche, die sich als „Kontrollpunkte“ verhalten, hat der Wert Nebenwirkungen. Die Eigenschaft Herzfrequenz-Kontrollpunkt dient beispielsweise dazu, einem Herzfrequenzsensor sagen, dass er die Anzahl der insgesamt verbrannten Kalorien zurücksetzen soll. Dieser Schritt unterstützt nur Schreibvorgänge. Bis Dafür stellt Chrome die Methode bluetoothLowEnergy.writeCharacteristicValue bereit:

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

Charakteristische Beschreibungen verhalten sich gleich und können lesbar und/oder beschreibbar sein. Chrome bietet bluetoothLowEnergy.readDescriptorValue und bluetoothLowEnergy.writeDescriptorValue Methoden zum Lesen und Schreiben des Werts einer Beschreibung.

Um zu prüfen, ob ein Merkmal Lese- oder Schreibvorgänge unterstützt, kann eine Anwendung den properties prüfen eines bluetoothLowEnergy.Characteristic-Objekts. Dieses Feld enthält zwar Informationen zu den Sicherheitsanforderungen für den Zugriff auf einen Wert enthalten, beschreiben sie, welcher Wert Funktion, die die Eigenschaft im Allgemeinen unterstützt.

Wertbenachrichtigungen verarbeiten

Einige Eigenschaften vermitteln ihren Wert durch Benachrichtigungen oder Hinweise. Zum Beispiel der Die Eigenschaft zur Herzfrequenzmessung ist weder lesbar noch beschreibbar. in regelmäßigen Intervallen den aktuellen Wert. Apps können diese Benachrichtigungen über die bluetoothLowEnergy.onCharacteristicValueChanged.

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

    var bytes = new Uint8Array(chrc.value);

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

Auch wenn ein Merkmal Benachrichtigungen/Angaben unterstützt, sind diese nicht standardmäßig aktiviert. Eine sollte bluetoothLowEnergy.startCharacteristicNotifications und bluetoothLowEnergy.stopCharacteristicNotifications zum Starten oder Beenden des Empfangs der Ereignis 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);
  }

Sobald die Benachrichtigungen gestartet wurden, erhält die Anwendung die bluetoothLowEnergy.onCharacteristicValueChanged, wenn eine Benachrichtigung oder Anzeige von dem Merkmal erhalten. Wenn das Merkmal Lesevorgänge unterstützt, ist dieses Ereignis ebenfalls nach einem erfolgreichen Aufruf von bluetoothLowEnergy.readCharacteristicValue gesendet. Dadurch können Apps um den Kontrollfluss einer Wertaktualisierung zu vereinheitlichen, die durch eine Leseanfrage und Benachrichtigungen ausgelöst wird:

  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 den "notify"- oder "indicate"-Property.

HINWEIS: Wenn ein Merkmal Benachrichtigungen/Angaben unterstützt, wird Charakteristische Konfiguration“ Deskriptor zum Aktivieren/Deaktivieren von Benachrichtigungen. Chrome erlaubt keine Apps in diesen Deskriptor schreiben. Apps sollten stattdessen die Methode bluetoothLowEnergy.startCharacteristicNotifications und bluetoothLowEnergy.stopCharacteristicNotifications zum Steuern des Benachrichtigungsverhaltens.