【HarmonyOS】鸿蒙应用低功耗蓝牙BLE的使专心得 （一）

【HarmonyOS】鸿蒙应用低功耗蓝牙BLE的使专心得(一)

     一、前言

     

     鸿蒙官网文档中蓝牙部分，对于之前没有开发过蓝牙的同学，使用和查阅起来不是很方便。由于只是API的调用阐明。并没有蓝牙整个调用流程的讲授，以是看起来会云里雾里。特别是针对低功耗蓝牙来说，对于寻常蓝牙，开发步调较少还好。
     在开发蓝牙和低功耗蓝牙之前，我们最好对蓝牙开发有肯定的基础认识，如许开发起来才气团体框架，知道本身在做什么，只是根据文档API的调用，很容易漏处理。
     本章主要讲授低功耗蓝牙BLE的开发调用，寻常蓝牙在之前的章节已经系统的讲过了。可以拜见，【HarmonyOS】鸿蒙应用蓝牙功能实现 (一，二，三)系列。
     二、BLE低功耗蓝牙的基础知识

     1.低功耗蓝牙是什么？ 低功耗蓝牙(Bluetooth Low Energy，简称BLE)是蓝牙技术的一种变体，也被称为蓝牙4.0。BLE技术通过一系列的技术和优化措施，如减少广播频段和广播时射频开启时间、采用深度就寝状态(Duty-Cycle)、优化毗连机制等，明显低落了装备的功耗。这使得BLE装备在长时间运行下，电池寿命得到大大延长。比如智能穿着装备、智能家电、传感器等
     2.低功耗蓝牙与寻常蓝牙的区别是什么？ 见名知意，在功耗上前者更为良好，并且易维护，非常得当对能耗敏感的场景。相比之下，寻常蓝牙的功耗较高。一旦激活，它就会始终保持毗连，比力耗能。因此，它主要应用在对功耗要求不高的装备上，如无线耳机、音箱、游戏手柄等。
     在广播信道上，前者为3，这有助于减少网络干扰并低落功耗。后者为32，虽然提供了更多的选择，但相应地也增长了功耗和复杂性。
     数据传输速率和包长度，前者都更短些。
     3.低功耗蓝牙相关专有名词表明：
     设置文件 (Profile) Profile 是被蓝牙标准预先定义的一些 Service 的集合，并不真实存在于蓝牙装备中。如果蓝牙装备之间要相互兼容，它们只要支持雷同的 Profile 即可。一个蓝牙装备可以支持多个 Profile。
     服务 Service 是蓝牙装备对外提供的服务，一个装备可以提供多个服务，比如电量信息服务、系统信息服务等。每个服务由一个 UUID 唯一标识。
     特征 每个 Service 包含 0 至多个 Characteristic。比如，电量信息服务就会有个 Characteristic 表示电量数据。Characteristic 包含一个值 (value)和 0 至多个描述符 (Descriptor) 构成。在与蓝牙装备通讯时，主要就是通过读写 Characteristic 的 value 完成。 每个 Characteristic 由一个 UUID 唯一标识。
     描述符 Descriptor 是描述特征值的已定义属性。例如，Descriptor 可指定人类可读的描述、特征值的取值范围或特定于特征值的度量单位。每个 Descriptor 由一个 UUID 唯一标识。
     GATT-Generic Attribute Profile GATT 设置文件是关于通过 BLE 链路发送和吸收一小段数据(称为“属性”)的一样寻通例范。当前的全部 BLE 应用设置文件都基于 GATT。
     Bluetooth SIG 为 BLE 装备定义了许多设置文件。设置文件是规定装备如安在特定应用中工作的规范。请注意，一个装备可以实现多个设置文件。例如，装备大概包含心率监测器和电池电量检测器。
     GATT 是基于属性协议 (ATT) 构建的。这也称为 GATT/ATT。ATT 颠末优化，可在 BLE 装备上运行。为此，它会尽大概减少使用的字节数量。每个属性均由通用唯一标识符 (UUID) 举行唯一标识。UUID 是一种标准化的 128 位格式，用于对信息举行唯一标识的字符串 ID。由 ATT 传输的特性会采用“特征”和服务的格式。
     中央装备Central和外围装备Peripheral 这是低功耗蓝牙中十分告急的概念。通过低功耗蓝牙链接的两个装备，一个为中央装备(获取信息的信息使用方)，一个为外围装备(产出信息的信息提供方)。例如手机和电子温度计通过蓝牙链接，前者就是中央装备，后者就是外围装备。
     中央装备Central 中央装备可以扫描外围装备，并在发现有外围装备存在后与之建立毗连，之后就可以使用外围装备提供的服务(Service)。一样寻常而言，手机会担任中央装备的脚色，利用外围装备提供的数据举行处理或展示等等。小步伐提供低功耗蓝牙接口是默认设定手机为中央装备的。
     外围装备Peripheral 外围装备一直处于广播状态，等待被中央装备搜索和毗连，不能自动发起搜索。例如智能手环、传感器等装备。如果外围装备广播时被设置为不可毗连的状态，也被称为广播模式 (Broadcaster)，常见的例子是蓝牙信标 (Beacon) 装备。
     三、BLE低功耗蓝牙的使用流程：

     

     该流程分为两个部分，中央装备的角度和外围装备的角度。
     首先作为中央装备，需要： 1.初始化蓝牙模块 2.扫描并发现蓝牙外围装备 3.毗连装备 4.获取蓝牙外围装备的服务 5. 读写服务的特征值 6. 断开毗连和关闭蓝牙适配器
     之后作为外围设别，需要： 1.初始化蓝牙模块 2.添加服务，写入特征值和描述 3.发送广播，设置广播各种参数
     DEMO示例：

     中央装备操作步调函数：
                 

1. import { ble } from '@kit.ConnectivityKit';
2. import { constant } from '@kit.ConnectivityKit';
3. import { AsyncCallback, BusinessError } from '@kit.BasicServicesKit';
5. const TAG: string = 'GattClientManager';
7. export class GattClientManager {
8.   device: string = undefined;
9.   gattClient: ble.GattClientDevice = undefined;
10.   connectState: ble.ProfileConnectionState = constant.ProfileConnectionState.STATE_DISCONNECTED;
11.   myServiceUuid: string = '00001810-0000-1000-8000-00805F9B34FB';
12.   myCharacteristicUuid: string = '00001820-0000-1000-8000-00805F9B34FB';
13.   myFirstDescriptorUuid: string = '00002902-0000-1000-8000-00805F9B34FB'; // 2902一般用于notification或者indication
14.   mySecondDescriptorUuid: string = '00002903-0000-1000-8000-00805F9B34FB';
15.   found: boolean = false;
17.   // 构造BLEDescriptor
18.   private initDescriptor(des: string, value: ArrayBuffer): ble.BLEDescriptor {
19.     let descriptor: ble.BLEDescriptor = {
20.       serviceUuid: this.myServiceUuid,
21.       characteristicUuid: this.myCharacteristicUuid,
22.       descriptorUuid: des,
23.       descriptorValue: value
24.     };
25.     return descriptor;
26.   }
28.   // 构造BLECharacteristic
29.   private initCharacteristic(): ble.BLECharacteristic {
30.     let descriptors: Array<ble.BLEDescriptor> = [];
31.     let descBuffer = new ArrayBuffer(2);
32.     let descValue = new Uint8Array(descBuffer);
33.     descValue[0] = 11;
34.     descValue[1] = 12;
35.     descriptors[0] = this.initDescriptor(this.myFirstDescriptorUuid, new ArrayBuffer(2));
36.     descriptors[1] = this.initDescriptor(this.mySecondDescriptorUuid, descBuffer);
37.     let charBuffer = new ArrayBuffer(2);
38.     let charValue = new Uint8Array(charBuffer);
39.     charValue[0] = 1;
40.     charValue[1] = 2;
41.     let characteristic: ble.BLECharacteristic = {
42.       serviceUuid: this.myServiceUuid,
43.       characteristicUuid: this.myCharacteristicUuid,
44.       characteristicValue: charBuffer,
45.       descriptors: descriptors
46.     };
47.     return characteristic;
48.   }
50.   private logCharacteristic(char: ble.BLECharacteristic) {
51.     let message = 'logCharacteristic uuid:' + char.characteristicUuid + '\n';
52.     let value = new Uint8Array(char.characteristicValue);
53.     message += 'logCharacteristic value: ';
54.     for (let i = 0; i < char.characteristicValue.byteLength; i++) {
55.       message += value[i] + ' ';
56.     }
57.     console.info(TAG, message);
58.   }
60.   private logDescriptor(des: ble.BLEDescriptor) {
61.     let message = 'logDescriptor uuid:' + des.descriptorUuid + '\n';
62.     let value = new Uint8Array(des.descriptorValue);
63.     message += 'logDescriptor value: ';
64.     for (let i = 0; i < des.descriptorValue.byteLength; i++) {
65.       message += value[i] + ' ';
66.     }
67.     console.info(TAG, message);
68.   }
70.   private checkService(services: Array<ble.GattService>): boolean {
71.     for (let i = 0; i < services.length; i++) {
72.       if (services[i].serviceUuid != this.myServiceUuid) {
73.         continue;
74.       }
75.       for (let j = 0; j < services[i].characteristics.length; j++) {
76.         if (services[i].characteristics[j].characteristicUuid != this.myCharacteristicUuid) {
77.           continue;
78.         }
79.         for (let k = 0; k < services[i].characteristics[j].descriptors.length; k++) {
80.           if (services[i].characteristics[j].descriptors[k].descriptorUuid == this.myFirstDescriptorUuid) {
81.             console.info(TAG, 'find expected service from server');
82.             return true;
83.           }
84.         }
85.       }
86.     }
87.     console.error(TAG, 'no expected service from server');
88.     return false;
89.   }
91.   // 1. 订阅连接状态变化事件
92.   public onGattClientStateChange() {
93.     if (!this.gattClient) {
94.       console.error(TAG, 'no gattClient');
95.       return;
96.     }
97.     try {
98.       this.gattClient.on('BLEConnectionStateChange', (stateInfo: ble.BLEConnectionChangeState) => {
99.         let state = '';
100.         switch (stateInfo.state) {
101.           case 0:
102.             state = 'DISCONNECTED';
103.             break;
104.           case 1:
105.             state = 'CONNECTING';
106.             break;
107.           case 2:
108.             state = 'CONNECTED';
109.             break;
110.           case 3:
111.             state = 'DISCONNECTING';
112.             break;
113.           default:
114.             state = 'undefined';
115.             break;
116.         }
117.         console.info(TAG, 'onGattClientStateChange: device=' + stateInfo.deviceId + ', state=' + state);
118.         if (stateInfo.deviceId == this.device) {
119.           this.connectState = stateInfo.state;
120.         }
121.       });
122.     } catch (err) {
123.       console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
124.     }
125.   }
127.   // 2. client端主动连接时调用
128.   public startConnect(peerDevice: string) { // 对端设备一般通过ble scan获取到
129.     if (this.connectState != constant.ProfileConnectionState.STATE_DISCONNECTED) {
130.       console.error(TAG, 'startConnect failed');
131.       return;
132.     }
133.     console.info(TAG, 'startConnect ' + peerDevice);
134.     this.device = peerDevice;
135.     // 2.1 使用device构造gattClient，后续的交互都需要使用该实例
136.     this.gattClient = ble.createGattClientDevice(peerDevice);
137.     try {
138.       this.onGattClientStateChange(); // 2.2 订阅连接状态
139.       this.gattClient.connect(); // 2.3 发起连接
140.     } catch (err) {
141.       console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
142.     }
143.   }
145.   // 3. client端连接成功后，需要进行服务发现
146.   public discoverServices() {
147.     if (!this.gattClient) {
148.       console.info(TAG, 'no gattClient');
149.       return;
150.     }
151.     console.info(TAG, 'discoverServices');
152.     try {
153.       this.gattClient.getServices().then((result: Array<ble.GattService>) => {
154.         console.info(TAG, 'getServices success: ' + JSON.stringify(result));
155.         this.found = this.checkService(result); // 要确保server端的服务内容有业务所需要的服务
156.       });
157.     } catch (err) {
158.       console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
159.     }
160.   }
162.   // 4. 在确保拿到了server端的服务结果后，读取server端特定服务的特征值时调用
163.   public readCharacteristicValue() {
164.     if (!this.gattClient || this.connectState != constant.ProfileConnectionState.STATE_CONNECTED) {
165.       console.error(TAG, 'no gattClient or not connected');
166.       return;
167.     }
168.     if (!this.found) { // 要确保server端有对应的characteristic
169.       console.error(TAG, 'no characteristic from server');
170.       return;
171.     }
173.     let characteristic = this.initCharacteristic();
174.     console.info(TAG, 'readCharacteristicValue');
175.     try {
176.       this.gattClient.readCharacteristicValue(characteristic).then((outData: ble.BLECharacteristic) => {
177.         this.logCharacteristic(outData);
178.       })
179.     } catch (err) {
180.       console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
181.     }
182.   }
184.   // 5. 在确保拿到了server端的服务结果后，写入server端特定服务的特征值时调用
185.   public writeCharacteristicValue() {
186.     if (!this.gattClient || this.connectState != constant.ProfileConnectionState.STATE_CONNECTED) {
187.       console.error(TAG, 'no gattClient or not connected');
188.       return;
189.     }
190.     if (!this.found) { // 要确保server端有对应的characteristic
191.       console.error(TAG, 'no characteristic from server');
192.       return;
193.     }
195.     let characteristic = this.initCharacteristic();
196.     console.info(TAG, 'writeCharacteristicValue');
197.     try {
198.       this.gattClient.writeCharacteristicValue(characteristic, ble.GattWriteType.WRITE, (err) => {
199.         if (err) {
200.           console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
201.           return;
202.         }
203.         console.info(TAG, 'writeCharacteristicValue success');
204.       });
205.     } catch (err) {
206.       console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
207.     }
208.   }
210.   // 6. 在确保拿到了server端的服务结果后，读取server端特定服务的描述符时调用
211.   public readDescriptorValue() {
212.     if (!this.gattClient || this.connectState != constant.ProfileConnectionState.STATE_CONNECTED) {
213.       console.error(TAG, 'no gattClient or not connected');
214.       return;
215.     }
216.     if (!this.found) { // 要确保server端有对应的descriptor
217.       console.error(TAG, 'no descriptor from server');
218.       return;
219.     }
221.     let descBuffer = new ArrayBuffer(0);
222.     let descriptor = this.initDescriptor(this.mySecondDescriptorUuid, descBuffer);
223.     console.info(TAG, 'readDescriptorValue');
224.     try {
225.       this.gattClient.readDescriptorValue(descriptor).then((outData: ble.BLEDescriptor) => {
226.         this.logDescriptor(outData);
227.       });
228.     } catch (err) {
229.       console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
230.     }
231.   }
233.   // 7. 在确保拿到了server端的服务结果后，写入server端特定服务的描述符时调用
234.   public writeDescriptorValue() {
235.     if (!this.gattClient || this.connectState != constant.ProfileConnectionState.STATE_CONNECTED) {
236.       console.error(TAG, 'no gattClient or not connected');
237.       return;
238.     }
239.     if (!this.found) { // 要确保server端有对应的descriptor
240.       console.error(TAG, 'no descriptor from server');
241.       return;
242.     }
244.     let descBuffer = new ArrayBuffer(2);
245.     let descValue = new Uint8Array(descBuffer);
246.     descValue[0] = 11;
247.     descValue[1] = 12;
248.     let descriptor = this.initDescriptor(this.mySecondDescriptorUuid, descBuffer);
249.     console.info(TAG, 'writeDescriptorValue');
250.     try {
251.       this.gattClient.writeDescriptorValue(descriptor, (err) => {
252.         if (err) {
253.           console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
254.           return;
255.         }
256.         console.info(TAG, 'writeDescriptorValue success');
257.       });
258.     } catch (err) {
259.       console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
260.     }
261.   }
263.   // 8.client端主动断开时调用
264.   public stopConnect() {
265.     if (!this.gattClient || this.connectState != constant.ProfileConnectionState.STATE_CONNECTED) {
266.       console.error(TAG, 'no gattClient or not connected');
267.       return;
268.     }
270.     console.info(TAG, 'stopConnect ' + this.device);
271.     try {
272.       this.gattClient.disconnect(); // 8.1 断开连接
273.       this.gattClient.off('BLEConnectionStateChange', (stateInfo: ble.BLEConnectionChangeState) => {
274.       });
275.       this.gattClient.close() // 8.2 如果不再使用此gattClient，则需要close
276.     } catch (err) {
277.       console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
278.     }
279.   }
280. }
282. let gattClientManager = new GattClientManager();
283. export default gattClientManager as GattClientManager;

复制代码

               外围装备操作步调函数：
                 

1. import { ble } from '@kit.ConnectivityKit';
2. import { constant } from '@kit.ConnectivityKit';
3. import { AsyncCallback, BusinessError } from '@kit.BasicServicesKit';
5. const TAG: string = 'GattServerManager';
7. export class GattServerManager {
8.   gattServer: ble.GattServer = undefined;
9.   connectState: ble.ProfileConnectionState = constant.ProfileConnectionState.STATE_DISCONNECTED;
10.   myServiceUuid: string = '00001810-0000-1000-8000-00805F9B34FB';
11.   myCharacteristicUuid: string = '00001820-0000-1000-8000-00805F9B34FB';
12.   myFirstDescriptorUuid: string = '00002902-0000-1000-8000-00805F9B34FB'; // 2902一般用于notification或者indication
13.   mySecondDescriptorUuid: string = '00002903-0000-1000-8000-00805F9B34FB';
15.   // 构造BLEDescriptor
16.   private initDescriptor(des: string, value: ArrayBuffer): ble.BLEDescriptor {
17.     let descriptor: ble.BLEDescriptor = {
18.       serviceUuid: this.myServiceUuid,
19.       characteristicUuid: this.myCharacteristicUuid,
20.       descriptorUuid: des,
21.       descriptorValue: value
22.     };
23.     return descriptor;
24.   }
26.   // 构造BLECharacteristic
27.   private initCharacteristic(): ble.BLECharacteristic {
28.     let descriptors: Array<ble.BLEDescriptor> = [];
29.     let descBuffer = new ArrayBuffer(2);
30.     let descValue = new Uint8Array(descBuffer);
31.     descValue[0] = 31;
32.     descValue[1] = 32;
33.     descriptors[0] = this.initDescriptor(this.myFirstDescriptorUuid, new ArrayBuffer(2));
34.     descriptors[1] = this.initDescriptor(this.mySecondDescriptorUuid, descBuffer);
35.     let charBuffer = new ArrayBuffer(2);
36.     let charValue = new Uint8Array(charBuffer);
37.     charValue[0] = 21;
38.     charValue[1] = 22;
39.     let characteristic: ble.BLECharacteristic = {
40.       serviceUuid: this.myServiceUuid,
41.       characteristicUuid: this.myCharacteristicUuid,
42.       characteristicValue: charBuffer,
43.       descriptors: descriptors
44.     };
45.     return characteristic;
46.   }
48.   // 1. 订阅连接状态变化事件
49.   public onGattServerStateChange() {
50.     if (!this.gattServer) {
51.       console.error(TAG, 'no gattServer');
52.       return;
53.     }
54.     try {
55.       this.gattServer.on('connectionStateChange', (stateInfo: ble.BLEConnectionChangeState) => {
56.         let state = '';
57.         switch (stateInfo.state) {
58.           case 0:
59.             state = 'DISCONNECTED';
60.             break;
61.           case 1:
62.             state = 'CONNECTING';
63.             break;
64.           case 2:
65.             state = 'CONNECTED';
66.             break;
67.           case 3:
68.             state = 'DISCONNECTING';
69.             break;
70.           default:
71.             state = 'undefined';
72.             break;
73.         }
74.         console.info(TAG, 'onGattServerStateChange: device=' + stateInfo.deviceId + ', state=' + state);
75.       });
76.     } catch (err) {
77.       console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
78.     }
79.   }
81.   // 2. server端注册服务时调用
82.   public registerServer() {
83.     let characteristics: Array<ble.BLECharacteristic> = [];
84.     let characteristic = this.initCharacteristic();
85.     characteristics.push(characteristic);
86.     let gattService: ble.GattService = {
87.       serviceUuid: this.myServiceUuid,
88.       isPrimary: true,
89.       characteristics: characteristics
90.     };
92.     console.info(TAG, 'registerServer ' + this.myServiceUuid);
93.     try {
94.       this.gattServer = ble.createGattServer(); // 2.1 构造gattServer，后续的交互都需要使用该实例
95.       this.onGattServerStateChange(); // 2.2 订阅连接状态
96.       this.gattServer.addService(gattService);
97.     } catch (err) {
98.       console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
99.     }
100.   }
102.   // 3. 订阅来自gattClient的读取特征值请求时调用
103.   public onCharacteristicRead() {
104.     if (!this.gattServer) {
105.       console.error(TAG, 'no gattServer');
106.       return;
107.     }
109.     console.info(TAG, 'onCharacteristicRead');
110.     try {
111.       this.gattServer.on('characteristicRead', (charReq: ble.CharacteristicReadRequest) => {
112.         let deviceId: string = charReq.deviceId;
113.         let transId: number = charReq.transId;
114.         let offset: number = charReq.offset;
115.         console.info(TAG, 'receive characteristicRead');
116.         let rspBuffer = new ArrayBuffer(2);
117.         let rspValue = new Uint8Array(rspBuffer);
118.         rspValue[0] = 21;
119.         rspValue[1] = 22;
120.         let serverResponse: ble.ServerResponse = {
121.           deviceId: deviceId,
122.           transId: transId,
123.           status: 0, // 0表示成功
124.           offset: offset,
125.           value: rspBuffer
126.         };
128.         try {
129.           this.gattServer.sendResponse(serverResponse);
130.         } catch (err) {
131.           console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
132.         }
133.       });
134.     } catch (err) {
135.       console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
136.     }
137.   }
139.   // 4. 订阅来自gattClient的写入特征值请求时调用
140.   public onCharacteristicWrite() {
141.     if (!this.gattServer) {
142.       console.error(TAG, 'no gattServer');
143.       return;
144.     }
146.     console.info(TAG, 'onCharacteristicWrite');
147.     try {
148.       this.gattServer.on('characteristicWrite', (charReq: ble.CharacteristicWriteRequest) => {
149.         let deviceId: string = charReq.deviceId;
150.         let transId: number = charReq.transId;
151.         let offset: number = charReq.offset;
152.         console.info(TAG, 'receive characteristicWrite: needRsp=' + charReq.needRsp);
153.         if (!charReq.needRsp) {
154.           return;
155.         }
156.         let rspBuffer = new ArrayBuffer(0);
157.         let serverResponse: ble.ServerResponse = {
158.           deviceId: deviceId,
159.           transId: transId,
160.           status: 0, // 0表示成功
161.           offset: offset,
162.           value: rspBuffer
163.         };
165.         try {
166.           this.gattServer.sendResponse(serverResponse);
167.         } catch (err) {
168.           console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
169.         }
170.       });
171.     } catch (err) {
172.       console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
173.     }
174.   }
176.   // 5. 订阅来自gattClient的读取描述符请求时调用
177.   public onDescriptorRead() {
178.     if (!this.gattServer) {
179.       console.error(TAG, 'no gattServer');
180.       return;
181.     }
183.     console.info(TAG, 'onDescriptorRead');
184.     try {
185.       this.gattServer.on('descriptorRead', (desReq: ble.DescriptorReadRequest) => {
186.         let deviceId: string = desReq.deviceId;
187.         let transId: number = desReq.transId;
188.         let offset: number = desReq.offset;
189.         console.info(TAG, 'receive descriptorRead');
190.         let rspBuffer = new ArrayBuffer(2);
191.         let rspValue = new Uint8Array(rspBuffer);
192.         rspValue[0] = 31;
193.         rspValue[1] = 32;
194.         let serverResponse: ble.ServerResponse = {
195.           deviceId: deviceId,
196.           transId: transId,
197.           status: 0, // 0表示成功
198.           offset: offset,
199.           value: rspBuffer
200.         };
202.         try {
203.           this.gattServer.sendResponse(serverResponse);
204.         } catch (err) {
205.           console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
206.         }
207.       });
208.     } catch (err) {
209.       console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
210.     }
211.   }
213.   // 6. 订阅来自gattClient的写入描述符请求时调用
214.   public onDescriptorWrite() {
215.     if (!this.gattServer) {
216.       console.error(TAG, 'no gattServer');
217.       return;
218.     }
220.     console.info(TAG, 'onDescriptorWrite');
221.     try {
222.       this.gattServer.on('descriptorWrite', (desReq: ble.DescriptorWriteRequest) => {
223.         let deviceId: string = desReq.deviceId;
224.         let transId: number = desReq.transId;
225.         let offset: number = desReq.offset;
226.         console.info(TAG, 'receive descriptorWrite: needRsp=' + desReq.needRsp);
227.         if (!desReq.needRsp) {
228.           return;
229.         }
230.         let rspBuffer = new ArrayBuffer(0);
231.         let serverResponse: ble.ServerResponse = {
232.           deviceId: deviceId,
233.           transId: transId,
234.           status: 0, // 0表示成功
235.           offset: offset,
236.           value: rspBuffer
237.         };
239.         try {
240.           this.gattServer.sendResponse(serverResponse);
241.         } catch (err) {
242.           console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
243.         }
244.       });
245.     } catch (err) {
246.       console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
247.     }
248.   }
250.   // 7. server端删除服务，不再使用时调用
251.   public unRegisterServer() {
252.     if (!this.gattServer) {
253.       console.error(TAG, 'no gattServer');
254.       return;
255.     }
257.     console.info(TAG, 'unRegisterServer ' + this.myServiceUuid);
258.     try {
259.       this.gattServer.removeService(this.myServiceUuid); // 7.1 删除服务
260.       this.gattServer.off('connectionStateChange', (stateInfo: ble.BLEConnectionChangeState) => { // 7.2 取消订阅连接状态
261.       });
262.       this.gattServer.close() // 7.3 如果不再使用此gattServer，则需要close
263.     } catch (err) {
264.       console.error(TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
265.     }
266.   }
267. }
269. let gattServerManager = new GattServerManager();
270. export default gattServerManager as GattServerManager;

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。