Ten dokument opisuje, jak używać Bluetooth, gniazda Bluetooth i Bluetooth Low Interfejsy API Energy do komunikacji z urządzeniami Bluetooth i Bluetooth Low Energy.
Podstawowe informacje o Bluetooth znajdziesz w oficjalnych specyfikacjach Bluetootha.
Wymagania dotyczące pliku manifestu
W przypadku aplikacji Chrome, które używają Bluetootha, dodaj do pliku manifestu wpis Bluetooth i określ, jeśli identyfikatory UUID profili, protokołów lub usług, które chcesz wdrożyć, oraz które chcesz wdrożyć za pomocą interfejsów API Socket lub Low Energy.
Przykład dla implementacji za pomocą gniazda:
"bluetooth": {
"uuids": [ "1105", "1106" ],
"socket": true
}
Jeśli chcesz korzystać z małego zużycia energii:
"bluetooth": {
"uuids": [ "180D", "1809", "180F" ],
"low_energy": true
}
Aby uzyskiwać dostęp tylko do stanu adaptera, wykrywać urządzenia w pobliżu i uzyskiwać podstawowe informacje o urządzeniach: wymagany jest tylko sam wpis:
"bluetooth": {}
Informacje o karcie
Uzyskiwanie stanu adaptera
Aby uzyskać stan adaptera Bluetooth, użyj metody bluetooth.getAdapterState:
chrome.bluetooth.getAdapterState(function(adapter) {
console.log("Adapter " + adapter.address + ": " + adapter.name);
});
Powiadomienia dotyczące karty
Zdarzenie bluetooth.onAdapterStateChanged jest wysyłane za każdym razem, gdy zmienia się stan adaptera. Może to spowodować służy na przykład do określania, kiedy adapter radiowy jest włączony, a kiedy wyłączony.
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");
}
}
});
Informacje o urządzeniu
Wyświetlanie listy znanych urządzeń
Aby zobaczyć listę urządzeń znanych z adaptera Bluetootha, użyj polecenia bluetooth.getDevices :
chrome.bluetooth.getDevices(function(devices) {
for (var i = 0; i < devices.length; i++) {
console.log(devices[i].address);
}
});
Zwrócone zostaną wszystkie urządzenia, w tym te sparowane i niedawno wykryte. Nie rozpocząć wykrywanie nowych urządzeń (patrz Wykrywanie urządzeń w pobliżu).
Otrzymywanie powiadomień na urządzeniu
Zamiast wielokrotnie wywoływać funkcję bluetooth.getDevices, możesz używać bluetooth.onDeviceAdded, bluetooth.onDeviceChanged i bluetooth.onDeviceRemoved wydarzenia, aby otrzymywać powiadomienia.
Zdarzenie bluetooth.onDeviceAdded jest wysyłane za każdym razem, gdy urządzenie zostanie wykryte przez adapter lub nawiązuje połączenie z adapterem:
chrome.bluetooth.onDeviceAdded.addListener(function(device) {
console.log(device.address);
});
Dodanie detektora tego zdarzenia nie rozpocznie wykrywania urządzeń (patrz Wykrywanie w pobliżu urządzenia).
Zmiany w urządzeniach, w tym wcześniej wykryte urządzenia będące sparowanymi, są powiadamiane przez Zdarzenie bluetooth.onDeviceChanged:
chrome.bluetooth.onDeviceChanged.addListener(function(device) {
console.log(device.address);
});
Zdarzenie bluetooth.onDeviceRemoved jest wysyłane za każdym razem, gdy sparowane urządzenie zostanie usunięte z systemu lub wykryte urządzenie nie było ostatnio wykrywane:
chrome.bluetooth.onDeviceRemoved.addListener(function(device) {
console.log(device.address);
});
Wykrywanie urządzeń w pobliżu
Aby rozpocząć wykrywanie urządzeń w pobliżu, użyj metody bluetooth.startDiscovery. Odkrywanie może wymaga wielu zasobów, więc po ich zakończeniu użyj wywołania bluetooth.stopDiscovery.
Wywołuj funkcję bluetooth.startDiscovery za każdym razem, gdy aplikacja chce wykryć urządzenia w pobliżu.
Nie traktuj wywołania jako warunkowego we właściwości discovering bluetooth.AdapterState.
uda się przeprowadzić wywołanie, nawet jeśli inna aplikacja wykryje urządzenia w pobliżu i zapewni,
nadal wykrywa treści po zatrzymaniu tej innej aplikacji.
Informacje o każdym nowo wykrytych urządzeniach są odbierane za pomocą parametru bluetooth.onDeviceAdded. . Dotyczy urządzeń, które zostały niedawno wykryte lub zostały wcześniej sparowane lub połączone, wydarzenie nie zostanie wysłane. Zamiast tego wywołaj bluetooth.getDevices, aby uzyskać aktualne informacje i użyć zdarzenia bluetooth.onDeviceChanged, aby otrzymywać powiadomienia o zmian w tych informacjach w wyniku ich wykrycia.
Przykład:
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);
});
Jeśli użytkownik wyłączy radio Bluetooth, wszystkie sesje wykrywania zostaną zakończone i nie zostaną wznowione
automatycznie po włączeniu radia. Jeśli ma to znaczenie dla Twojej aplikacji, obejrzyj
Zdarzenie bluetooth.onAdapterStateChanged. Jeśli właściwość discovering zmieni się na false,
Aby wznowić, aplikacja będzie musiała ponownie wywołać funkcję bluetooth.startDiscovery. Uważaj na
niewymagających zasobów.
Identyfikowanie urządzeń
Dostępnych jest wiele różnych opcji identyfikacji urządzeń zwracanych przez bluetooth.getDevices i powiązane zdarzenia.
Jeśli urządzenie obsługuje specyfikację identyfikatora urządzenia Bluetooth, do aplikacji zostanie dodanych kilka właściwości Obiekt urządzenia zawierający pola zdefiniowane w tej specyfikacji. Przykład:
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));
}
}
});
Do identyfikacji konkretnego modelu, a nawet jego wersji, wystarcza zwykle specyfikacja identyfikatora urządzenia.
urządzenia od dostawcy. Jeśli nie są one podane, należy polegać na informacjach na temat
klasa lub typ urządzenia, opcjonalnie połączone z prefiksem producenta w atrybucie address.
Większość urządzeń Bluetooth podaje informacje o klasie urządzeń w postaci pola bitowego interpretowanego zgodnie z
dokument Baseband Assigned Numbers (Przypisane numery pasma bazowego). To pole bitowe jest dostępne w: deviceClass
usłudze.
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));
}
}
});
Analiza tego pola może być skomplikowana, więc na najpopularniejszych typach urządzeń Chrome robi to za Ciebie,
ustawia pole type. Jeśli ta funkcja nie jest dostępna lub nie odpowiada Twoim potrzebom, musisz
samodzielnie przeanalizuj deviceClass.
chrome.bluetooth.getDevices(function(devices) {
for (var i = 0; i < devices.length; i++) {
if (devices[0].vendorIdSource != undefined) {
console.log(devices[0].address + ' = ' + devices[0].type);
}
}
});
Korzystanie z RFCOMM i L2CAP
Aplikacje Chrome mogą nawiązywać połączenia z dowolnym urządzeniem obsługującym usługi RFCOMM lub L2CAP. Obejmuje to m.in. z większością klasycznych urządzeń Bluetooth dostępnych na rynku.
Podłączanie gniazdka
Aby połączyć się z urządzeniem, potrzebujesz trzech rzeczy. Gniazdo do nawiązywania połączenia z, utworzony za pomocą bluetoothSocket.create; adres urządzenia, z którym chcesz się połączyć; oraz identyfikator UUID samej usługi.
Przed nawiązaniem połączenia upewnij się, że ładowarka zna urządzenie, korzystając z bluetooth.getDevice lub interfejsy API do wykrywania urządzeń.
Informacje niezbędne do nawiązania bazowego połączenia, w tym informacje o tym, czy RFCOMM czy Należy stosować protokół L2CAP oraz określić, który kanał lub PSM jest uzyskiwany za pomocą wykrywania SDP urządzenia.
Przykład:
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);
});
Trzymaj uchwyt socketId, aby móc później wysyłać do niego dane (bluetoothSocket.send) gniazda elektrycznego.
Odbieranie i wysyłanie z gniazda
Do odbierania i wysyłania danych z gniazda są używane obiekty ArrayBuffer. Aby dowiedzieć się więcej o obiekcie ArrayBuffers,
zapoznaj się z omówieniem, tablicami z JavaScriptem i samouczkiem How to conversion TrackBuffer.
do i z ciągu znaków.
Aby wysłać dane, które posiadasz w arrayBuffer, użyj 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")
}
})
W przeciwieństwie do metody wysyłania danych dane są odbierane w zdarzeniu. (bluetoothSocket.onReceive. Gniazdka są tworzone bez wstrzymania (patrz bluetoothSocket.setPaused). więc odbiornik tego zdarzenia jest zwykle dodawany między bluetoothSocket.create i bluetoothSocket.connect
chrome.bluetoothSocket.onRecieve.addListener(function(receiveInfo) {
if (receiveInfo.socketId != socketId)
return;
// receiveInfo.data is an ArrayBuffer.
});
Otrzymuje błędy gniazda i odłączenie
Aby otrzymywać powiadomienia o błędach gniazda, w tym o rozłączeniu, dodaj detektor do Zdarzenie bluetoothSocket.onReceiveError.
chrome.bluetoothSocket.onReceiveError.addListener(function(errorInfo) {
// Cause is in errorInfo.error.
console.log(errorInfo.errorMessage);
});
Odłączanie od gniazdka
Aby rozłączyć połączenie i odłączyć gniazdko, użyj polecenia bluetoothSocket.disconnect.
chrome.bluetoothSocket.disconnect(socketId);
Usługi wydawnicze
Oprócz nawiązywania połączeń wychodzących z urządzeniami Aplikacje Chrome mogą publikować usługi, które mogą być na dowolnym urządzeniu obsługującym RFCOMM lub L2CAP.
Słuchanie w gniazdku
Obsługiwane są 2 typy opublikowanej usługi. RFCOMM jest najczęściej używany i obejmuje większość urządzeń i profili:
var uuid = '1105';
chrome.bluetoothSocket.create(function(createInfo) {
chrome.bluetoothSocket.listenUsingRfcomm(createInfo.socketId,
uuid, onListenCallback);
});
Druga kategoria to L2CAP, która obejmuje inne typy urządzeń oraz zastosowania specyficzne dla danego dostawcy, takie jak oprogramowanie układowe. przesyłanie.
var uuid = '0b87367c-f188-47cd-bc20-a5f4f70973c6';
chrome.bluetoothSocket.create(function(createInfo) {
chrome.bluetoothSocket.listenUsingL2cap(createInfo.socketId,
uuid, onListenCallback);
});
W obu przypadkach można przekazać opcjonalny parametr bluetoothSocket.ListenOptions, aby przydzielić określony
lub PSM. Wywołanie zwrotne wskazuje błąd poprzez chrome.runtime.lastError i powodzenie
w przeciwnym razie. Zachowaj uchwyt socketId, aby móc później akceptować połączenia
(bluetoothSocket.onAccept) z tego gniazda.
Akceptowanie połączeń z klientem
Połączenia klientów są akceptowane i przekazywane do aplikacji za pomocą Zdarzenie 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);
});
Przestań akceptować połączenia z klientami
Aby przestać akceptować połączenia z klientem i cofnąć publikację usługi, użyj polecenia bluetoothSocket.disconnect.
chrome.bluetoothSocket.disconnect(serverSocketId);
Interakcja z urządzeniami o niskiej energii
Bluetooth Low Energy lub (Bluetooth Smart) to technologia bezprzewodowa ukierunkowana na mniejszą moc. konsumpcją treści. Interfejs API Bluetooth Low Energy pozwala aplikacjom realizować główną rolę przez połączenie LE z urządzeniem peryferyjnym. W poniższych sekcjach dowiesz się, jak odkrywać, nawiązywać kontakty i nawiązywać kontakt współdziałają z urządzeniami peryferyjnymi Bluetooth Low Energy.
Wykrywanie urządzeń peryferyjnych i łączenie się z nimi
Podobnie jak w przypadku tradycyjnych urządzeń Bluetooth, urządzenia peryferyjne LE można wykryć za pomocą opisanych metod.
w artykule Wykrywanie urządzeń w pobliżu . Urządzenie LE staje się wykrywalne przez wysyłanie pakietów danych
„Dane reklamowe” a urządzenie ma włączony tryb reklamowy. Dane reklamowe
może zawierać identyfikatory UUID usług dostępnych na urządzeniu. Jeśli identyfikatory UUID są obecne,
jest dostępna przy użyciu właściwości uuids odpowiedniego obiektu bluetooth.Device.
Z wykrytym urządzeniem LE można się połączyć, wywołując bluetoothLowEnergy.connect. że aplikacja może wchodzić w interakcje ze swoimi usługami:
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...
...
});
});
Po nawiązaniu połączenia właściwość connected odpowiedniego obiektu bluetooth.Device zostanie
mają wartość true. Wywołanie bluetoothLowEnergy.connect powoduje zgłoszenie roszczenia przez
jest dostępna na fizycznym połączeniu z urządzeniem. Może istnieć fizyczne połączenie z urządzeniem
bez wywoływania funkcji bluetoothLowEnergy.connect (na przykład z powodu innej aplikacji). W
w tym przypadku, chociaż aplikacja może nadal korzystać z usług urządzenia, powinna
zawsze wywołaj bluetoothLowEnergy.connect, aby inna aplikacja nie mogła odłączyć
fizyczny link.
Gdy aplikacja nie będzie już połączona, może usunąć rezerwację połączenia przez Wywołuję bluetoothLowEnergy.disconnect:
chrome.bluetoothLowEnergy.disconnect(deviceAddress);
Pamiętaj, że nie musi to spowodować zniszczenia fizycznego linku do urządzenia, bo mogą istnieć inne w aplikacjach, które mają aktywne połączenia z urządzeniem. Czasami urządzenie może stać się zostało odłączone z powodów, które są poza kontrolą aplikacji (np. jeśli urządzenie znika lub zostaje bezpośrednio odłączony przez użytkownika za pomocą narzędzi systemu operacyjnego). Aby otrzymywać powiadomienia o zmianach, aplikacja powinna obserwować zdarzenie bluetooth.onDeviceChanged w przeglądarce i w razie potrzeby połączyć się ponownie.
Po nawiązaniu połączenia urządzenie z Chrome będzie miało tzw. rolę centralną, a urządzenie zdalne jest nazywane urządzeniem peryferyjnym. W tym momencie aplikacja może wchodzić w interakcję z usługami na urządzeniu przy użyciu metod opisanych w następnej sekcji. Uwaga: atrybut Interfejsy API nie obsługują obecnie działania jako urządzenia peryferyjnego LE. aplikacje mogą natomiast obsługiwać tylko główną rolę.
Usługi, cechy i deskryptory
Bluetooth Low Energy działa w oparciu o prosty protokół odpowiedzi żądania nazywany protokołem atrybutów (ATT). Dzięki ATT urządzenie centralne wchodzi w interakcję z tak zwanymi atrybutami na urządzeniu peryferyjnym. tworząc specjalny profil Bluetooth nazywany profilem atrybutów ogólnych (GATT). GATT, definiuje te ogólne koncepcje:
- Usługa: usługa GATT reprezentuje zbieranie danych i powiązanych z nimi zachowań w celu realizacji dla konkretnej funkcji urządzenia. Na przykład pulsometr ma zazwyczaj co najmniej jedną "usługę pomiaru tętna". Informacje o usłudze GATT znajdują się w obiekt bluetoothLowEnergy.Service.
- Cecha: charakterystyka GATT to podstawowy element danych używany do konstruowania usługi GATT. zawiera wartość wraz z właściwościami, które określają sposób uzyskania dostępu do tej wartości. Przykład: "usługi pomiaru tętna" ma „Pomiar tętna” , która służy do uzyskania wartość tętna użytkownika. Informacje o cechy GATT znajdują się w Obiekt bluetoothLowEnergy.Characteristic.
- Opis: deskryptor cechy GATT zawiera dodatkowe informacje na temat cechy. Informacje o deskryptorze cechy GATT znajdują się w Obiekt bluetoothLowEnergy.Descriptor.
Interfejs API Bluetooth Low Energy umożliwia aplikacjom znajdowanie informacji na temat
usług, charakterystyki i deskryptorów, wywołując bluetoothLowEnergy.getServices,
bluetoothLowEnergy.getCharacteristics i bluetoothLowEnergy.getDescriptors. Aplikacje mogą
filtrować usługi, cechy i deskryptory, porównując ich pole uuid z
wybrany identyfikator UUID GATT:
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;
}
}
...
});
Do każdej usługi, cechy i deskryptora dostępnego za pośrednictwem interfejsu API zostaje przypisany
identyfikatora instancji, który można uzyskać za pomocą pola instanceId. Takim identyfikatorem instancji może być
służą do identyfikowania obiektu GATT i wykonywania na nim konkretnych operacji:
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) {
...
});
});
Zdarzenia usługi
Gdy urządzenie się połączy, Chrome wykryje swoje usługi. Przy wykrywaniu każdej usługi aplikacja zostanie usunięta, aplikacja otrzyma parametr bluetoothLowEnergy.onServiceAdded i Zdarzenia 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 asynchronicznie wykrywa wszystkie cechy i deskryptory usługi oraz wysyła zdarzenie bluetoothLowEnergy.onServiceAdded po zakończeniu wykrywania. Jeśli połączenie z urządzenie peryferyjne, zostanie usunięte, Chrome usunie wszystkie powiązane usługi i wyśle Zdarzenie bluetoothLowEnergy.onServiceRemoved.
Niektóre urządzenia peryferyjne mogą modyfikować swoje usługi, np. charakterystyka usługi może ulec zmianie lub mogą zostać dodane i całkowicie usunięte. Chrome powiadamia aplikacje o tych zmianach za pomocą bluetoothLowEnergy.onServiceChanged, bluetoothLowEnergy.onServiceAdded i Zdarzenia bluetoothLowEnergy.onServiceRemoved.
chrome.bluetoothLowEnergy.onServiceChanged.addListener(function(service) {
if (service.instanceId != myService.instanceId)
return;
updateMyService(service);
});
Odczytywanie i zapisywanie wartości cechy
Cecha GATT koduje jeden aspekt swojej usługi. Centralna aplikacja odczytuje, modyfikuje i podejmuje działania stan usługi urządzenia peryferyjnego na podstawie wartości cechy. Cecha jest ciągiem bajtów, a jej znaczenie jest określone przez specyfikację wysokiego poziomu, która definiuje do określonej cechy. Na przykład wartość właściwości Pomiar tętna koduje tętno użytkownika i łączną liczbę spalonych kalorii, a czujnik na ciele Parametr lokalizacji wskazuje, gdzie w ciele należy nosić czujnik tętna.
Chrome udostępnia metodę bluetoothLowEnergy.readCharacteristicValue, aby odczytywać wartość charakterystyczna:
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.
...
});
Niektóre cechy można zapisać, zwłaszcza te występujące jako „punkty kontrolne”, gdzie pisanie ma skutki uboczne. Na przykład cecha Punkt kontroli tętna jest używana do poproś czujnika tętna o zresetowanie łącznej liczby spalonych kalorii i obsługę tylko zapisów. Do aby to osiągnąć, Chrome udostępnia metodę 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.
});
Deskryptory charakterystyczne działają w ten sam sposób i mogą być czytelne i do zapisu. Chrome zapewnia: bluetoothLowEnergy.readDescriptorValue i bluetoothLowEnergy.writeDescriptorValue do odczytywania i zapisywania wartości deskryptora.
Aby sprawdzić, czy dana cecha obsługuje odczyty lub zapisy, aplikacja może sprawdzić properties
obiektu bluetoothLowEnergy.Characteristic. To pole nie zawiera
informacji o wymaganiach w zakresie bezpieczeństwa potrzebnych do uzyskania dostępu do wartości, wskazuje, która wartość
obsługuje ogólnie cechę.
Obsługa powiadomień o wartościach
Niektóre cechy określają ich wartość za pomocą powiadomień lub wskazówek. Na przykład plik Cecha pomiaru tętna jest nieczytelna ani możliwa do zapisu, ale wysyła aktualizacje na w regularnych odstępach czasu. Aplikacje mogą odsłuchiwać te powiadomienia za pomocą Zdarzenie bluetoothLowEnergy.onCharacteristicValueChanged.
chrome.bluetoothLowEnergy.onCharacteristicValueChanged.addListener(
function(chrc) {
if (chrc.instanceId != myCharId)
return;
var bytes = new Uint8Array(chrc.value);
// Do stuff with the bytes.
...
});
Nawet jeśli dana cecha obsługuje powiadomienia lub wskazówki, nie są one domyślnie włączone. An aplikacja powinna wywoływać metody bluetoothLowEnergy.startCharacteristicNotifications i metod bluetoothLowEnergy.stopCharacteristicNotifications, aby włączyć lub wyłączyć otrzymywanie Zdarzenie 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);
}
Po uruchomieniu powiadomień aplikacja otrzyma bluetoothLowEnergy.onCharacteristicValueChanged, za każdym razem, gdy pojawi się powiadomienie lub wskazanie. otrzymywane z cechy. Jeśli cecha obsługuje odczyty, zdarzenie to również jest wysłane po udanym wywołaniu bluetoothLowEnergy.readCharacteristicValue. Zezwala to aplikacjom aby ujednolicić przepływ kontroli aktualizacji wartości aktywowanej za pomocą żądania odczytu i powiadomień:
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.
});
});
Jeśli cecha obsługuje powiadomienia, jej pole properties będzie zawierać albo
Usługa "notify" lub "indicate".
UWAGA: jeśli cecha obsługuje powiadomienia/wskazania, będzie miała Konfiguracja cechy” deskryptor do włączania/wyłączania powiadomień. Przeglądarka Chrome nie zezwala do zapisywania w tym deskryptorach. Aplikacje powinny zamiast tego używać bluetoothLowEnergy.startCharacteristicNotifications i metody bluetoothLowEnergy.stopCharacteristicNotifications do sterowania zachowaniem powiadomień.