Dit document beschrijft hoe u de Bluetooth- , Bluetooth Socket- en Bluetooth Low Energy API's kunt gebruiken om te communiceren met Bluetooth- en Bluetooth Low Energy-apparaten.
Voor achtergrondinformatie over Bluetooth raadpleegt u de officiële Bluetooth-specificaties .
Duidelijke eisen
Voor Chrome-apps die Bluetooth gebruiken, voegt u de Bluetooth- vermelding toe aan het manifest en specificeert u, indien van toepassing, de UUID's van profielen, protocollen of services die u wilt implementeren, en of u deze wilt implementeren met de socket en/of Low Energy API's.
Bijvoorbeeld voor een socket-implementatie:
"bluetooth": {
"uuids": [ "1105", "1106" ],
"socket": true
}
En voor een Low Energy-implementatie:
"bluetooth": {
"uuids": [ "180D", "1809", "180F" ],
"low_energy": true
}
Om alleen toegang te krijgen tot de adapterstatus, apparaten in de buurt te ontdekken en basisinformatie over apparaten te verkrijgen, is alleen de invoer zelf vereist:
"bluetooth": {}
Adapterinformatie
Adapterstatus verkrijgen
Gebruik de methode bluetooth.getAdapterState om de status van de Bluetooth-adapter te verkrijgen:
chrome.bluetooth.getAdapterState(function(adapter) {
console.log("Adapter " + adapter.address + ": " + adapter.name);
});
Adaptermeldingen
De gebeurtenis bluetooth.onAdapterStateChanged wordt verzonden wanneer de adapterstatus verandert. Dit kan bijvoorbeeld worden gebruikt om te bepalen wanneer de adapterradio is in- of uitgeschakeld.
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");
}
}
});
Apparaat informatie
Bekende apparaten vermelden
Gebruik de methode bluetooth.getDevices om een lijst te krijgen van de apparaten die bekend zijn bij de Bluetooth-adapter:
chrome.bluetooth.getDevices(function(devices) {
for (var i = 0; i < devices.length; i++) {
console.log(devices[i].address);
}
});
Alle apparaten worden geretourneerd, inclusief gekoppelde apparaten en onlangs ontdekte apparaten. Er wordt niet begonnen met het ontdekken van nieuwe apparaten (zie Apparaten in de buurt ontdekken ).
Apparaatmeldingen ontvangen
In plaats van herhaaldelijk bluetooth.getDevices aan te roepen, kunt u de gebeurtenissen bluetooth.onDeviceAdded , bluetooth.onDeviceChanged en bluetooth.onDeviceRemoved gebruiken om meldingen te ontvangen.
De gebeurtenis bluetooth.onDeviceAdded wordt verzonden wanneer een apparaat door de adapter wordt ontdekt of verbinding maakt met de adapter:
chrome.bluetooth.onDeviceAdded.addListener(function(device) {
console.log(device.address);
});
Als u een luisteraar voor deze gebeurtenis toevoegt, wordt de detectie van apparaten niet gestart (zie Apparaten in de buurt ontdekken ).
Wijzigingen aan apparaten, inclusief eerder ontdekte apparaten die worden gekoppeld, worden gemeld door de gebeurtenis bluetooth.onDeviceChanged :
chrome.bluetooth.onDeviceChanged.addListener(function(device) {
console.log(device.address);
});
Ten slotte wordt de gebeurtenis bluetooth.onDeviceRemoved verzonden wanneer een gekoppeld apparaat uit het systeem wordt verwijderd of een ontdekt apparaat recentelijk niet is gezien:
chrome.bluetooth.onDeviceRemoved.addListener(function(device) {
console.log(device.address);
});
Apparaten in de buurt ontdekken
Gebruik de methode bluetooth.startDiscovery om te beginnen met het ontdekken van apparaten in de buurt. Discovery kan veel resources vergen, dus u moet bluetooth.stopDiscovery aanroepen als u klaar bent.
U moet bluetooth.startDiscovery bellen wanneer uw app apparaten in de buurt moet detecteren. Maak de oproep niet afhankelijk van de discovering eigenschap van bluetooth.AdapterState . De oproep slaagt zelfs als een andere app apparaten in de buurt ontdekt, en zorgt ervoor dat de adapter de detectie blijft uitvoeren nadat die andere app is gestopt.
Informatie over elk nieuw ontdekt apparaat wordt ontvangen met behulp van de gebeurtenis bluetooth.onDeviceAdded . Voor apparaten die onlangs al zijn ontdekt of waarmee eerder is gekoppeld of waarmee verbinding is gemaakt, wordt de gebeurtenis niet verzonden. In plaats daarvan moet u bluetooth.getDevices aanroepen om de huidige informatie te verkrijgen, en de gebeurtenis bluetooth.onDeviceChanged gebruiken om op de hoogte te worden gesteld van wijzigingen in die informatie als gevolg van ontdekking.
Voorbeeld:
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);
});
Als de gebruiker de Bluetooth-radio uitzet, worden alle detectiesessies beëindigd en niet automatisch hervat wanneer de radio wordt ingeschakeld. Als dit belangrijk is voor uw app, moet u de gebeurtenis bluetooth.onAdapterStateChanged bekijken. Als de discovering eigenschap verandert in false , moet uw app bluetooth.startDiscovery opnieuw aanroepen om te hervatten. Wees voorzichtig met de hulpbronnenintensieve aard van ontdekkingen.
Apparaten identificeren
Er zijn een aantal verschillende opties beschikbaar voor het identificeren van apparaten die worden geretourneerd door bluetooth.getDevices en de bijbehorende gebeurtenissen.
Als het apparaat de Bluetooth Device ID-specificatie ondersteunt, worden er verschillende eigenschappen toegevoegd aan het Device-object met de velden die door die specificatie zijn gedefinieerd. Voorbeeld:
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));
}
}
});
De Device ID-specificatie is doorgaans voldoende om een bepaald model, en zelfs een revisie, van een apparaat van een leverancier te identificeren. Als dit niet aanwezig is, moet u in plaats daarvan vertrouwen op informatie over de klasse of het type van het apparaat, eventueel gecombineerd met het voorvoegsel van de fabrikant in het address .
De meeste Bluetooth-apparaten bieden apparaatklasse-informatie als een bitveld, geïnterpreteerd volgens het Baseband Assigned Numbers- document. Dit bitveld is beschikbaar in de eigenschap 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));
}
}
});
Het parseren van het veld kan complex zijn, dus voor de meest voorkomende apparaattypen handelt Chrome dit voor u af en stelt het type in. Als dit niet beschikbaar is, of onvoldoende is voor uw behoeften, moet u de deviceClass zelf parseren.
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);
}
}
});
Met behulp van RFCOMM en L2CAP
Chrome Apps kunnen verbindingen maken met elk apparaat dat RFCOMM- of L2CAP-services ondersteunt. Dit omvat het merendeel van de klassieke Bluetooth-apparaten op de markt.
Aansluiten op een stopcontact
Om verbinding te maken met een apparaat heb je drie dingen nodig. Een socket om verbinding mee te maken, gemaakt met bluetoothSocket.create ; het adres van het apparaat waarmee u verbinding wilt maken, en de UUID van de dienst zelf.
Voordat u de verbinding tot stand brengt, moet u verifiëren dat de adapter het apparaat kent met behulp van bluetooth.getDevice of de apparaatdetectie-API's.
De informatie die nodig is om de onderliggende verbinding tot stand te brengen, inclusief of het RFCOMM- of L2CAP-protocol moet worden gebruikt en welk kanaal of PSM, wordt verkregen met behulp van SDP-detectie op het apparaat.
Voorbeeld:
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);
});
Houd een handvat bij de socketId zodat u later gegevens ( bluetoothSocket.send ) naar deze socket kunt verzenden.
Ontvangen van en verzenden naar een stopcontact
Het ontvangen van gegevens van en het verzenden naar een socket maakt gebruik van ArrayBuffer objecten. Voor meer informatie over ArrayBuffers kunt u het overzicht, JavaScript-getypeerde arrays en de tutorial Hoe ArrayBuffer van en naar String converteren bekijken.
Gebruik bluetoothSocket.send om gegevens in arrayBuffer te verzenden:
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")
}
})
In tegenstelling tot de methode om gegevens te verzenden, worden gegevens ontvangen in een gebeurtenis ( bluetoothSocket.onReceive . Sockets worden ononderbroken gemaakt (zie bluetoothSocket.setPaused ), dus de luisteraar voor deze gebeurtenis wordt doorgaans toegevoegd tussen bluetoothSocket.create en bluetoothSocket.connect .
chrome.bluetoothSocket.onRecieve.addListener(function(receiveInfo) {
if (receiveInfo.socketId != socketId)
return;
// receiveInfo.data is an ArrayBuffer.
});
Ontvangst van socketfouten en ontkoppeling
Als u op de hoogte wilt worden gesteld van socketfouten, inclusief het verbreken van de verbinding, voegt u een luisteraar toe aan de gebeurtenis bluetoothSocket.onReceiveError .
chrome.bluetoothSocket.onReceiveError.addListener(function(errorInfo) {
// Cause is in errorInfo.error.
console.log(errorInfo.errorMessage);
});
Loskoppelen van een stopcontact
Gebruik bluetoothSocket.disconnect om de verbinding te verbreken en het stopcontact te verbreken.
chrome.bluetoothSocket.disconnect(socketId);
Uitgeverijdiensten
Naast het maken van uitgaande verbindingen met apparaten, kunnen Chrome Apps services publiceren die kunnen worden gebruikt door elk apparaat dat RFCOMM of L2CAP ondersteunt.
Luisteren op een stopcontact
Er worden twee typen gepubliceerde services ondersteund. RFCOMM wordt het meest gebruikt en omvat de meeste apparaten en profielen:
var uuid = '1105';
chrome.bluetoothSocket.create(function(createInfo) {
chrome.bluetoothSocket.listenUsingRfcomm(createInfo.socketId,
uuid, onListenCallback);
});
L2CAP is de andere en omvat andere apparaattypen en leverancierspecifiek gebruik, zoals het uploaden van firmware.
var uuid = '0b87367c-f188-47cd-bc20-a5f4f70973c6';
chrome.bluetoothSocket.create(function(createInfo) {
chrome.bluetoothSocket.listenUsingL2cap(createInfo.socketId,
uuid, onListenCallback);
});
In beide gevallen kan een optionele bluetoothSocket.ListenOptions worden doorgegeven om een specifiek kanaal of PSM toe te wijzen. De callback geeft een fout aan via chrome.runtime.lastError en anders succes. Houd een handvat bij de socketId zodat u later verbindingen ( bluetoothSocket.onAccept ) van deze socket kunt accepteren.
Clientverbindingen accepteren
Clientverbindingen worden geaccepteerd en doorgegeven aan uw toepassing via de gebeurtenis 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);
});
Stop met het accepteren van clientverbindingen
Gebruik bluetoothSocket.disconnect om het accepteren van clientverbindingen te stoppen en de publicatie van de service ongedaan te maken.
chrome.bluetoothSocket.disconnect(serverSocketId);
Interactie met Low Energy-apparaten
Bluetooth Low Energy of (Bluetooth Smart) is een draadloze technologie gericht op een lager energieverbruik. Met de Bluetooth Low Energy API kunnen applicaties de centrale rol vervullen in een LE-verbinding met een randapparaat. In de volgende secties wordt beschreven hoe u Bluetooth Low Energy-randapparatuur kunt ontdekken, er verbinding mee kunt maken en ermee kunt communiceren.
Randapparatuur ontdekken en verbinden
Net als bij traditionele Bluetooth-apparaten kunnen LE-randapparatuur worden ontdekt met behulp van de methoden die worden beschreven in Apparaten in de buurt ontdekken . Een LE-apparaat maakt zichzelf vindbaar door datapakketten te verzenden die "Advertising Data" worden genoemd en het apparaat staat in de advertentiemodus . De advertentiegegevens kunnen UUID's bevatten van diensten die op het apparaat beschikbaar zijn. Indien aanwezig zijn deze UUID's toegankelijk via de eigenschap uuids van het overeenkomstige bluetooth.Device- object.
Eenmaal ontdekt, kan er verbinding worden gemaakt met een LE-apparaat door bluetoothLowEnergy.connect aan te roepen, zodat de applicatie kan communiceren met zijn 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...
...
});
});
Eenmaal verbonden, zal de connected eigenschap van het corresponderende bluetooth.Device- object de waarde true hebben. Door bluetoothLowEnergy.connect aan te roepen, wordt door de applicatie een claim op de fysieke verbinding met het apparaat tot stand gebracht. Er kan een fysieke verbinding met het apparaat bestaan zonder ooit bluetoothLowEnergy.connect aan te roepen (bijvoorbeeld vanwege een andere applicatie). In dit geval moet uw applicatie, terwijl deze nog steeds kan communiceren met de services van het apparaat, altijd bluetoothLowEnergy.connect aanroepen om te voorkomen dat een andere applicatie de fysieke link verbreekt.
Zodra uw applicatie niet langer verbonden hoeft te worden, kan deze de claim op de verbinding verwijderen door bluetoothLowEnergy.disconnect aan te roepen:
chrome.bluetoothLowEnergy.disconnect(deviceAddress);
Houd er rekening mee dat hierdoor niet noodzakelijkerwijs de fysieke link met het apparaat wordt vernietigd, omdat er mogelijk andere applicaties zijn die actieve verbindingen met het apparaat hebben. Soms kan de verbinding met het apparaat worden verbroken vanwege redenen die buiten de controle van de toepassing liggen (bijvoorbeeld als het apparaat verdwijnt of expliciet wordt losgekoppeld door de gebruiker via hulpprogramma's van het besturingssysteem). Uw toepassing moet de gebeurtenis bluetooth.onDeviceChanged observeren om op de hoogte te worden gesteld van wijzigingen in de verbinding en indien nodig opnieuw verbinding te maken.
Eenmaal verbonden, zal het apparaat waarop Chrome draait de zogenaamde centrale rol spelen, terwijl het externe apparaat de perifere rol zou spelen. Op dit punt kan uw toepassing communiceren met de services op het apparaat met behulp van de methoden die in de volgende sectie worden beschreven. Opmerking: de API's bieden momenteel geen ondersteuning voor het fungeren als LE-randapparaat; apps kunnen alleen de centrale rol vervullen.
Diensten, kenmerken en beschrijvingen
Bluetooth Low Energy is gebaseerd op een eenvoudig verzoek-antwoordprotocol, het Attribute Protocol (ATT). Met behulp van ATT communiceert een centraal apparaat met de zogenaamde attributen op een randapparaat door zich te conformeren aan een speciaal Bluetooth-profiel, het Generic Attribute Profile (GATT). GATT definieert de volgende concepten op hoog niveau:
- Service: Een GATT-service vertegenwoordigt een verzameling gegevens en bijbehorend gedrag om een bepaalde functie van een apparaat te vervullen. Een hartslagmeter heeft bijvoorbeeld doorgaans ten minste één "hartslagservice". Informatie over een GATT-service bevindt zich in een bluetoothLowEnergy.Service- object.
- Kenmerk: Een GATT-kenmerk is een basisgegevenselement dat wordt gebruikt om een GATT-service te construeren, dat een waarde bevat, samen met eigenschappen die bepalen hoe toegang tot die waarde kan worden verkregen. De "Hartslagservice" heeft bijvoorbeeld het kenmerk "Hartslagmeting", dat wordt gebruikt om de waarde van de hartslag van de gebruiker te verkrijgen. Informatie over een GATT-kenmerk bevindt zich in een bluetoothLowEnergy.Characteristic -object.
- Descriptor: Een GATT-kenmerkdescriptor bevat verdere informatie over een kenmerk. Informatie over een GATT-kenmerkdescriptor bevindt zich in een bluetoothLowEnergy.Descriptor- object.
Met de Bluetooth Low Energy API kunnen toepassingen informatie vinden over de services, kenmerken en descriptors van een apparaat door bluetoothLowEnergy.getServices , bluetoothLowEnergy.getCharacteristics en bluetoothLowEnergy.getDescriptors aan te roepen. Apps kunnen services, kenmerken en descriptors filteren door hun uuid veld te vergelijken met de gewenste 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;
}
}
...
});
Aan elke service, eigenschap en descriptor die via de API toegankelijk is, wordt een unieke instance-ID toegewezen, die kan worden verkregen met behulp van het instanceId veld. Dit instance-ID kan worden gebruikt om een GATT-object te identificeren en er specifieke bewerkingen op uit te voeren:
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) {
...
});
});
Service-evenementen
Zodra een apparaat is verbonden, zal Chrome de services ervan ontdekken. Wanneer elke service wordt ontdekt en verwijderd, ontvangt de toepassing de gebeurtenissen bluetoothLowEnergy.onServiceAdded en 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 ontdekt asynchroon alle kenmerken en beschrijvingen van een service en verzendt de gebeurtenis bluetoothLowEnergy.onServiceAdded zodra de detectie is voltooid. Als de verbinding met een randapparaat wordt verbroken, verwijdert Chrome alle gerelateerde services en verzendt de gebeurtenis bluetoothLowEnergy.onServiceRemoved .
Sommige randapparaten kunnen hun diensten wijzigen; de kenmerken van een dienst kunnen bijvoorbeeld veranderen of diensten kunnen geheel worden toegevoegd of verwijderd. Chrome brengt apps op de hoogte van deze wijzigingen met behulp van de gebeurtenissen bluetoothLowEnergy.onServiceChanged , bluetoothLowEnergy.onServiceAdded en bluetoothLowEnergy.onServiceRemoved .
chrome.bluetoothLowEnergy.onServiceChanged.addListener(function(service) {
if (service.instanceId != myService.instanceId)
return;
updateMyService(service);
});
De waarde van een kenmerk lezen en schrijven
Een GATT-kenmerk codeert één aspect van de dienstverlening ervan. Een centrale app leest, handelt en wijzigt de status van de service van een randapparaat door te werken op de waarde van een kenmerk. De karakteristieke waarde is een reeks bytes en de betekenis ervan wordt gedefinieerd door de specificatie op hoog niveau die een bepaald kenmerk definieert. De waarde van het kenmerk Hartslagmeting codeert bijvoorbeeld de hartslag van de gebruiker en de totale hoeveelheid calorieën die hij heeft verbrand, terwijl het kenmerk Lichaamssensorlocatie codeert waar in het lichaam de hartslagsensor moet worden gedragen.
Chrome biedt de methode bluetoothLowEnergy.readCharacteristicValue om de waarde van een kenmerk te lezen:
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.
...
});
Sommige kenmerken zijn beschrijfbaar, vooral die kenmerken die zich gedragen als "controlepunten", waarbij het schrijven van de waarde bijwerkingen heeft. De eigenschap Hartslagcontrolepunt wordt bijvoorbeeld gebruikt om een hartslagsensor te vertellen de telling van het totale aantal verbrande calorieën te resetten en ondersteunt alleen schrijfbewerkingen. Om dit te bereiken biedt Chrome de 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.
});
Karakteristieke descriptoren gedragen zich op dezelfde manier en kunnen leesbaar en/of beschrijfbaar zijn. Chrome biedt de methoden bluetoothLowEnergy.readDescriptorValue en bluetoothLowEnergy.writeDescriptorValue om de waarde van een descriptor te lezen en te schrijven.
Om te controleren of een kenmerk lezen of schrijven ondersteunt, kan een applicatie het properties van een bluetoothLowEnergy.Characteristic -object controleren. Hoewel dit veld geen informatie bevat over de beveiligingsvereisten voor toegang tot een waarde, wordt wel beschreven welke waardebewerking het kenmerk in het algemeen ondersteunt.
Het afhandelen van waardemeldingen
Sommige kenmerken maken hun waarde kenbaar door middel van meldingen of indicaties. De hartslagmetingskarakteristiek is bijvoorbeeld niet leesbaar of schrijfbaar, maar verzendt met regelmatige tussenpozen updates over de huidige waarde. Toepassingen kunnen naar deze meldingen luisteren met behulp van de gebeurtenis bluetoothLowEnergy.onCharacteristicValueChanged .
chrome.bluetoothLowEnergy.onCharacteristicValueChanged.addListener(
function(chrc) {
if (chrc.instanceId != myCharId)
return;
var bytes = new Uint8Array(chrc.value);
// Do stuff with the bytes.
...
});
Zelfs als een kenmerk meldingen/indicaties ondersteunt, zijn deze niet standaard ingeschakeld. Een toepassing moet de methoden bluetoothLowEnergy.startCharacteristicNotifications en bluetoothLowEnergy.stopCharacteristicNotifications aanroepen om de ontvangst van de gebeurtenis bluetoothLowEnergy.onCharacteristicValueChanged te starten of te stoppen.
// 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);
}
Zodra meldingen zijn gestart, ontvangt de applicatie de bluetoothLowEnergy.onCharacteristicValueChanged telkens wanneer er een melding of indicatie wordt ontvangen van het kenmerk. Als het kenmerk reads ondersteunt, wordt deze gebeurtenis ook verzonden na een succesvolle aanroep naar bluetoothLowEnergy.readCharacteristicValue . Hierdoor kunnen apps de controlestroom verenigen van een waarde-update die wordt geactiveerd via een leesverzoek en meldingen:
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.
});
});
Als een kenmerk meldingen ondersteunt, bevat het properties de eigenschap "notify" of "indicate" .
OPMERKING: Als een kenmerk meldingen/indicaties ondersteunt, heeft deze de descriptor "Client Characteristic Configuration" om meldingen in of uit te schakelen. Chrome staat niet toe dat apps naar deze descriptor schrijven. Apps moeten in plaats daarvan de methoden bluetoothLowEnergy.startCharacteristicNotifications en bluetoothLowEnergy.stopCharacteristicNotifications gebruiken om het meldingsgedrag te controleren.