เอกสารนี้จะอธิบายวิธีใช้บลูทูธ ซ็อกเก็ตบลูทูธ และบลูทูธต่ำ Energy API สำหรับสื่อสารกับอุปกรณ์บลูทูธและบลูทูธพลังงานต่ำ
สำหรับข้อมูลเบื้องต้นเกี่ยวกับบลูทูธ โปรดดูข้อมูลจำเพาะของบลูทูธอย่างเป็นทางการ
ข้อกำหนดของไฟล์ Manifest
สำหรับแอป Chrome ที่ใช้บลูทูธ ให้เพิ่มรายการบลูทูธลงในไฟล์ Manifest และระบุว่า UUID ของโปรไฟล์ โปรโตคอล หรือบริการที่คุณต้องการนำไปใช้ควบคู่กับ คุณต้องการใช้ API เหล่านี้กับ Socket และ/หรือ API แบบพลังงานต่ำ
ตัวอย่างเช่น การใช้งานซ็อกเก็ต
"bluetooth": {
"uuids": [ "1105", "1106" ],
"socket": true
}
และสำหรับการติดตั้งใช้งานพลังงานต่ำ
"bluetooth": {
"uuids": [ "180D", "1809", "180F" ],
"low_energy": true
}
หากต้องการเข้าถึงเฉพาะสถานะอะแดปเตอร์ ค้นหาอุปกรณ์ที่อยู่ใกล้เคียง และรับข้อมูลพื้นฐานเกี่ยวกับอุปกรณ์ รายการที่จำเป็นมีดังนี้
"bluetooth": {}
ข้อมูลอะแดปเตอร์
กำลังรับสถานะอะแดปเตอร์
หากต้องการดูสถานะของอะแดปเตอร์บลูทูธ ให้ใช้เมธอด bluetooth.getAdapterState ดังนี้
chrome.bluetooth.getAdapterState(function(adapter) {
console.log("Adapter " + adapter.address + ": " + adapter.name);
});
การแจ้งเตือนเกี่ยวกับอะแดปเตอร์
ระบบจะส่งเหตุการณ์ bluetooth.onAdapterStateChanged ทุกครั้งที่สถานะของอะแดปเตอร์เปลี่ยนแปลง วิธีนี้ เช่น เพื่อระบุว่าจะเปิดหรือปิดวิทยุของอะแดปเตอร์เมื่อใด
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");
}
}
});
ข้อมูลอุปกรณ์
แสดงรายการอุปกรณ์ที่รู้จัก
หากต้องการดูรายการอุปกรณ์ที่อะแดปเตอร์บลูทูธรู้จัก ให้ใช้ bluetooth.getDevices วิธีการ:
chrome.bluetooth.getDevices(function(devices) {
for (var i = 0; i < devices.length; i++) {
console.log(devices[i].address);
}
});
ส่งคืนอุปกรณ์ทั้งหมด รวมถึงอุปกรณ์ที่จับคู่แล้วและเพิ่งค้นพบเมื่อเร็วๆ นี้ จะไม่เป็น เริ่มการค้นหาอุปกรณ์ใหม่ๆ (ดูการค้นพบอุปกรณ์ที่อยู่ใกล้เคียง)
การรับการแจ้งเตือนของอุปกรณ์
แทนที่จะเรียก bluetooth.getDevices ซ้ำๆ คุณสามารถใช้ bluetooth.onDeviceAdded, bluetooth.onDeviceChanged และ bluetooth.onDeviceRemoved กิจกรรมเพื่อรับการแจ้งเตือน
ระบบจะส่งเหตุการณ์ bluetooth.onDeviceAdded เมื่ออะแดปเตอร์ตรวจพบอุปกรณ์ หรือ ทำการเชื่อมต่อกับอะแดปเตอร์:
chrome.bluetooth.onDeviceAdded.addListener(function(device) {
console.log(device.address);
});
การเพิ่ม Listener สำหรับกิจกรรมนี้ไม่ได้เป็นการเริ่มการค้นพบอุปกรณ์ (ดูการค้นพบในบริเวณใกล้เคียง อุปกรณ์)
การเปลี่ยนแปลงในอุปกรณ์ รวมถึงอุปกรณ์ที่ค้นพบก่อนหน้านี้ซึ่งถูกจับคู่แล้ว จะได้รับการแจ้งเตือนโดย เหตุการณ์ bluetooth.onDeviceChanged:
chrome.bluetooth.onDeviceChanged.addListener(function(device) {
console.log(device.address);
});
สุดท้าย ระบบจะส่งเหตุการณ์ bluetooth.onDeviceRemoved เมื่อมีการนำอุปกรณ์ที่จับคู่ออก ระบบหรืออุปกรณ์ที่ค้นพบไม่พบเมื่อเร็วๆ นี้:
chrome.bluetooth.onDeviceRemoved.addListener(function(device) {
console.log(device.address);
});
กำลังค้นหาอุปกรณ์ที่อยู่ใกล้เคียง
หากต้องการเริ่มค้นหาอุปกรณ์ที่อยู่ใกล้เคียง ให้ใช้เมธอด bluetooth.startDiscovery Discovery สามารถ ต้องใช้ทรัพยากรอย่างเข้มงวด คุณควรเรียกใช้ bluetooth.stopDiscovery เมื่อเสร็จสิ้น
คุณควรเรียกใช้ bluetooth.startDiscovery ทุกครั้งที่แอปจำเป็นต้องค้นหาอุปกรณ์ที่อยู่ใกล้เคียง
อย่าทำให้การเรียกใช้มีเงื่อนไขในพร็อพเพอร์ตี้ discovering ของ bluetooth.AdapterState
จะสำเร็จลุล่วงได้แม้ว่าแอปอื่นจะค้นหาอุปกรณ์ที่อยู่ใกล้เคียง และจะทำให้อะแดปเตอร์
ยังคงทำการค้นพบต่อไปหลังจากที่แอปอื่นหยุดทำงาน
จะได้รับข้อมูลเกี่ยวกับอุปกรณ์ที่เพิ่งค้นพบใหม่ผ่านทาง bluetooth.onDeviceAdded กิจกรรม สำหรับอุปกรณ์ที่พบเมื่อเร็วๆ นี้หรือเคยจับคู่กับ หรือเชื่อมต่ออยู่ เหตุการณ์ก็จะไม่ถูกส่งไป คุณควรเรียก bluetooth.getDevices เพื่อ รับข้อมูลปัจจุบัน และใช้เหตุการณ์ bluetooth.onDeviceChanged เพื่อรับการแจ้งเตือน การเปลี่ยนแปลงของข้อมูลดังกล่าวอันเป็นผลมาจากการค้นพบ
ตัวอย่าง
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);
});
หากผู้ใช้ปิดวิทยุบลูทูธ เซสชันการค้นพบทั้งหมดจะสิ้นสุดลงและจะไม่กลับมาทำงานอีกครั้ง
โดยอัตโนมัติเมื่อเปิดวิทยุ หากเรื่องนี้สำคัญต่อแอปของคุณ คุณควรดู
bluetooth.onAdapterStateChanged หากพร็อพเพอร์ตี้ discovering เปลี่ยนเป็น false
แอปของคุณจะต้องเรียกใช้ bluetooth.startDiscovery อีกครั้งเพื่อกลับมาใช้งานต่อ โปรดระมัดระวัง
ในการค้นพบอย่างแท้จริง
การระบุอุปกรณ์
มีตัวเลือกต่างๆ มากมายสำหรับการระบุอุปกรณ์ที่ส่งคืนโดย bluetooth.getDevices และเหตุการณ์ที่เกี่ยวข้อง
หากอุปกรณ์รองรับข้อกำหนดรหัสอุปกรณ์บลูทูธ จะมีการเพิ่มคุณสมบัติหลายรายการลงใน ออบเจ็กต์อุปกรณ์ที่มีช่องซึ่งกำหนดโดยข้อกำหนดนั้นๆ ตัวอย่าง
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));
}
}
});
โดยทั่วไปแล้ว ข้อกำหนดเฉพาะเกี่ยวกับรหัสอุปกรณ์ก็เพียงพอที่จะระบุรุ่นที่เจาะจง และแม้แต่การแก้ไข
อุปกรณ์จากผู้ให้บริการ แต่หากไม่มีข้อมูลดังกล่าว คุณต้องอาศัยข้อมูลเกี่ยวกับ
คลาสหรือประเภทอุปกรณ์ โดยจะรวมกับคำนำหน้าของผู้ผลิตใน address หรือไม่ก็ได้
อุปกรณ์บลูทูธส่วนใหญ่จะให้ข้อมูลคลาสของอุปกรณ์เป็นช่องบิตที่แปลค่าตาม
เอกสารหมายเลขที่มอบหมายของเบสแบนด์ ช่องบิตนี้มีอยู่ใน 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));
}
}
});
การแยกวิเคราะห์ช่องข้อมูลอาจซับซ้อน ดังนั้นสำหรับประเภทอุปกรณ์ที่พบบ่อยที่สุดที่ Chrome จะจัดการให้คุณ
ตั้งค่าฟิลด์ type ในกรณีที่รายการนี้ไม่มีให้บริการ หรือไม่เพียงพอสำหรับความต้องการของคุณ คุณจะต้อง
แยกวิเคราะห์ 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);
}
}
});
การใช้ RFCOMM และ L2CAP
แอป Chrome อาจเชื่อมต่อกับอุปกรณ์ใดๆ ที่รองรับบริการ RFCOMM หรือ L2CAP ซึ่งรวมถึง อุปกรณ์บลูทูธคลาสสิกส่วนใหญ่ในตลาด
กำลังเชื่อมต่อกับซ็อกเก็ต
หากต้องการเชื่อมต่อกับอุปกรณ์ คุณต้องมี 3 สิ่ง เต้ารับสำหรับเชื่อมต่อ ด้วย ซึ่งสร้างขึ้นโดยใช้ bluetoothSocket.create ที่อยู่ของอุปกรณ์ที่ต้องการเชื่อมต่อ และ UUID ของบริการเอง
ก่อนทำการเชื่อมต่อ คุณควรยืนยันว่าอะแดปเตอร์รู้จักอุปกรณ์โดยใช้ bluetooth.getDevice หรือ API การค้นพบอุปกรณ์
ข้อมูลที่จำเป็นในการสร้างการเชื่อมต่อพื้นฐาน รวมถึงว่า RFCOMM หรือ ควรใช้โปรโตคอล L2CAP และแชแนลหรือ PSM ที่ได้มาโดยใช้การค้นพบ SDP ใน อุปกรณ์
ตัวอย่าง
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);
});
เก็บแฮนเดิลกับ socketId ไว้เพื่อให้สามารถส่งข้อมูล (bluetoothSocket.send) มาที่แท็กนี้ในภายหลัง Socket
การรับจากและส่งไปยังซ็อกเก็ต
การรับข้อมูลจากและส่งไปยังซ็อกเก็ตใช้ออบเจ็กต์ ArrayBuffer หากต้องการเรียนรู้เกี่ยวกับ ArrayBuffers
ดูภาพรวม อาร์เรย์ประเภท JavaScript และบทแนะนำ วิธีแปลง ArrayBuffer
to and from String (สตริง)
หากต้องการส่งข้อมูลที่คุณมีใน arrayBuffer ให้ใช้ bluetoothSocket.send โดยทำดังนี้
chrome.bluetoothSocket.send(socketId, arrayBuffer, function(bytes_sent) {
if (chrome.runtime.lastError) {
console.log("Send failed: " + chrome.runtime.lastError.message);
} else {
console.log("Sent " + bytes_sent + " bytes")
}
})
ข้อมูลจะได้รับในเหตุการณ์ ซึ่งตรงข้ามกับวิธีส่งข้อมูล (bluetoothSocket.onReceive. ซ็อกเก็ตถูกสร้างขึ้นโดยยกเลิกการหยุดชั่วคราว (ดู bluetoothSocket.setPaused) ดังนั้นโดยทั่วไป Listener สำหรับเหตุการณ์นี้มักจะเพิ่มระหว่าง bluetoothSocket.create และ bluetoothSocket.connect
chrome.bluetoothSocket.onRecieve.addListener(function(receiveInfo) {
if (receiveInfo.socketId != socketId)
return;
// receiveInfo.data is an ArrayBuffer.
});
การได้รับข้อผิดพลาดและการยกเลิกการเชื่อมต่อของซ็อกเก็ต
หากต้องการรับการแจ้งเตือนข้อผิดพลาดด้านซ็อกเก็ต รวมถึงการยกเลิกการเชื่อมต่อ ให้เพิ่ม Listener ลงใน เหตุการณ์ bluetoothSocket.onReceiveError
chrome.bluetoothSocket.onReceiveError.addListener(function(errorInfo) {
// Cause is in errorInfo.error.
console.log(errorInfo.errorMessage);
});
กำลังยกเลิกการเชื่อมต่อกับเต้ารับ
หากต้องการวางสายการเชื่อมต่อและยกเลิกการเชื่อมต่อเต้ารับ ให้ใช้ bluetoothSocket.disconnect
chrome.bluetoothSocket.disconnect(socketId);
บริการเผยแพร่
นอกเหนือจากการเชื่อมต่อขาออกกับอุปกรณ์แล้ว แอป Chrome ยังอาจเผยแพร่บริการที่ ใช้โดยอุปกรณ์ที่รองรับ RFCOMM หรือ L2CAP
ฟังเพลงผ่านซ็อกเก็ต
บริการที่เผยแพร่มี 2 ประเภทที่รองรับ RFCOMM เป็นวิธีที่นิยมใช้มากที่สุดและครอบคลุม อุปกรณ์และโปรไฟล์ส่วนใหญ่ ได้แก่
var uuid = '1105';
chrome.bluetoothSocket.create(function(createInfo) {
chrome.bluetoothSocket.listenUsingRfcomm(createInfo.socketId,
uuid, onListenCallback);
});
L2CAP คืออีกประเภทหนึ่งและครอบคลุมประเภทอุปกรณ์อื่นๆ และการใช้งานเฉพาะผู้ให้บริการ เช่น เฟิร์มแวร์ กำลังอัปโหลด
var uuid = '0b87367c-f188-47cd-bc20-a5f4f70973c6';
chrome.bluetoothSocket.create(function(createInfo) {
chrome.bluetoothSocket.listenUsingL2cap(createInfo.socketId,
uuid, onListenCallback);
});
ในทั้ง 2 กรณี ระบบอาจส่ง bluetoothSocket.ListenOptions เพื่อจัดสรร
ช่องหรือ PSM การติดต่อกลับระบุข้อผิดพลาดผ่าน chrome.runtime.lastError และสำเร็จ
หรือไม่เช่นนั้น เก็บแฮนเดิลกับ socketId เพื่อให้คุณยอมรับการเชื่อมต่อในภายหลังได้
(bluetoothSocket.onAccept) จากซ็อกเก็ตนี้
การยอมรับการเชื่อมต่อกับไคลเอ็นต์
การเชื่อมต่อไคลเอ็นต์จะได้รับการยอมรับและส่งไปยังใบสมัครของคุณผ่าน 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);
});
หยุดการยอมรับการเชื่อมต่อไคลเอ็นต์
หากต้องการหยุดยอมรับการเชื่อมต่อไคลเอ็นต์และยกเลิกการเผยแพร่บริการ ให้ใช้ bluetoothSocket.disconnect
chrome.bluetoothSocket.disconnect(serverSocketId);
การโต้ตอบกับอุปกรณ์พลังงานต่ำ
บลูทูธพลังงานต่ำหรือ (บลูทูธอัจฉริยะ) เป็นเทคโนโลยีไร้สายที่มุ่งลดพลังงาน การบริโภค API บลูทูธพลังงานต่ำช่วยให้แอปพลิเคชันใช้บทบาทหลักใน การเชื่อมต่อ LE กับอุปกรณ์ต่อพ่วง ส่วนต่อไปนี้จะอธิบายวิธีค้นหา เชื่อมต่อ และ โต้ตอบกับอุปกรณ์ต่อพ่วงบลูทูธพลังงานต่ำ
การค้นหาและการเชื่อมต่อกับอุปกรณ์ต่อพ่วง
โดยจะค้นพบอุปกรณ์ต่อพ่วง LE โดยใช้วิธีการที่อธิบายไว้ เช่นเดียวกับอุปกรณ์บลูทูธทั่วไป
ในการค้นพบอุปกรณ์ที่อยู่ใกล้เคียง อุปกรณ์ LE ทำให้ค้นพบได้โดยการส่งแพ็กเก็ตข้อมูล
ที่เรียกว่า "ข้อมูลการโฆษณา" และอุปกรณ์อยู่ในโหมดโฆษณา ข้อมูลการโฆษณา
อาจมี UUID ของบริการที่พร้อมใช้งานในอุปกรณ์ หากมี UUID เหล่านี้จะ
เข้าถึงได้โดยใช้พร็อพเพอร์ตี้ uuids ของออบเจ็กต์ bluetooth.Device ที่เกี่ยวข้อง
เมื่อค้นพบแล้ว คุณสามารถเชื่อมต่ออุปกรณ์ LE ได้โดยเรียกใช้ bluetoothLowEnergy.connect เพื่อให้ ที่แอปพลิเคชันสามารถโต้ตอบกับบริการของแอปพลิเคชัน:
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...
...
});
});
เมื่อเชื่อมต่อแล้ว พร็อพเพอร์ตี้ connected ของออบเจ็กต์ bluetooth.Device ที่เกี่ยวข้องจะ
มีค่า true การเรียกใช้ bluetoothLowEnergy.connect สร้างการอ้างสิทธิ์โดย
กับการเชื่อมต่อทางกายภาพกับอุปกรณ์ มีการเชื่อมต่อทางกายภาพกับอุปกรณ์อยู่ได้
โดยไม่ต้องเรียก bluetoothLowEnergy.connect (ตัวอย่างเช่น เนื่องจากแอปพลิเคชันอื่น) ใน
ในขณะที่แอปพลิเคชันของคุณยังสามารถโต้ตอบกับบริการของอุปกรณ์ได้
จะเรียก bluetoothLowEnergy.connect เสมอเพื่อป้องกันไม่ให้แอปพลิเคชันอื่นยกเลิกการเชื่อมต่อ
ลิงก์จริง
เมื่อแอปพลิเคชันของคุณไม่จำเป็นต้องเชื่อมต่ออีกต่อไปแล้ว สามารถลบการอ้างสิทธิ์ออกจากการเชื่อมต่อได้โดย กำลังเรียก bluetoothLowEnergy.disconnect
chrome.bluetoothLowEnergy.disconnect(deviceAddress);
โปรดทราบว่าการดำเนินการนี้ไม่ได้ทำลายลิงก์ของอุปกรณ์จริงเสมอไป เนื่องจากอาจมี แอปพลิเคชันที่มีการเชื่อมต่อกับอุปกรณ์ที่ใช้งานอยู่ บางครั้งอุปกรณ์อาจ ยกเลิกการเชื่อมต่อ เนื่องจากเหตุผลที่อยู่เหนือการควบคุมของแอปพลิเคชัน (เช่น ในกรณีที่อุปกรณ์ หายไปหรือถูกตัดการเชื่อมต่ออย่างชัดแจ้งจากผู้ใช้ผ่านยูทิลิตีของระบบปฏิบัติการ) แอปพลิเคชันควรสังเกตเหตุการณ์ bluetooth.onDeviceChanged เพื่อรับการแจ้งเตือนเกี่ยวกับการเปลี่ยนแปลง กับการเชื่อมต่อ และเชื่อมต่อใหม่หากจำเป็น
เมื่อเชื่อมต่อแล้ว อุปกรณ์ที่ใช้ Chrome จะอยู่ในบทบาทส่วนกลางขณะที่ อุปกรณ์ระยะไกลแจ้งว่ามีบทบาทของอุปกรณ์ต่อพ่วง ในขั้นตอนนี้ แอปพลิเคชันของคุณสามารถโต้ตอบ กับบริการในอุปกรณ์โดยใช้วิธีการที่อธิบายไว้ในส่วนต่อไปนี้ หมายเหตุ: ปัจจุบัน API ยังไม่รองรับการทำหน้าที่เป็นอุปกรณ์ต่อพ่วง LE ของ Google จะสามารถใช้เฉพาะบทบาทหลักเท่านั้น
บริการ ลักษณะเฉพาะ และข้อบ่งชี้
บลูทูธพลังงานต่ำสร้างขึ้นโดยใช้โปรโตคอลคำขอตอบกลับแบบง่ายที่เรียกว่าโปรโตคอลแอตทริบิวต์ (ATT) อุปกรณ์ส่วนกลางจะใช้ ATT กับแอตทริบิวต์ที่เรียกว่าในอุปกรณ์ต่อพ่วง ด้วยการปฏิบัติตามโปรไฟล์บลูทูธพิเศษที่เรียกว่า generic Attribute Profile (GATT) แกต จะกำหนดแนวคิดระดับสูงดังต่อไปนี้
- บริการ: บริการ GATT แสดงถึงการรวบรวมข้อมูลและพฤติกรรมที่เกี่ยวข้องเพื่อบรรลุ ฟังก์ชันเฉพาะของอุปกรณ์ ตัวอย่างเช่น เครื่องวัดอัตราการเต้นของหัวใจมักจะมีอย่างน้อย "บริการอัตราการเต้นของหัวใจ" 1 รายการ ข้อมูลเกี่ยวกับบริการ GATT นั้นมีอยู่ใน bluetoothLowEnergy.Service
- ลักษณะเฉพาะ: ลักษณะเฉพาะของ GATT เป็นองค์ประกอบข้อมูลพื้นฐานที่ใช้ในการสร้างบริการ GATT ซึ่งมีค่าพร้อมด้วยพร็อพเพอร์ตี้ที่กำหนดวิธีเข้าถึงค่าดังกล่าว ตัวอย่างเช่น "บริการอัตราการเต้นของหัวใจ" มี "การวัดอัตราการเต้นของหัวใจ" ลักษณะเฉพาะ ซึ่งจะนำมาใช้เพื่อให้ได้รับ ค่าอัตราการเต้นของหัวใจของผู้ใช้ ข้อมูลเกี่ยวกับลักษณะเฉพาะของ GATT นั้นมีอยู่ใน bluetoothLowEnergy.Characteristic
- ตัวบอกลักษณะ: ข้อบ่งชี้ลักษณะเฉพาะของ GATT มีข้อมูลเพิ่มเติมเกี่ยวกับลักษณะเฉพาะหนึ่งๆ ข้อมูลเกี่ยวกับข้อบ่งชี้ลักษณะเฉพาะของ GATT จะอยู่ใน bluetoothLowEnergy.Descriptor
API บลูทูธพลังงานต่ำช่วยให้แอปพลิเคชันค้นหาข้อมูลเกี่ยวกับอุปกรณ์
บริการ ลักษณะ และข้อบ่งชี้โดยเรียกใช้ bluetoothLowEnergy.getServices
bluetoothLowEnergy.getCharacteristics และ bluetoothLowEnergy.getDescriptors แอปสามารถ
กรองบริการ ลักษณะ และข้อบ่งชี้โดยเปรียบเทียบฟิลด์ uuid กับฟิลด์
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;
}
}
...
});
บริการ ลักษณะ และข้อบ่งชี้แต่ละรายการที่เข้าถึงได้ผ่าน API จะได้รับการกำหนด
ตัวระบุอินสแตนซ์ ซึ่งรับได้โดยใช้ช่อง instanceId รหัสอินสแตนซ์นี้สามารถเป็น
ซึ่งใช้ในการระบุออบเจ็กต์ GATT และดำเนินการอย่างใดอย่างหนึ่งกับออบเจ็กต์นั้น
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) {
...
});
});
เหตุการณ์เกี่ยวกับบริการ
เมื่อเชื่อมต่ออุปกรณ์แล้ว Chrome จะค้นพบบริการต่างๆ เมื่อมีการค้นพบแต่ละบริการและ ออก แอปพลิเคชันจะได้รับ bluetoothLowEnergy.onServiceAdded และ เหตุการณ์ 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 จะค้นพบลักษณะและข้อบ่งชี้ทั้งหมดของบริการแบบไม่พร้อมกัน แล้วส่ง เหตุการณ์ bluetoothLowEnergy.onServiceAdded เมื่อการค้นหาเสร็จสิ้น หากการเชื่อมต่อกับ อุปกรณ์ต่อพ่วงสิ้นสุดลง Chrome จะนำบริการที่เกี่ยวข้องทั้งหมดออกและส่ง bluetoothLowEnergy.onServiceRemoved
อุปกรณ์ต่อพ่วงบางอย่างอาจแก้ไขบริการ เช่น ลักษณะของบริการอาจเปลี่ยนแปลงหรือ บริการต่างๆ อาจถูกเพิ่มและนำออกทั้งหมด Chrome จะแจ้งเตือนแอปเกี่ยวกับการเปลี่ยนแปลงเหล่านี้โดยใช้ bluetoothLowEnergy.onServiceChanged, bluetoothLowEnergy.onServiceAdded และ เหตุการณ์ bluetoothLowEnergy.onServiceRemoved
chrome.bluetoothLowEnergy.onServiceChanged.addListener(function(service) {
if (service.instanceId != myService.instanceId)
return;
updateMyService(service);
});
การอ่านและการเขียนค่าของลักษณะเฉพาะ
ลักษณะเฉพาะของ GATT จะเข้ารหัสลักษณะหนึ่งของบริการ แอปกลางอ่าน ทำงาน และแก้ไข สถานะบริการของอุปกรณ์ต่อพ่วงโดยการดำเนินการตามค่าลักษณะเฉพาะ ลักษณะเฉพาะ คือลำดับไบต์ และความหมายของค่าจะกำหนดโดยข้อกำหนดระดับสูงที่กำหนด ลักษณะเฉพาะบางอย่าง เช่น ค่าของลักษณะเฉพาะการวัดอัตราการเต้นของหัวใจ เข้ารหัสอัตราการเต้นของหัวใจและปริมาณแคลอรี่ที่ใช้ไปทั้งหมดของผู้ใช้ ขณะที่เซ็นเซอร์ร่างกาย การเข้ารหัสลักษณะเฉพาะของตำแหน่งในบริเวณที่ควรสวมใส่เซ็นเซอร์วัดอัตราการเต้นของหัวใจในร่างกาย
Chrome มีเมธอด bluetoothLowEnergy.readCharacteristicValue ในการอ่านค่าของแอตทริบิวต์ ลักษณะเฉพาะ:
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.
...
});
คุณลักษณะบางอย่างเขียนได้ โดยเฉพาะคุณลักษณะที่มีลักษณะเป็น "จุดควบคุม" ซึ่งการเขียน ค่านั้นจะมีผลข้างเคียง เช่น ฟีเจอร์ของจุดควบคุมอัตราการเต้นของหัวใจจะใช้เพื่อ บอกเซ็นเซอร์วัดอัตราการเต้นของหัวใจให้รีเซ็ตจำนวนแคลอรี่ที่ใช้ไปทั้งหมด และรองรับการเขียนเท่านั้น ถึง Chrome จะให้เมธอด 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.
});
โดยตัวบอกลักษณะจะมีการทำงานในลักษณะเดียวกันและสามารถอ่านและ/หรือเขียนได้ Chrome มอบ ค่า bluetoothLowEnergy.readDescriptorValue และ bluetoothLowEnergy.writeDescriptorValue ในการอ่านและเขียนค่าของข้อบ่งชี้
แอปพลิเคชันจะตรวจสอบ properties เพื่อดูว่าลักษณะเฉพาะรองรับการอ่านหรือการเขียนหรือไม่
ของออบเจ็กต์ bluetoothLowEnergy.Characteristic แม้ว่าฟิลด์นี้ไม่มี
เกี่ยวกับข้อกำหนดด้านความปลอดภัยในการเข้าถึงค่า ระบบจะอธิบายค่า
ที่คุณสมบัติรองรับโดยทั่วไป
การจัดการการแจ้งเตือนมูลค่า
ลักษณะเฉพาะบางอย่างทำให้คุณค่าของแอตทริบิวต์เป็นที่รู้จักโดยใช้การแจ้งเตือนหรือตัวบ่งชี้ ตัวอย่างเช่น ลักษณะเฉพาะการวัดอัตราการเต้นของหัวใจไม่สามารถอ่านหรือเขียนได้ แต่จะส่งการอัปเดตเกี่ยวกับ ค่าปัจจุบันในช่วงเวลาที่สม่ำเสมอ แอปพลิเคชันสามารถฟังการแจ้งเตือนเหล่านี้ได้โดยใช้ เหตุการณ์ bluetoothLowEnergy.onCharacteristicValueChanged
chrome.bluetoothLowEnergy.onCharacteristicValueChanged.addListener(
function(chrc) {
if (chrc.instanceId != myCharId)
return;
var bytes = new Uint8Array(chrc.value);
// Do stuff with the bytes.
...
});
แม้ว่าลักษณะเฉพาะจะรองรับการแจ้งเตือน/ตัวบ่งชี้ แต่ไม่ได้เปิดใช้งานโดยค่าเริ่มต้น CANNOT TRANSLATE แอปพลิเคชันควรเรียก bluetoothLowEnergy.startCharacteristicNotifications และ เมธอด bluetoothLowEnergy.stopCharacteristicNotifications เพื่อเริ่มหรือหยุดรับ เหตุการณ์ 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);
}
เมื่อเริ่มการแจ้งเตือนแล้ว แอปพลิเคชันจะได้รับ bluetoothLowEnergy.onCharacteristicValueChanged ทุกครั้งที่การแจ้งเตือนหรือสัญญาณบอกสถานะ ที่ได้รับจากลักษณะเฉพาะ หากลักษณะดังกล่าวรองรับการอ่าน เหตุการณ์นี้จะ ส่งหลังจากการเรียกไปยัง bluetoothLowEnergy.readCharacteristicValue ที่สำเร็จ การดำเนินการนี้ช่วยให้แอป เพื่อรวมขั้นตอนการควบคุมของการอัปเดตค่าที่ทริกเกอร์ผ่านคำขออ่านและการแจ้งเตือน ดังนี้
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.
});
});
หากคุณลักษณะรองรับการแจ้งเตือน ฟิลด์ properties ของฟิลด์จะมีฟิลด์
พร็อพเพอร์ตี้ "notify" หรือ "indicate"
หมายเหตุ: หากคุณลักษณะรองรับการแจ้งเตือน/ตัวบ่งชี้ จะมีข้อความ "ไคลเอ็นต์ การกำหนดค่าลักษณะเฉพาะ" ข้อบ่งชี้ในการเปิด/ปิดการแจ้งเตือน Chrome ไม่อนุญาต ที่จะเขียนลงในคำอธิบายนี้ แอปควรใช้ bluetoothLowEnergy.startCharacteristicNotifications และ เมธอด bluetoothLowEnergy.stopCharacteristicNotifications เพื่อควบคุมลักษณะการแจ้งเตือน