蓝牙模块
蓝牙设置
开启关闭蓝牙
- import需要的access模块。
- 需要SystemCapability.Communication.Bluetooth.Core系统能力。
- 开启蓝牙。
- 关闭蓝牙。
示例代码：
import { access } from '@kit.ConnectivityKit';
import { AsyncCallback, BusinessError } from '@kit.BasicServicesKit';
// 开启蓝牙
access.enableBluetooth();
access.on('stateChange', (data) => {
let btStateMessage = '';
switch (data) {
case 0:
btStateMessage += 'STATE_OFF';
break;
case 1:
btStateMessage += 'STATE_TURNING_ON';
break;
case 2:
btStateMessage += 'STATE_ON';
break;
case 3:
btStateMessage += 'STATE_TURNING_OFF';
break;
case 4:
btStateMessage += 'STATE_BLE_TURNING_ON';
break;
case 5:
btStateMessage += 'STATE_BLE_ON';
break;
case 6:
btStateMessage += 'STATE_BLE_TURNING_OFF';
break;
default:
btStateMessage += 'unknown status';
break;
}
if (btStateMessage == 'STATE_ON') {
access.off('stateChange');
}
console.info('bluetooth statues: ' + btStateMessage);
})
// 关闭蓝牙
access.disableBluetooth();
access.on('stateChange', (data) => {
let btStateMessage = '';
switch (data) {
case 0:
btStateMessage += 'STATE_OFF';
break;
case 1:
btStateMessage += 'STATE_TURNING_ON';
break;
case 2:
btStateMessage += 'STATE_ON';
break;
case 3:
btStateMessage += 'STATE_TURNING_OFF';
break;
case 4:
btStateMessage += 'STATE_BLE_TURNING_ON';
break;
case 5:
btStateMessage += 'STATE_BLE_ON';
break;
case 6:
btStateMessage += 'STATE_BLE_TURNING_OFF';
break;
default:
btStateMessage += 'unknown status';
break;
}
if (btStateMessage == 'STATE_OFF') {
access.off('stateChange');
}
console.info("bluetooth statues: " + btStateMessage);
})
广播与扫描开发指导
场景介绍
主要场景有：
开启、关闭广播
开启、关闭扫描
开启、关闭广播 - 作为广播中心
- import需要的ble模块。
- 开启设备的蓝牙。
- 需要SystemCapability.Communication.Bluetooth.Core系统能力。
- 开启广播，对端设备扫描该广播。
- 关闭广播。
示例代码：
import { ble } from '@kit.ConnectivityKit';
import { AsyncCallback, BusinessError } from '@kit.BasicServicesKit';
const TAG: string = 'BleAdvertisingManager';
export class BleAdvertisingManager {
private advHandle: number = 0xFF; // default invalid value
// 1 订阅广播状态
public onAdvertisingStateChange() {
try {
ble.on('advertisingStateChange', (data: ble.AdvertisingStateChangeInfo) => {
console.info(TAG, 'bluetooth advertising state = ' + JSON.stringify(data));
AppStorage.setOrCreate('advertiserState', data.state);
});
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
}
// 2 首次启动广播
public async startAdvertising() {
// 2.1 设置广播发送的参数
let setting: ble.AdvertiseSetting = {
interval: 160,
txPower: 0,
connectable: true
};
// 2.2 构造广播数据
let manufactureValueBuffer = new Uint8Array(4);
manufactureValueBuffer[0] = 1;
manufactureValueBuffer[1] = 2;
manufactureValueBuffer[2] = 3;
manufactureValueBuffer[3] = 4;
let serviceValueBuffer = new Uint8Array(4);
serviceValueBuffer[0] = 5;
serviceValueBuffer[1] = 6;
serviceValueBuffer[2] = 7;
serviceValueBuffer[3] = 8;
let manufactureDataUnit: ble.ManufactureData = {
manufactureId: 4567,
manufactureValue: manufactureValueBuffer.buffer
};
let serviceDataUnit: ble.ServiceData = {
serviceUuid: "00001888-0000-1000-8000-00805f9b34fb",
serviceValue: serviceValueBuffer.buffer
};
let advData: ble.AdvertiseData = {
serviceUuids: ["00001888-0000-1000-8000-00805f9b34fb"],
manufactureData: [manufactureDataUnit],
serviceData: [serviceDataUnit],
includeDeviceName: false // 表示是否携带设备名，可选参数。注意带上设备名时广播包长度不能超出31个字节。
};
let advResponse: ble.AdvertiseData = {
serviceUuids: ["00001888-0000-1000-8000-00805f9b34fb"],
manufactureData: [manufactureDataUnit],
serviceData: [serviceDataUnit]
};
// 2.3 构造广播启动完整参数AdvertisingParams
let advertisingParams: ble.AdvertisingParams = {
advertisingSettings: setting,
advertisingData: advData,
advertisingResponse: advResponse,
duration: 0 // 可选参数，若大于0，则广播发送一段时间后，则会临时停止，可重新启动发送
}
// 2.4 首次启动广播，且获取所启动广播的标识ID
try {
this.onAdvertisingStateChange();
this.advHandle = await ble.startAdvertising(advertisingParams);
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
}
// 4 临时停止广播，该广播资源仍然存在
public async disableAdvertising() {
// 4.1 构造临时停止广播参数
let advertisingDisableParams: ble.AdvertisingDisableParams = {
advertisingId: this.advHandle // 使用首次启动广播时获取到的广播标识ID
}
// 4.2 临时停止
try {
await ble.disableAdvertising(advertisingDisableParams);
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
}
// 5 再次启动广播
public async enableAdvertising(enableDuration: number) {
// 5.1 构造临时启动广播参数
let advertisingEnableParams: ble.AdvertisingEnableParams = {
advertisingId: this.advHandle, // 使用首次启动广播时获取到的广播标识ID
duration: enableDuration
}
// 5.2 再次启动
try {
await ble.enableAdvertising(advertisingEnableParams);
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
}
// 6 完全关闭广播，释放广播资源
public async stopAdvertising() {
try {
await ble.stopAdvertising(this.advHandle);
ble.off('advertisingStateChange', (data: ble.AdvertisingStateChangeInfo) => {
console.info(TAG, 'bluetooth advertising state = ' + JSON.stringify(data));
});
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
}
}
let bleAdvertisingManager = new BleAdvertisingManager();
export default bleAdvertisingManager as BleAdvertisingManager;
开启、关闭扫描
- import需要的ble模块。
- 开启设备的蓝牙。
- 需要SystemCapability.Communication.Bluetooth.Core系统能力。
- 对端设备开启广播。
- 本端设备开启扫描，获取扫描结果。
- 关闭扫描。
示例代码:
import { ble } from '@kit.ConnectivityKit';
import { AsyncCallback, BusinessError } from '@kit.BasicServicesKit';
const TAG: string = 'BleScanManager';
const BLE_ADV_TYPE_FLAG = 0x01;
const BLE_ADV_TYPE_16_BIT_SERVICE_UUIDS_INCOMPLETE = 0x02;
const BLE_ADV_TYPE_16_BIT_SERVICE_UUIDS_COMPLETE = 0x03;
const BLE_ADV_TYPE_32_BIT_SERVICE_UUIDS_INCOMPLETE = 0x04;
const BLE_ADV_TYPE_32_BIT_SERVICE_UUIDS_COMPLETE = 0x05;
const BLE_ADV_TYPE_128_BIT_SERVICE_UUIDS_INCOMPLETE = 0x06;
const BLE_ADV_TYPE_128_BIT_SERVICE_UUIDS_COMPLETE = 0x07;
const BLE_ADV_TYPE_LOCAL_NAME_SHORT = 0x08;
const BLE_ADV_TYPE_LOCAL_NAME_COMPLETE = 0x09;
const BLE_ADV_TYPE_TX_POWER_LEVEL = 0x0A;
const BLE_ADV_TYPE_16_BIT_SERVICE_SOLICITATION_UUIDS = 0x14;
const BLE_ADV_TYPE_128_BIT_SERVICE_SOLICITATION_UUIDS = 0x15;
const BLE_ADV_TYPE_32_BIT_SERVICE_SOLICITATION_UUIDS = 0x1F;
const BLE_ADV_TYPE_16_BIT_SERVICE_DATA = 0x16;
const BLE_ADV_TYPE_32_BIT_SERVICE_DATA = 0x20;
const BLE_ADV_TYPE_128_BIT_SERVICE_DATA = 0x21;
const BLE_ADV_TYPE_MANUFACTURER_SPECIFIC_DATA = 0xFF;
const BLUETOOTH_UUID_16_BIT_LENGTH = 2;
const BLUETOOTH_UUID_32_BIT_LENGTH = 4;
const BLUETOOTH_UUID_128_BIT_LENGTH = 16;
const BLUETOOTH_MANUFACTURE_ID_LENGTH = 2;
export class BleScanManager {
// 1 订阅扫描结果
public onScanResult() {
ble.on('BLEDeviceFind', (data: Array<ble.ScanResult>) => {
if (data.length > 0) {
console.info(TAG, 'BLE scan result = ' + data[0].deviceId);
this.parseScanResult(data[0].data);
}
});
}
private parseScanResult(data: ArrayBuffer) {
let advData = new Uint8Array(data);
if (advData.byteLength == 0) {
console.warn(TAG, 'nothing, adv data length is 0');
return;
}
console.info(TAG, 'advData: ' + JSON.stringify(advData));
let advFlags: number = -1;
let txPowerLevel: number = -1;
let localName: string = "";
let serviceUuids: string[] = [];
let serviceSolicitationUuids: string[] = [];
let serviceDatas: Record<string, Uint8Array> = {};
let manufactureSpecificDatas: Record<number, Uint8Array> = {};
let curPos = 0;
while (curPos < advData.byteLength) {
let length = advData[curPos++];
if (length == 0) {
break;
}
let advDataLength = length - 1;
let advDataType = advData[curPos++];
switch (advDataType) {
case BLE_ADV_TYPE_FLAG:
advFlags = advData[curPos];
break;
case BLE_ADV_TYPE_LOCAL_NAME_SHORT:
case BLE_ADV_TYPE_LOCAL_NAME_COMPLETE:
localName = advData.slice(curPos, curPos + advDataLength).toString();
break;
case BLE_ADV_TYPE_TX_POWER_LEVEL:
txPowerLevel = advData[curPos];
break;
case BLE_ADV_TYPE_16_BIT_SERVICE_UUIDS_INCOMPLETE:
case BLE_ADV_TYPE_16_BIT_SERVICE_UUIDS_COMPLETE:
this.parseServiceUuid(BLUETOOTH_UUID_16_BIT_LENGTH, curPos, advDataLength, advData, serviceUuids);
break;
case BLE_ADV_TYPE_32_BIT_SERVICE_UUIDS_INCOMPLETE:
case BLE_ADV_TYPE_32_BIT_SERVICE_UUIDS_COMPLETE:
this.parseServiceUuid(BLUETOOTH_UUID_32_BIT_LENGTH, curPos, advDataLength, advData, serviceUuids);
break;
case BLE_ADV_TYPE_128_BIT_SERVICE_UUIDS_INCOMPLETE:
case BLE_ADV_TYPE_128_BIT_SERVICE_UUIDS_COMPLETE:
this.parseServiceUuid(BLUETOOTH_UUID_128_BIT_LENGTH, curPos, advDataLength, advData, serviceUuids);
break;
case BLE_ADV_TYPE_16_BIT_SERVICE_SOLICITATION_UUIDS:
this.parseServiceSolicitationUuid(BLUETOOTH_UUID_16_BIT_LENGTH, curPos, advDataLength,
advData, serviceSolicitationUuids);
break;
case BLE_ADV_TYPE_32_BIT_SERVICE_SOLICITATION_UUIDS:
this.parseServiceSolicitationUuid(BLUETOOTH_UUID_32_BIT_LENGTH, curPos, advDataLength,
advData, serviceSolicitationUuids);
break;
case BLE_ADV_TYPE_128_BIT_SERVICE_SOLICITATION_UUIDS:
this.parseServiceSolicitationUuid(BLUETOOTH_UUID_128_BIT_LENGTH, curPos, advDataLength,
advData, serviceSolicitationUuids);
break;
case BLE_ADV_TYPE_16_BIT_SERVICE_DATA:
this.parseServiceData(BLUETOOTH_UUID_16_BIT_LENGTH, curPos, advDataLength, advData, serviceDatas);
break;
case BLE_ADV_TYPE_32_BIT_SERVICE_DATA:
this.parseServiceData(BLUETOOTH_UUID_32_BIT_LENGTH, curPos, advDataLength, advData, serviceDatas);
break;
case BLE_ADV_TYPE_128_BIT_SERVICE_DATA:
this.parseServiceData(BLUETOOTH_UUID_128_BIT_LENGTH, curPos, advDataLength, advData, serviceDatas);
break;
case BLE_ADV_TYPE_MANUFACTURER_SPECIFIC_DATA:
this.parseManufactureData(curPos, advDataLength, advData, manufactureSpecificDatas);
break;
default:
break;
}
curPos += advDataLength;
}
}
private parseServiceUuid(uuidLength: number, curPos: number, advDataLength: number,
advData: Uint8Array, serviceUuids: string[]) {
while (advDataLength > 0) {
let tmpData: Uint8Array = advData.slice(curPos, curPos + uuidLength);
serviceUuids.push(this.getUuidFromUint8Array(uuidLength, tmpData));
advDataLength -= uuidLength;
curPos += uuidLength;
}
}
private parseServiceSolicitationUuid(uuidLength: number, curPos: number, advDataLength: number,
advData: Uint8Array, serviceSolicitationUuids: string[]) {
while (advDataLength > 0) {
let tmpData: Uint8Array = advData.slice(curPos, curPos + uuidLength);
serviceSolicitationUuids.push(this.getUuidFromUint8Array(uuidLength, tmpData));
advDataLength -= uuidLength;
curPos += uuidLength;
}
}
private getUuidFromUint8Array(uuidLength: number, uuidData: Uint8Array): string {
let uuid = "";
let temp: string = "";
for (let i = uuidLength - 1; i > -1; i--) {
temp += uuidData[i].toString(16).padStart(2, "0");
}
switch (uuidLength) {
case BLUETOOTH_UUID_16_BIT_LENGTH:
uuid = `0000${temp}-0000-1000-8000-00805F9B34FB`;
break;
case BLUETOOTH_UUID_32_BIT_LENGTH:
uuid = `${temp}-0000-1000-8000-00805F9B34FB`;
break;
case BLUETOOTH_UUID_128_BIT_LENGTH:
uuid = `${temp.substring(0, 8)}-${temp.substring(8, 12)}-${temp.substring(12, 16)}-${temp.substring(16, 20)}-${temp.substring(20, 32)}`;
break;
default:
break;
}
return uuid;
}
private parseServiceData(uuidLength: number, curPos: number, advDataLength: number,
advData: Uint8Array, serviceDatas: Record<string, Uint8Array>) {
let tmpUuid: Uint8Array = advData.slice(curPos, curPos + uuidLength);
let tmpValue: Uint8Array = advData.slice(curPos + uuidLength, curPos + advDataLength);
serviceDatas[tmpUuid.toString()] = tmpValue;
}
private parseManufactureData(curPos: number, advDataLength: number,
advData: Uint8Array, manufactureSpecificDatas: Record<number, Uint8Array>) {
let manufactureId: number = (advData[curPos + 1] << 8) + advData[curPos];
let tmpValue: Uint8Array = advData.slice(curPos + BLUETOOTH_MANUFACTURE_ID_LENGTH, curPos + advDataLength);
manufactureSpecificDatas[manufactureId] = tmpValue;
}
// 2 开启扫描
public startScan() {
// 2.1 构造扫描过滤器，需要能够匹配预期的广播包内容
let manufactureId = 4567;
let manufactureData: Uint8Array = new Uint8Array([1, 2, 3, 4]);
let manufactureDataMask: Uint8Array = new Uint8Array([0xFF, 0xFF, 0xFF, 0xFF]);
let scanFilter: ble.ScanFilter = { // 根据业务实际情况定义过滤器
manufactureId: manufactureId,
manufactureData: manufactureData.buffer,
manufactureDataMask: manufactureDataMask.buffer
};
// 2.2 构造扫描参数
let scanOptions: ble.ScanOptions = {
interval: 0,
dutyMode: ble.ScanDuty.SCAN_MODE_LOW_POWER,
matchMode: ble.MatchMode.MATCH_MODE_AGGRESSIVE
}
try {
this.onScanResult(); // 订阅扫描结果
ble.startBLEScan([scanFilter], scanOptions);
console.info(TAG, 'startBleScan success');
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
}
// 3 关闭扫描
public stopScan() {
try {
ble.off('BLEDeviceFind', (data: Array<ble.ScanResult>) => { // 取消订阅扫描结果
console.info(TAG, 'off success');
});
ble.stopBLEScan();
console.info(TAG, 'stopBleScan success');
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
}
}
let bleScanManager = new BleScanManager();
export default bleScanManager as BleScanManager;
GATT
通用属性协议是GATT（Generic Attribute）的缩写，它是一种用于在蓝牙低功耗设备之间传输数据的协议，定义了一套通用的属性和服务框架。通过GATT协议，蓝牙设备可以向其他设备提供服务，也可以从其他设备获取服务。
主要场景有：
- 连接server端读取和写入信息。
- server端操作services和通知客户端信息。
连接server端读取和写入信息
- import需要的ble模块。
- 创建gattClient实例对象。
- 连接gattServer。
- 读取gattServer的特征值和描述符。
- 向gattServer写入特征值和描述符。
- 断开连接，销毁gattClient实例。
- 示例代码:
import { ble } from '@kit.ConnectivityKit';
import { constant } from '@kit.ConnectivityKit';
import { AsyncCallback, BusinessError } from '@kit.BasicServicesKit';
const TAG: string = 'GattClientManager';
export class GattClientManager {
device: string = undefined;
gattClient: ble.GattClientDevice = undefined;
connectState: ble.ProfileConnectionState = constant.ProfileConnectionState.STATE_DISCONNECTED;
myServiceUuid: string = '00001810-0000-1000-8000-00805F9B34FB';
myCharacteristicUuid: string = '00001820-0000-1000-8000-00805F9B34FB';
myFirstDescriptorUuid: string = '00002902-0000-1000-8000-00805F9B34FB'; // 2902一般用于notification或者indication
mySecondDescriptorUuid: string = '00002903-0000-1000-8000-00805F9B34FB';
found: boolean = false;
// 构造BLEDescriptor
private initDescriptor(des: string, value: ArrayBuffer): ble.BLEDescriptor {
let descriptor: ble.BLEDescriptor = {
serviceUuid: this.myServiceUuid,
characteristicUuid: this.myCharacteristicUuid,
descriptorUuid: des,
descriptorValue: value
};
return descriptor;
}
// 构造BLECharacteristic
private initCharacteristic(): ble.BLECharacteristic {
let descriptors: Array<ble.BLEDescriptor> = [];
let descBuffer = new ArrayBuffer(2);
let descValue = new Uint8Array(descBuffer);
descValue[0] = 11;
descValue[1] = 12;
descriptors[0] = this.initDescriptor(this.myFirstDescriptorUuid, new ArrayBuffer(2));
descriptors[1] = this.initDescriptor(this.mySecondDescriptorUuid, descBuffer);
let charBuffer = new ArrayBuffer(2);
let charValue = new Uint8Array(charBuffer);
charValue[0] = 1;
charValue[1] = 2;
let characteristic: ble.BLECharacteristic = {
serviceUuid: this.myServiceUuid,
characteristicUuid: this.myCharacteristicUuid,
characteristicValue: charBuffer,
descriptors: descriptors
};
return characteristic;
}
private logCharacteristic(char: ble.BLECharacteristic) {
let message = 'logCharacteristic uuid:' + char.characteristicUuid + '\n';
let value = new Uint8Array(char.characteristicValue);
message += 'logCharacteristic value: ';
for (let i = 0; i < char.characteristicValue.byteLength; i++) {
message += value[i] + ' ';
}
console.info(TAG, message);
}
private logDescriptor(des: ble.BLEDescriptor) {
let message = 'logDescriptor uuid:' + des.descriptorUuid + '\n';
let value = new Uint8Array(des.descriptorValue);
message += 'logDescriptor value: ';
for (let i = 0; i < des.descriptorValue.byteLength; i++) {
message += value[i] + ' ';
}
console.info(TAG, message);
}
private checkService(services: Array<ble.GattService>): boolean {
for (let i = 0; i < services.length; i++) {
if (services[i].serviceUuid != this.myServiceUuid) {
continue;
}
for (let j = 0; j < services[i].characteristics.length; j++) {
if (services[i].characteristics[j].characteristicUuid != this.myCharacteristicUuid) {
continue;
}
for (let k = 0; k < services[i].characteristics[j].descriptors.length; k++) {
if (services[i].characteristics[j].descriptors[k].descriptorUuid == this.myFirstDescriptorUuid) {
console.info(TAG, 'find expected service from server');
return true;
}
}
}
}
console.error(TAG, 'no expected service from server');
return false;
}
// 1. 订阅连接状态变化事件
public onGattClientStateChange() {
if (!this.gattClient) {
console.error(TAG, 'no gattClient');
return;
}
try {
this.gattClient.on('BLEConnectionStateChange', (stateInfo: ble.BLEConnectionChangeState) => {
let state = '';
switch (stateInfo.state) {
case 0:
state = 'DISCONNECTED';
break;
case 1:
state = 'CONNECTING';
break;
case 2:
state = 'CONNECTED';
break;
case 3:
state = 'DISCONNECTING';
break;
default:
state = 'undefined';
break;
}
console.info(TAG, 'onGattClientStateChange: device=' + stateInfo.deviceId + ', state=' + state);
if (stateInfo.deviceId == this.device) {
this.connectState = stateInfo.state;
}
});
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
}
// 2. client端主动连接时调用
public startConnect(peerDevice: string) { // 对端设备一般通过ble scan获取到
if (this.connectState != constant.ProfileConnectionState.STATE_DISCONNECTED) {
console.error(TAG, 'startConnect failed');
return;
}
console.info(TAG, 'startConnect ' + peerDevice);
this.device = peerDevice;
// 2.1 使用device构造gattClient，后续的交互都需要使用该实例
this.gattClient = ble.createGattClientDevice(peerDevice);
try {
this.onGattClientStateChange(); // 2.2 订阅连接状态
this.gattClient.connect(); // 2.3 发起连接
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
}
// 3. client端连接成功后，需要进行服务发现
public discoverServices() {
if (!this.gattClient) {
console.info(TAG, 'no gattClient');
return;
}
console.info(TAG, 'discoverServices');
try {
this.gattClient.getServices().then((result: Array<ble.GattService>) => {
console.info(TAG, 'getServices success: ' + JSON.stringify(result));
this.found = this.checkService(result); // 要确保server端的服务内容有业务所需要的服务
});
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
}
// 4. 在确保拿到了server端的服务结果后，读取server端特定服务的特征值时调用
public readCharacteristicValue() {
if (!this.gattClient || this.connectState != constant.ProfileConnectionState.STATE_CONNECTED) {
console.error(TAG, 'no gattClient or not connected');
return;
}
if (!this.found) { // 要确保server端有对应的characteristic
console.error(TAG, 'no characteristic from server');
return;
}
let characteristic = this.initCharacteristic();
console.info(TAG, 'readCharacteristicValue');
try {
this.gattClient.readCharacteristicValue(characteristic).then((outData: ble.BLECharacteristic) => {
this.logCharacteristic(outData);
})
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
}
// 5. 在确保拿到了server端的服务结果后，写入server端特定服务的特征值时调用
public writeCharacteristicValue() {
if (!this.gattClient || this.connectState != constant.ProfileConnectionState.STATE_CONNECTED) {
console.error(TAG, 'no gattClient or not connected');
return;
}
if (!this.found) { // 要确保server端有对应的characteristic
console.error(TAG, 'no characteristic from server');
return;
}
let characteristic = this.initCharacteristic();
console.info(TAG, 'writeCharacteristicValue');
try {
this.gattClient.writeCharacteristicValue(characteristic, ble.GattWriteType.WRITE, (err) => {
if (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
return;
}
console.info(TAG, 'writeCharacteristicValue success');
});
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
}
// 6. 在确保拿到了server端的服务结果后，读取server端特定服务的描述符时调用
public readDescriptorValue() {
if (!this.gattClient || this.connectState != constant.ProfileConnectionState.STATE_CONNECTED) {
console.error(TAG, 'no gattClient or not connected');
return;
}
if (!this.found) { // 要确保server端有对应的descriptor
console.error(TAG, 'no descriptor from server');
return;
}
let descBuffer = new ArrayBuffer(0);
let descriptor = this.initDescriptor(this.mySecondDescriptorUuid, descBuffer);
console.info(TAG, 'readDescriptorValue');
try {
this.gattClient.readDescriptorValue(descriptor).then((outData: ble.BLEDescriptor) => {
this.logDescriptor(outData);
});
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
}
// 7. 在确保拿到了server端的服务结果后，写入server端特定服务的描述符时调用
public writeDescriptorValue() {
if (!this.gattClient || this.connectState != constant.ProfileConnectionState.STATE_CONNECTED) {
console.error(TAG, 'no gattClient or not connected');
return;
}
if (!this.found) { // 要确保server端有对应的descriptor
console.error(TAG, 'no descriptor from server');
return;
}
let descBuffer = new ArrayBuffer(2);
let descValue = new Uint8Array(descBuffer);
descValue[0] = 11;
descValue[1] = 12;
let descriptor = this.initDescriptor(this.mySecondDescriptorUuid, descBuffer);
console.info(TAG, 'writeDescriptorValue');
try {
this.gattClient.writeDescriptorValue(descriptor, (err) => {
if (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
return;
}
console.info(TAG, 'writeDescriptorValue success');
});
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
}
// 8.client端主动断开时调用
public stopConnect() {
if (!this.gattClient || this.connectState != constant.ProfileConnectionState.STATE_CONNECTED) {
console.error(TAG, 'no gattClient or not connected');
return;
}
console.info(TAG, 'stopConnect ' + this.device);
try {
this.gattClient.disconnect(); // 8.1 断开连接
this.gattClient.off('BLEConnectionStateChange', (stateInfo: ble.BLEConnectionChangeState) => {
});
this.gattClient.close() // 8.2 如果不再使用此gattClient，则需要close
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
}
}
let gattClientManager = new GattClientManager();
export default gattClientManager as GattClientManager;
server端操作services和通知客户端信息
- import需要的ble模块。
- 创建gattServer实例对象。
- 添加services信息。
- 当向gattServer写入特征值通知gattClient。
- 移除services信息。
- 注销gattServer实例。
- 示例代码:
import { ble } from '@kit.ConnectivityKit';
import { constant } from '@kit.ConnectivityKit';
import { AsyncCallback, BusinessError } from '@kit.BasicServicesKit';
const TAG: string = 'GattServerManager';
export class GattServerManager {
gattServer: ble.GattServer = undefined;
connectState: ble.ProfileConnectionState = constant.ProfileConnectionState.STATE_DISCONNECTED;
myServiceUuid: string = '00001810-0000-1000-8000-00805F9B34FB';
myCharacteristicUuid: string = '00001820-0000-1000-8000-00805F9B34FB';
myFirstDescriptorUuid: string = '00002902-0000-1000-8000-00805F9B34FB'; // 2902一般用于notification或者indication
mySecondDescriptorUuid: string = '00002903-0000-1000-8000-00805F9B34FB';
// 构造BLEDescriptor
private initDescriptor(des: string, value: ArrayBuffer): ble.BLEDescriptor {
let descriptor: ble.BLEDescriptor = {
serviceUuid: this.myServiceUuid,
characteristicUuid: this.myCharacteristicUuid,
descriptorUuid: des,
descriptorValue: value
};
return descriptor;
}
// 构造BLECharacteristic
private initCharacteristic(): ble.BLECharacteristic {
let descriptors: Array<ble.BLEDescriptor> = [];
let descBuffer = new ArrayBuffer(2);
let descValue = new Uint8Array(descBuffer);
descValue[0] = 31;
descValue[1] = 32;
descriptors[0] = this.initDescriptor(this.myFirstDescriptorUuid, new ArrayBuffer(2));
descriptors[1] = this.initDescriptor(this.mySecondDescriptorUuid, descBuffer);
let charBuffer = new ArrayBuffer(2);
let charValue = new Uint8Array(charBuffer);
charValue[0] = 21;
charValue[1] = 22;
let characteristic: ble.BLECharacteristic = {
serviceUuid: this.myServiceUuid,
characteristicUuid: this.myCharacteristicUuid,
characteristicValue: charBuffer,
descriptors: descriptors
};
return characteristic;
}
// 1. 订阅连接状态变化事件
public onGattServerStateChange() {
if (!this.gattServer) {
console.error(TAG, 'no gattServer');
return;
}
try {
this.gattServer.on('connectionStateChange', (stateInfo: ble.BLEConnectionChangeState) => {
let state = '';
switch (stateInfo.state) {
case 0:
state = 'DISCONNECTED';
break;
case 1:
state = 'CONNECTING';
break;
case 2:
state = 'CONNECTED';
break;
case 3:
state = 'DISCONNECTING';
break;
default:
state = 'undefined';
break;
}
console.info(TAG, 'onGattServerStateChange: device=' + stateInfo.deviceId + ', state=' + state);
});
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
}
// 2. server端注册服务时调用
public registerServer() {
let characteristics: Array<ble.BLECharacteristic> = [];
let characteristic = this.initCharacteristic();
characteristics.push(characteristic);
let gattService: ble.GattService = {
serviceUuid: this.myServiceUuid,
isPrimary: true,
characteristics: characteristics
};
console.info(TAG, 'registerServer ' + this.myServiceUuid);
try {
this.gattServer = ble.createGattServer(); // 2.1 构造gattServer，后续的交互都需要使用该实例
this.onGattServerStateChange(); // 2.2 订阅连接状态
this.gattServer.addService(gattService);
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
}
// 3. 订阅来自gattClient的读取特征值请求时调用
public onCharacteristicRead() {
if (!this.gattServer) {
console.error(TAG, 'no gattServer');
return;
}
console.info(TAG, 'onCharacteristicRead');
try {
this.gattServer.on('characteristicRead', (charReq: ble.CharacteristicReadRequest) => {
let deviceId: string = charReq.deviceId;
let transId: number = charReq.transId;
let offset: number = charReq.offset;
console.info(TAG, 'receive characteristicRead');
let rspBuffer = new ArrayBuffer(2);
let rspValue = new Uint8Array(rspBuffer);
rspValue[0] = 21;
rspValue[1] = 22;
let serverResponse: ble.ServerResponse = {
deviceId: deviceId,
transId: transId,
status: 0, // 0表示成功
offset: offset,
value: rspBuffer
};
try {
this.gattServer.sendResponse(serverResponse);
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
});
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
}
// 4. 订阅来自gattClient的写入特征值请求时调用
public onCharacteristicWrite() {
if (!this.gattServer) {
console.error(TAG, 'no gattServer');
return;
}
console.info(TAG, 'onCharacteristicWrite');
try {
this.gattServer.on('characteristicWrite', (charReq: ble.CharacteristicWriteRequest) => {
let deviceId: string = charReq.deviceId;
let transId: number = charReq.transId;
let offset: number = charReq.offset;
console.info(TAG, 'receive characteristicWrite: needRsp=' + charReq.needRsp);
if (!charReq.needRsp) {
return;
}
let rspBuffer = new ArrayBuffer(0);
let serverResponse: ble.ServerResponse = {
deviceId: deviceId,
transId: transId,
status: 0, // 0表示成功
offset: offset,
value: rspBuffer
};
try {
this.gattServer.sendResponse(serverResponse);
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
});
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
}
// 5. 订阅来自gattClient的读取描述符请求时调用
public onDescriptorRead() {
if (!this.gattServer) {
console.error(TAG, 'no gattServer');
return;
}
console.info(TAG, 'onDescriptorRead');
try {
this.gattServer.on('descriptorRead', (desReq: ble.DescriptorReadRequest) => {
let deviceId: string = desReq.deviceId;
let transId: number = desReq.transId;
let offset: number = desReq.offset;
console.info(TAG, 'receive descriptorRead');
let rspBuffer = new ArrayBuffer(2);
let rspValue = new Uint8Array(rspBuffer);
rspValue[0] = 31;
rspValue[1] = 32;
let serverResponse: ble.ServerResponse = {
deviceId: deviceId,
transId: transId,
status: 0, // 0表示成功
offset: offset,
value: rspBuffer
};
try {
this.gattServer.sendResponse(serverResponse);
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
});
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
}
// 6. 订阅来自gattClient的写入描述符请求时调用
public onDescriptorWrite() {
if (!this.gattServer) {
console.error(TAG, 'no gattServer');
return;
}
console.info(TAG, 'onDescriptorWrite');
try {
this.gattServer.on('descriptorWrite', (desReq: ble.DescriptorWriteRequest) => {
let deviceId: string = desReq.deviceId;
let transId: number = desReq.transId;
let offset: number = desReq.offset;
console.info(TAG, 'receive descriptorWrite: needRsp=' + desReq.needRsp);
if (!desReq.needRsp) {
return;
}
let rspBuffer = new ArrayBuffer(0);
let serverResponse: ble.ServerResponse = {
deviceId: deviceId,
transId: transId,
status: 0, // 0表示成功
offset: offset,
value: rspBuffer
};
try {
this.gattServer.sendResponse(serverResponse);
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
});
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
}
// 7. server端删除服务，不再使用时调用
public unRegisterServer() {
if (!this.gattServer) {
console.error(TAG, 'no gattServer');
return;
}
console.info(TAG, 'unRegisterServer ' + this.myServiceUuid);
try {
this.gattServer.removeService(this.myServiceUuid); // 7.1 删除服务
this.gattServer.off('connectionStateChange', (stateInfo: ble.BLEConnectionChangeState) => { // 7.2 取消订阅连接状态
});
this.gattServer.close() // 7.3 如果不再使用此gattServer，则需要close
} catch (err) {
console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
}
}
}
let gattServerManager = new GattServerManager();
export default gattServerManager as GattServerManager;
SPP 串行通信
SPP是Serial Port Profile（串口协议）的缩写，是一种蓝牙协议，用于在蓝牙设备之间建立串行通信连接。通过SPP，蓝牙设备可以像使用串口一样进行数据传输，例如传输文件、文本等。
主要场景有：
服务端向客户端写入数据。
通过socket连接对端设备。
SPP
服务端向客户端写入数据
- import需要的socket模块。
- 需要SystemCapability.Communication.Bluetooth.Core系统能力。
- 开启设备蓝牙。
- 创建服务端socket，返回serverId。
- 服务端等待客户端连接，返回clientId。
- 服务端向客户端写入数据。
7.（可选）服务端订阅客户端写入的数据。 - 注销服务端socket。
- 注销客户端socket。
- 示例代码：
import { socket } from '@kit.ConnectivityKit';
import { AsyncCallback, BusinessError } from '@kit.BasicServicesKit';
// 创建服务器监听Socket, 返回serverId
let serverNumber = -1;
let sppOption: socket.SppOptions = {
uuid: '00001101-0000-1000-8000-00805f9b34fb',
secure: true,
type: 0
};
socket.sppListen('server1', sppOption, (code, serverSocketID) => {
if (code != null) {
console.error('sppListen error, code is ' + (code as BusinessError).code);
return;
} else {
serverNumber = serverSocketID;
console.info('sppListen success, serverNumber = ' + serverNumber);
}
});
// socket等待客户端连接，连接成功返回clientId
let clientNumber = -1;
socket.sppAccept(serverNumber, (code, clientSocketID) => {
if (code != null) {
console.error('sppAccept error, code is ' + (code as BusinessError).code);
return;
} else {
clientNumber = clientSocketID;
console.info('accept the client success');
}
})
console.info('waiting for client connection');
// 向客户端写入数据
let array = new Uint8Array(990);
array[0] = 'A'.charCodeAt(0);
array[1] = 'B'.charCodeAt(0);
array[2] = 'C'.charCodeAt(0);
array[3] = 'D'.charCodeAt(0);
socket.sppWrite(clientNumber, array.buffer);
console.info('sppWrite success');
// 订阅读请求事件
socket.on('sppRead', clientNumber, (dataBuffer: ArrayBuffer) => {
const data = new Uint8Array(dataBuffer);
if (data != null) {
console.info('sppRead success, data = ' + JSON.stringify(data));
} else {
console.error('sppRead error, data is null');
}
});
// 取消订阅读请求事件
socket.off('sppRead', clientNumber, (dataBuffer: ArrayBuffer) => {
const data = new Uint8Array(dataBuffer);
if (data != null) {
console.info('offSppRead success, data = ' + JSON.stringify(data));
} else {
console.error('offSppRead error, data is null');
}
});
// 注销服务端socket
socket.sppCloseServerSocket(serverNumber);
console.info('sppCloseServerSocket success');
// 注销客户端socket
socket.sppCloseClientSocket(clientNumber);
console.info('sppCloseClientSocket success');
通过socket连接对端设备
- import需要的socket模块。
- 需要SystemCapability.Communication.Bluetooth.Core系统能力。
- 开启设备蓝牙。
- 开启ble扫描，获取对端设备mac地址。
- 连接对端设备。
- 示例代码：
import { socket } from '@kit.ConnectivityKit';
import { AsyncCallback, BusinessError } from '@kit.BasicServicesKit';
// 开启ble扫描，获取对端设备mac地址
let deviceId = 'xx:xx:xx:xx:xx:xx';
// 连接对端设备
socket.sppConnect(deviceId, {
uuid: '00001101-0000-1000-8000-00805f9b34fb',
secure: true,
type: 0
}, (code, socketID) => {
if (code != null) {
console.error('sppConnect error, code = ' + (code as BusinessError).code);
return;
}
console.info('sppConnect success, socketId = ' + socketID);
})
