Questo documento descrive come utilizzare il Bluetooth, la presa Bluetooth e il Bluetooth Low API Energy per comunicare con dispositivi Bluetooth e Bluetooth Low Energy.
Per informazioni di base sul Bluetooth, leggi le specifiche ufficiali del Bluetooth.
Requisiti dei file manifest
Per le app di Chrome che utilizzano il Bluetooth, aggiungi la voce bluetooth al file manifest e specifica, se appropriato, gli UUID dei profili, dei protocolli o dei servizi che vuoi implementare e se si desidera implementarle con le API socket e/o Low Energy.
Ad esempio, per un'implementazione socket:
"bluetooth": {
"uuids": [ "1105", "1106" ],
"socket": true
}
Per un'implementazione a bassa energia:
"bluetooth": {
"uuids": [ "180D", "1809", "180F" ],
"low_energy": true
}
Per accedere solo allo stato dell'adattatore, rilevare i dispositivi nelle vicinanze e ottenere informazioni di base sui dispositivi, è richiesta solo la voce stessa:
"bluetooth": {}
Informazioni sull'adattatore
Recupero stato adattatore in corso...
Per conoscere lo stato dell'adattatore Bluetooth, utilizza il metodo bluetooth.getAdapterState:
chrome.bluetooth.getAdapterState(function(adapter) {
console.log("Adapter " + adapter.address + ": " + adapter.name);
});
Notifiche dell'adattatore
L'evento bluetooth.onAdapterStateChanged viene inviato ogni volta che lo stato dell'adattatore cambia. Questo può ad esempio per determinare quando la radio dell'adattatore è accesa o spenta.
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");
}
}
});
Informazioni sul dispositivo
Elenco dei dispositivi noti
Per ottenere un elenco dei dispositivi noti all'adattatore Bluetooth, utilizza il comando bluetooth.getDevices. :
chrome.bluetooth.getDevices(function(devices) {
for (var i = 0; i < devices.length; i++) {
console.log(devices[i].address);
}
});
Vengono restituiti tutti i dispositivi, inclusi quelli accoppiati e quelli rilevati di recente. Non iniziare il rilevamento di nuovi dispositivi (consulta la sezione Rilevamento di dispositivi nelle vicinanze).
Ricezione di notifiche sul dispositivo
Anziché chiamare ripetutamente bluetooth.getDevices, puoi utilizzare bluetooth.onDeviceAdded, bluetooth.onDeviceChanged e bluetooth.onDeviceRemoved eventi per ricevere notifiche.
L'evento bluetooth.onDeviceAdded viene inviato ogni volta che un dispositivo viene rilevato dall'adattatore oppure stabilisce una connessione all'adattatore:
chrome.bluetooth.onDeviceAdded.addListener(function(device) {
console.log(device.address);
});
L'aggiunta di un listener per questo evento non avvia il rilevamento di dispositivi (vedi Rilevamento di dispositivi nelle vicinanze). dispositivi mobili).
Le modifiche apportate ai dispositivi, inclusi i dispositivi rilevati in precedenza in fase di accoppiamento, vengono notificate dal Evento bluetooth.onDeviceChanged:
chrome.bluetooth.onDeviceChanged.addListener(function(device) {
console.log(device.address);
});
Infine, l'evento bluetooth.onDeviceRemoved viene inviato ogni volta che un dispositivo accoppiato viene rimosso da sistema o un dispositivo rilevato non è stato rilevato di recente:
chrome.bluetooth.onDeviceRemoved.addListener(function(device) {
console.log(device.address);
});
Rilevamento di dispositivi nelle vicinanze
Per avviare il rilevamento dei dispositivi nelle vicinanze, utilizza il metodo bluetooth.startDiscovery. La scoperta può richiede un consumo di risorse elevato, quindi al termine dovresti chiamare bluetooth.stopDiscovery.
Devi chiamare bluetooth.startDiscovery ogni volta che la tua app deve rilevare dispositivi nelle vicinanze.
Non rendere condizionale la chiamata alla proprietà discovering di bluetooth.AdapterState. La
la chiamata avrà esito positivo anche se un'altra app rileva dispositivi nelle vicinanze e garantirà che l'adattatore
continua a eseguire il rilevamento dopo l'interruzione dell'altra app.
Le informazioni su ogni dispositivo appena rilevato vengono ricevute tramite bluetooth.onDeviceAdded . Per i dispositivi già rilevati di recente o precedentemente accoppiati con o connesso, l'evento non verrà inviato. Invece, devi chiamare bluetooth.getDevices per ottenere le informazioni attuali e utilizzare l'evento bluetooth.onDeviceChanged per ricevere una notifica modifiche a queste informazioni a seguito del rilevamento.
Esempio:
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);
});
Se l'utente disattiva la radio Bluetooth, tutte le sessioni di rilevamento verranno terminate e non riprenderanno
automaticamente quando la radio è accesa. Se questo è importante per la tua app, dovresti guardare il
bluetooth.onAdapterStateChanged. Se la proprietà discovering diventa false:
l'app dovrà chiamare di nuovo bluetooth.startDiscovery per riprendere. Presta attenzione alle
per un'individuazione che richiede un elevato utilizzo
di risorse.
Identificare i dispositivi
Sono disponibili diverse opzioni per identificare i dispositivi restituiti bluetooth.getDevices e gli eventi correlati.
Se il dispositivo supporta la specifica ID dispositivo Bluetooth, vengono aggiunte diverse proprietà al l'oggetto Device contenente i campi definiti da tale specifica. Esempio:
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 specifica dell'ID dispositivo è in genere sufficiente
per identificare un determinato modello e persino una revisione,
di un dispositivo di un fornitore. Dove non è presente, è invece necessario basarsi sulle informazioni relative alla
classe o tipo di dispositivo, facoltativamente combinato con il prefisso del produttore nell'address.
La maggior parte dei dispositivi Bluetooth fornisce le informazioni sulla classe del dispositivo sotto forma di campo di bit interpretato in base a
il documento Baseband Assigned Numbers. Questo campo di bit è disponibile in deviceClass
proprietà.
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'analisi del campo può essere complessa quindi, per i tipi di dispositivi più comuni, Chrome gestisce questa operazione per te e
consente di impostare il campo type. Se non è disponibile o non è sufficiente per le tue esigenze, dovrai:
analizzare deviceClass autonomamente.
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);
}
}
});
Utilizzo di RFCOMM e L2CAP
Le App di Chrome possono stabilire connessioni a qualsiasi dispositivo che supporta i servizi RFCOMM o L2CAP. Sono inclusi la maggior parte dei dispositivi Bluetooth classici sul mercato.
Collegamento a una presa
Per stabilire una connessione a un dispositivo, hai bisogno di tre elementi. Una presa per effettuare il collegamento creato utilizzando bluetoothSocket.create. l'indirizzo del dispositivo a cui vuoi connetterti, e l'UUID del servizio stesso.
Prima di effettuare il collegamento, devi verificare che l'adattatore sia a conoscenza del dispositivo utilizzando bluetooth.getDevice o le API di rilevamento dei dispositivi.
Le informazioni necessarie per stabilire la connessione di base, ad esempio se RFCOMM o È necessario utilizzare il protocollo L2CAP e quale canale o PSM si ottiene utilizzando il rilevamento SDP sulla dispositivo.
Esempio:
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);
});
Conserva un handle a socketId in modo da poter inviare i dati (bluetoothSocket.send) a questo presa.
Ricezione e invio su un socket
La ricezione di dati da e l'invio a un socket utilizza gli oggetti ArrayBuffer. Per saperne di più su ArrayBuffers,
guarda la panoramica, Array digitati JavaScript, e il tutorial, Come convertire ArrayBuffer
da e verso una stringa.
Per inviare i dati presenti in arrayBuffer utilizza 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")
}
})
A differenza del metodo con cui inviare i dati, i dati vengono ricevuti in un evento (bluetoothSocket.onReceive. I socket vengono creati riattivati (vedi bluetoothSocket.setPaused) pertanto il listener per questo evento viene generalmente aggiunto tra bluetoothSocket.create e bluetoothSocket.connect.
chrome.bluetoothSocket.onRecieve.addListener(function(receiveInfo) {
if (receiveInfo.socketId != socketId)
return;
// receiveInfo.data is an ArrayBuffer.
});
Ricezione di errori di socket e disconnessione
Per ricevere notifiche relative a errori socket, inclusa la disconnessione, aggiungi un listener al Evento bluetoothSocket.onReceiveError.
chrome.bluetoothSocket.onReceiveError.addListener(function(errorInfo) {
// Cause is in errorInfo.error.
console.log(errorInfo.errorMessage);
});
Disconnettersi da una presa
Per interrompere la connessione e scollegare la presa, utilizza bluetoothSocket.disconnect.
chrome.bluetoothSocket.disconnect(socketId);
Servizi di pubblicazione
Oltre a effettuare connessioni in uscita ai dispositivi, le App di Chrome possono pubblicare servizi che utilizzato da qualsiasi dispositivo che supporta RFCOMM o L2CAP.
Ascoltare su una presa
Sono supportati due tipi di servizi pubblicati. RFCOMM è il più comunemente usato e copre la maggior parte dei dispositivi e dei profili:
var uuid = '1105';
chrome.bluetoothSocket.create(function(createInfo) {
chrome.bluetoothSocket.listenUsingRfcomm(createInfo.socketId,
uuid, onListenCallback);
});
L2CAP è l'altro e copre altri tipi di dispositivi e utilizzi specifici del fornitore, come il firmware caricamento in corso.
var uuid = '0b87367c-f188-47cd-bc20-a5f4f70973c6';
chrome.bluetoothSocket.create(function(createInfo) {
chrome.bluetoothSocket.listenUsingL2cap(createInfo.socketId,
uuid, onListenCallback);
});
In entrambi i casi, potrebbe essere passato un valore bluetoothSocket.ListenOptions facoltativo per allocare un
canale o PSM. Il callback indica un errore tramite chrome.runtime.lastError e l'esito è positivo
negli altri casi. Mantenere un handle nel socketId per poter accettare le connessioni in un secondo momento
(bluetoothSocket.onAccept) da questo socket.
Accettazione delle connessioni client in corso
Le connessioni client vengono accettate e trasmesse all'applicazione tramite 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);
});
Interrompi l'accettazione di connessioni client
Per interrompere l'accettazione di connessioni client e annullare la pubblicazione del servizio, utilizza bluetoothSocket.disconnect.
chrome.bluetoothSocket.disconnect(serverSocketId);
Interazione con dispositivi a bassa energia
Bluetooth Low Energy o (Bluetooth Smart) è una tecnologia wireless che riduce l'energia il consumo eccessivo. L'API Bluetooth Low Energy consente alle applicazioni di implementare il ruolo centrale nel una connessione LE a una periferica. Le seguenti sezioni descrivono come scoprire, connetterti e interagire con le periferiche Bluetooth Low Energy.
Rilevamento e connessione alle periferiche
Come con i dispositivi Bluetooth tradizionali, le periferiche LE possono essere scoperte utilizzando i metodi descritti
in Rilevamento di dispositivi nelle vicinanze . Un dispositivo LE si rende rilevabile inviando pacchetti di dati
chiamata "Dati pubblicitari" e il dispositivo si trova in modalità pubblicità. I dati pubblicitari
potrebbero contenere UUID di servizi disponibili sul dispositivo. Se presenti, questi UUID verranno
accessibile tramite la proprietà uuids dell'oggetto bluetooth.Device corrispondente.
Una volta rilevato, un dispositivo LE può essere connesso chiamando bluetoothLowEnergy.connect in modo che che l'applicazione possa interagire con i suoi servizi:
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...
...
});
});
Dopo la connessione, la proprietà connected dell'oggetto bluetooth.Device corrispondente verrà
hanno il valore true. La chiamata a bluetoothLowEnergy.connect stabilisce una richiesta da parte del
dell'applicazione sulla connessione fisica al dispositivo. Può esistere una connessione fisica al dispositivo
senza mai chiamare bluetoothLowEnergy.connect (ad esempio a causa di un'altra applicazione). Nella
in questo caso, anche se la tua applicazione può ancora interagire con i servizi del dispositivo,
chiama sempre bluetoothLowEnergy.connect per impedire a un'altra applicazione di disconnettere il
collegamento fisico.
Quando la tua applicazione non deve più essere connessa, può rimuovere la richiesta relativa alla connessione chiamata bluetoothLowEnergy.disconnect:
chrome.bluetoothLowEnergy.disconnect(deviceAddress);
Tieni presente che ciò non determinerà necessariamente l'eliminazione del collegamento fisico al dispositivo, poiché potrebbero esserci altri applicazioni con connessioni attive al dispositivo. A volte il dispositivo potrebbe disconnessi per motivi che esulano dal controllo dell'applicazione (ad esempio, se il dispositivo scompare o viene esplicitamente disconnessa dall'utente tramite utilità del sistema operativo). La tua applicazione dovrebbe osservare l'evento bluetooth.onDeviceChanged per ricevere notifiche delle modifiche alla connessione e, se necessario, ricollegarti.
Una volta connesso, il dispositivo su cui è in esecuzione Chrome avrà il cosiddetto ruolo centrale, mentre dispositivo remoto abbia il ruolo di periferica. A questo punto, l'applicazione può interagire con i servizi sul dispositivo utilizzando i metodi descritti nella sezione che segue. Nota: il Attualmente le API non supportano l'uso di periferica LE. le app possono implementare solo il ruolo centrale.
Servizi, caratteristiche e descrittori
Bluetooth Low Energy si basa su un semplice protocollo di richiesta-risposta chiamato Attribute Protocol (ATT). Grazie all'ATT, un dispositivo centrale interagisce con i cosiddetti attributi su un dispositivo periferico mediante la conformità a uno speciale profilo Bluetooth denominato Generic Attribute Profile (GATT). GATT definisce i seguenti concetti di alto livello:
- Servizio: un servizio GATT rappresenta una raccolta di dati e dei comportamenti associati per eseguire un funzione specifica di un dispositivo. Ad esempio, un cardiofrequenzimetro di solito ha almeno un "Servizio di frequenza cardiaca". Le informazioni su un servizio GATT sono contenute in un bluetoothLowEnergy.Service.
- Caratteristica: una caratteristica GATT è un elemento di dati di base utilizzato per creare un servizio GATT. contenente un valore insieme alle proprietà che ne definiscono la modalità di accesso. Ad esempio: il "Servizio di rilevazione del battito cardiaco" è presente la colonna "Misurazione del battito cardiaco" , che viene utilizzata per ottenere il valore del battito cardiaco dell'utente. Le informazioni su una caratteristica GATT sono contenute in un bluetoothLowEnergy.Characteristic.
- Descrittore: un descrittore della caratteristica GATT contiene ulteriori informazioni su una caratteristica. Le informazioni su un descrittore della caratteristica GATT sono contenute in un bluetoothLowEnergy.Descriptor.
L'API Bluetooth Low Energy consente alle applicazioni di trovare informazioni sull'
servizi, caratteristiche e descrittori chiamando bluetoothLowEnergy.getServices,
bluetoothLowEnergy.getCharacteristics e bluetoothLowEnergy.getDescriptors. Le app possono
filtrano servizi, caratteristiche e descrittori confrontando il campo uuid con
UUID GATT desiderato:
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;
}
}
...
});
A ogni servizio, caratteristica e descrittore accessibile tramite l'API viene assegnato un
identificatore di istanza, che puoi ottenere utilizzando il campo instanceId. Questo ID istanza può essere
utilizzato per identificare un oggetto GATT ed eseguire operazioni specifiche sull'oggetto:
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) {
...
});
});
Eventi di servizio
Una volta connesso un dispositivo, Chrome rileva i suoi servizi. Quando ogni servizio viene rilevato rimosso, l'applicazione riceverà il comando bluetoothLowEnergy.onServiceAdded e Eventi 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 rileva tutte le caratteristiche e i descrittori di un servizio in modo asincrono e invia il Evento bluetoothLowEnergy.onServiceAdded al termine del rilevamento. Se la connessione a un termina la periferica, Chrome rimuove tutti i servizi correlati e invia Evento bluetoothLowEnergy.onServiceRemoved.
Alcune periferiche possono modificare i servizi, ad esempio le caratteristiche di un servizio possono cambiare potrebbero essere aggiunti e rimossi del tutto. Chrome invia una notifica alle app di questi cambiamenti utilizzando bluetoothLowEnergy.onServiceChanged, bluetoothLowEnergy.onServiceAdded e Eventi bluetoothLowEnergy.onServiceRemoved.
chrome.bluetoothLowEnergy.onServiceChanged.addListener(function(service) {
if (service.instanceId != myService.instanceId)
return;
updateMyService(service);
});
Lettura e scrittura del valore di una caratteristica
Una caratteristica GATT codifica un aspetto del suo servizio. Un'app centrale legge, agisce e modifica lo stato del servizio di una periferica operando sul valore di una caratteristica. La caratteristica è una sequenza di byte il cui significato è definito dalla specifica di alto livello che definisce una determinata caratteristica. Ad esempio, il valore della caratteristica di Misurazione del battito cardiaco codifica il battito cardiaco dell'utente e la quantità totale di calorie bruciate, mentre il sensore per il corpo Posizione codifica la posizione del corpo in cui deve essere indossato il sensore del battito cardiaco.
Chrome fornisce il metodo bluetoothLowEnergy.readCharacteristicValue per leggere il valore di un caratteristica:
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.
...
});
Alcune caratteristiche sono scrivibili, in particolare quelle che si comportano come "punti di controllo", in cui la scrittura il valore ha degli effetti collaterali. Ad esempio, la caratteristica Punto di controllo del battito cardiaco viene utilizzata per: Di' a un sensore del battito cardiaco di reimpostare il conteggio delle calorie totali bruciate e supporta solo le operazioni di scrittura. A raggiungere questo obiettivo, Chrome fornisce il metodo 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.
});
I descrittori delle caratteristiche si comportano allo stesso modo e possono essere leggibili e/o scrivibili. Chrome fornisce bluetoothLowEnergy.readDescriptorValue e bluetoothLowEnergy.writeDescriptorValue per leggere e scrivere il valore di un descrittore.
Per verificare se una caratteristica supporta letture o scritture, un'applicazione può controllare properties
campo di un oggetto bluetoothLowEnergy.Characteristic. Questo campo non contiene
informazioni sui requisiti di sicurezza per accedere a un valore, descrive quale valore
operativa supportata in generale dalla caratteristica.
Gestione delle notifiche sui valori
Alcune caratteristiche ne fanno conoscere il valore tramite notifiche o indicazioni. Ad esempio, La caratteristica di misurazione del battito cardiaco non è leggibile né scrivibile, ma invia aggiornamenti sulla relativa valore corrente a intervalli regolari. Le applicazioni possono ascoltare queste notifiche utilizzando bluetoothLowEnergy.onCharacteristicValueChanged.
chrome.bluetoothLowEnergy.onCharacteristicValueChanged.addListener(
function(chrc) {
if (chrc.instanceId != myCharId)
return;
var bytes = new Uint8Array(chrc.value);
// Do stuff with the bytes.
...
});
Anche se una caratteristica supporta notifiche/indicazioni, queste non sono attive per impostazione predefinita. Un l'applicazione deve chiamare bluetoothLowEnergy.startCharacteristicNotifications e bluetoothLowEnergy.stopCharacteristicNotifications per avviare o interrompere la ricezione del Evento 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);
}
Una volta avviate le notifiche, l'applicazione riceverà bluetoothLowEnergy.onCharacteristicValueChanged ogni volta che viene visualizzata una notifica o un'indicazione ricevuto dalla caratteristica. Se la caratteristica supporta le letture, anche questo evento verrà inviate dopo una chiamata a bluetoothLowEnergy.readCharacteristicValue. In questo modo le app per unificare il flusso di controllo di un aggiornamento del valore attivato tramite una richiesta di lettura e notifiche:
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.
});
});
Se una caratteristica supporta le notifiche, il campo properties conterrà
"notify" o "indicate".
NOTA: se una caratteristica supporta notifiche/indicazioni, avrà il campo Configurazione caratteristica" descrittore per attivare/disattivare le notifiche. Chrome non consente app per scrivere in questo descrittore. Le app devono invece usare bluetoothLowEnergy.startCharacteristicNotifications e bluetoothLowEnergy.stopCharacteristicNotifications per controllare il comportamento delle notifiche.