【HarmonyOS】鸿蒙应用蓝牙功能实现 （三）

【HarmonyOS】鸿蒙应用蓝牙功能实现 (三)

     前言

     今天整理蓝牙Demo代码，查看官网时发现自己帐号没有登录，竟然也可以访问最新的API文档，真是喜大奔普。看来华为已经开始对外开放最新的API文档，不再有白名单限定了。
     

     HarmonyOS NEXTDeveloper Beta5
     接下来解说蓝牙配对流程。低功耗蓝牙BLE模式将在下面章节解说。
     蓝牙配对业务流程

     1.设备进入可被发现模式： 起首，设备需要进入可被发现模式，这样附近的蓝牙设备才能识别到它。一方设备(如手机)会主动搜索附近的蓝牙设备，并列出全部可用的配对选项。
     2.选择并触发配对哀求： 用户从列表中选择想要连接的设备，并触发配对哀求。此时，双方设备会交换一系列的身份验证信息，以确保相互的身份安全无误。在这个过程中，可能会要求用户输入配对码(如PIN码)或在设备上确认配对哀求。
     3.身份验证和加密： 一旦身份验证通过，设备间就会创建安全的连接通道，这一过程称为“配对乐成”。配对完成后，设备之间的连接就创建了，它们可以开始传输数据。
     4.数据传输： 设备间通过蓝牙举行数据传输，可以传输音频、文件等多种类型的数据。
     5.断开连接： 当数据传输完成后，蓝牙设备可以断开连接。断开连接的操作可以通过设备上的按钮大概软件来实现。
     蓝牙配对通常是一次性的，即一旦设备乐成配对，它们会在后续的连接中自动识别并连接，无需再次举行配对过程(除非设备被重置或用户手动取消配对)
     以下是传统的蓝牙配对流程图仅供参考：
     

     通例蓝牙配对Demo

     

     Demo包括以下内容： 1.蓝牙权限开启 2.蓝牙开启/关闭 3.蓝牙扫描开启/关闭 4.蓝牙配对 5.蓝牙code协议确认
     蓝牙UI交互类
         

1. import { access } from '@kit.ConnectivityKit';
2. import { BusinessError } from '@kit.BasicServicesKit';
3. import { BlueToothMgr } from '../manager/BlueToothMgr';
4. import { abilityAccessCtrl, common } from '@kit.AbilityKit';
5. import { connection } from '@kit.ConnectivityKit';
6. import { map } from '@kit.ConnectivityKit';
7. import { pbap } from '@kit.ConnectivityKit';
8. import { HashMap } from '@kit.ArkTS';
9. import { DeviceInfo } from '../info/DeviceInfo';
10. import { promptAction } from '@kit.ArkUI';
12. @Entry
13. @Component
14. struct Index {
16.   private TAG: string = "BlueToothTest";
18.   // 扫描状态定时器
19.   private mNumInterval: number = -1;
20.   // 当前设备蓝牙名
21.   @State mCurrentDeviceName: string = "";
22.   // 蓝牙状态
23.   @State @Watch('onChangeBlueTooth') isStartBlueTooth: boolean = false;
24.   // 蓝牙扫描状态
25.   @State @Watch('onChangeBlueTooth') isStartScan: boolean = false;
26.   // 当前蓝牙权限
27.   @State userGrant: boolean = false;
28.   // 扫描到设备名
29.   @State mMapDevice: HashMap<string, DeviceInfo> = new HashMap();
30.   // ui展现的设备列表
31.   @State mListDeviceInfo: Array<DeviceInfo> = new Array();
33.   async aboutToAppear() {
34.     await this.requestBlueToothPermission();
36.     let state = access.getState();
37.     console.log(this.TAG, "getState state: " + state);
38.     if(state == 2){
39.       this.isStartBlueTooth = true;
40.       console.log(this.TAG, "getState isStartBlueTooth: " + this.isStartBlueTooth);
41.     }else{
42.       this.isStartBlueTooth = false;
43.       console.log(this.TAG, "getState isStartBlueTooth: " + this.isStartBlueTooth);
44.     }
45.   }
47.   private onChangeBlueTooth(){
48.     if(!this.isStartBlueTooth){
49.       this.mMapDevice = new HashMap();
50.       return;
51.     }
53.     this.mCurrentDeviceName = BlueToothMgr.Ins().getCurrentDeviceName();
54.   }
56.   // 用户申请权限
57.   async reqPermissionsFromUser(): Promise<number[]> {
58.     let context = getContext() as common.UIAbilityContext;
59.     let atManager = abilityAccessCtrl.createAtManager();
60.     let grantStatus = await atManager.requestPermissionsFromUser(context, ['ohos.permission.ACCESS_BLUETOOTH']);
61.     return grantStatus.authResults;
62.   }
64.   // 用户申请蓝牙权限
65.   async requestBlueToothPermission() {
66.     let grantStatus = await this.reqPermissionsFromUser();
67.     for (let i = 0; i < grantStatus.length; i++) {
68.       if (grantStatus[i] === 0) {
69.         // 用户授权，可以继续访问目标操作
70.         this.userGrant = true;
71.         promptAction.showToast({ message: "蓝牙授权成功！"});
72.       }else{
73.         promptAction.showToast({ message: "蓝牙授权失败！"});
74.       }
75.     }
76.   }
78.   setBlueToothScan = ()=>{
79.     if(!this.isStartScan){
80.       promptAction.showToast({ message: "开启扫描！"});
81.       BlueToothMgr.Ins().startScanDevice((data: Array<string>)=>{
82.         let deviceId: string = data[0];
83.         if(this.mMapDevice.hasKey(deviceId)){
84.           // 重复设备，丢弃不处理
85.         }else{
86.           // 添加到表中
87.           let deviceInfo: DeviceInfo = new DeviceInfo();
88.           deviceInfo.deviceId = deviceId;
89.           deviceInfo.deviceName = BlueToothMgr.Ins().getDeviceName(deviceId);
90.           deviceInfo.deviceClass = BlueToothMgr.Ins().getDeviceClass(deviceId);
91.           this.mMapDevice.set(deviceId, deviceInfo);
92.           this.mListDeviceInfo = this.mListDeviceInfo.concat(deviceInfo);
93.         }
94.       });
95.       this.mMapDevice.clear();
96.       this.mListDeviceInfo = [];
97.       // 开启定时器
98.       this.mNumInterval = setInterval(()=>{
99.         let discovering = BlueToothMgr.Ins().isCurrentDiscovering();
100.         if(!discovering){
101.           this.closeScanDevice();
102.         }
103.       }, 1000);
104.       this.isStartScan = true;
105.     }else{
106.       promptAction.showToast({ message: "关闭扫描！"});
107.       BlueToothMgr.Ins().stopScanDevice();
108.       this.closeScanDevice();
109.     }
110.   }
112.   private closeScanDevice(){
113.     clearInterval(this.mNumInterval);
114.     this.isStartScan = false;
115.   }
117.   setBlueToothState = ()=>{
118.     try {
119.       if(!this.isStartBlueTooth){
120.         // 开启蓝牙
121.         BlueToothMgr.Ins().setBlueToothAccess(true, (state: access.BluetoothState) => {
122.           console.log(this.TAG, "getState setBlueToothAccessTrue: " + state);
123.           if(state == access.BluetoothState.STATE_ON){
124.             this.isStartBlueTooth = true;
125.             promptAction.showToast({ message: "开启蓝牙！"});
126.             console.log(this.TAG, "getState isStartBlueTooth: " + this.isStartBlueTooth);
127.           }
128.         });
129.       }else{
130.         BlueToothMgr.Ins().setBlueToothAccess(false, (state: access.BluetoothState) => {
131.           console.log(this.TAG, "getState setBlueToothAccessFalse: " + state);
132.           if(state == access.BluetoothState.STATE_OFF){
133.             this.isStartBlueTooth = false;
134.             promptAction.showToast({ message: "关闭蓝牙！"});
135.             console.log(this.TAG, "getState isStartBlueTooth: " + this.isStartBlueTooth);
136.           }
137.         });
138.       }
139.     } catch (err) {
140.       console.error(this.TAG,'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
141.     }
142.   }
144.   private isLog(){
145.     console.log(this.TAG, "isLog isStartBlueTooth: " + this.isStartBlueTooth);
146.     return true;
147.   }
149.   build() {
150.     Column() {
151.       if(this.userGrant){
152.         if(this.isLog()){
153.           Text("当前蓝牙设备信息:\n " + this.mCurrentDeviceName)
154.             .fontSize(px2fp(80))
155.             .margin({ top: px2vp(100) })
156.             .fontWeight(FontWeight.Bold)
158.           Text(this.isStartBlueTooth ? "蓝牙状态: 开启" : "蓝牙状态: 关闭")
159.             .fontSize(px2fp(80))
160.             .margin({ top: px2vp(100) })
161.             .fontWeight(FontWeight.Bold)
162.             .onClick(this.setBlueToothState)
164.           Text(this.isStartScan ? "蓝牙扫描: 开启ing" : "蓝牙扫描: 关闭")
165.             .margin({ top: px2vp(100) })
166.             .fontSize(px2fp(80))
167.             .fontWeight(FontWeight.Bold)
168.             .onClick(this.setBlueToothScan)
170.           this.ListView()
171.         }
172.       }
173.     }
174.     .justifyContent(FlexAlign.Center)
175.     .height('100%')
176.     .width('100%')
177.   }
179.   @Builder ListView(){
180.     List() {
181.       ForEach(this.mListDeviceInfo, (item: DeviceInfo, index: number) => {
182.         ListItem() {
183.           Column(){
184.             Row() {
185.               Text("设备ID: " + item.deviceId).fontSize(px2fp(42)).fontColor(Color.Black)
186.               Blank()
187.               Text("设备名: " + item.deviceName).fontSize(px2fp(42)).fontColor(Color.Black)
188.             }
189.             .width('100%')
190.             Text(item.deviceClass).fontSize(px2fp(42)).fontColor(Color.Black)
191.           }
192.           .width('100%')
193.           .height(px2vp(200))
194.           .justifyContent(FlexAlign.Start)
195.           .onClick(()=>{
196.             // 点击选择处理配对
197.             AlertDialog.show({
198.               title:"选择配对",
199.               message:"是否选择该设备进行蓝牙配对？",
200.               autoCancel: true,
201.               primaryButton: {
202.                 value:"确定",
203.                 action:()=>{
204.                   promptAction.showToast({ message: item.deviceName + "配对ing！"});
205.                   BlueToothMgr.Ins().pairDevice(item.deviceId);
206.                 }
207.               },
208.               secondaryButton: {
209.                 value:"取消",
210.                 action:()=>{
211.                   promptAction.showToast({ message: "取消！"});
212.                 }
213.               },
214.               cancel:()=>{
215.                 promptAction.showToast({ message: "取消！"});
216.               }
217.             })
218.           })
219.         }
220.       }, (item: string, index: number) => JSON.stringify(item) + index)
221.     }
222.     .width('100%')
223.   }
224. }

复制代码

         蓝牙管理类
         

1. import { access, ble } from '@kit.ConnectivityKit';
2. import { BusinessError } from '@kit.BasicServicesKit';
3. import { connection } from '@kit.ConnectivityKit';
5. export class BlueToothMgr {
7.   private TAG: string = "BlueToothTest";
9.   private static mBlueToothMgr: BlueToothMgr | undefined = undefined;
11.   private advHandle: number = 0xFF; // default invalid value
13.   private mDeviceDiscoverArr: Array<string> = new Array<string>();
15.   public static Ins(){
16.     if(!BlueToothMgr.mBlueToothMgr){
17.       BlueToothMgr.mBlueToothMgr = new BlueToothMgr();
18.       BlueToothMgr.init();
19.     }
20.     return BlueToothMgr.mBlueToothMgr;
21.   }
23.   private static init(){
24.     try {
25.       connection.on('pinRequired', (data: connection.PinRequiredParam) =>{
26.         // data为配对请求参数
27.         console.info("BlueToothTest",'pinRequired pin required = '+ JSON.stringify(data));
28.       });
29.     } catch (err) {
30.       console.error("BlueToothTest", 'pinRequired errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
31.     }
32.   }
34.   /**
35.    * 当前设备蓝牙设备名称
36.    */
37.   public getCurrentDeviceName(){
38.     let localName: string = "";
39.     try {
40.       localName = connection.getLocalName();
41.       console.info(this.TAG, 'getCurrentDeviceName localName: ' + localName);
42.     } catch (err) {
43.       console.error(this.TAG, 'getCurrentDeviceName errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
44.     }
45.     return localName;
46.   }
48.   /**
49.    * 当前设备蓝牙可发现状态
50.    */
51.   public isCurrentDiscovering(){
52.     let res: boolean = false;
53.     try {
54.       res = connection.isBluetoothDiscovering();
55.       console.info(this.TAG, 'isCurrentDiscovering isBluetoothDiscovering: ' + res);
56.     } catch (err) {
57.       console.error(this.TAG, 'isCurrentDiscovering errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
58.     }
59.     return res;
60.   }
62.   // STATE_OFF        0        表示蓝牙已关闭。
63.   // STATE_TURNING_ON        1        表示蓝牙正在打开。
64.   // STATE_ON        2        表示蓝牙已打开。
65.   // STATE_TURNING_OFF        3        表示蓝牙正在关闭。
66.   // STATE_BLE_TURNING_ON        4        表示蓝牙正在打开LE-only模式。
67.   // STATE_BLE_ON        5        表示蓝牙正处于LE-only模式。
68.   // STATE_BLE_TURNING_OFF        6        表示蓝牙正在关闭LE-only模式。
70.   public getBlueToothState(): access.BluetoothState {
71.     let state = access.getState();
72.     return state;
73.   }
75.   /**
76.    * 设置蓝牙访问(开关状态)
77.    * @param isAccess true: 打开蓝牙
78.    */
79.   setBlueToothAccess(isAccess: boolean, callbackBluetoothState: Callback<access.BluetoothState>){
80.     try {
81.       if(isAccess){
82.         console.info(this.TAG, 'bluetooth enableBluetooth 1');
83.         access.enableBluetooth();
84.         console.info(this.TAG, 'bluetooth enableBluetooth 2');
85.         access.on('stateChange', (data: access.BluetoothState) => {
86.           let btStateMessage = this.switchState(data);
87.           if (btStateMessage == 'STATE_ON') {
88.             access.off('stateChange');
89.           }
90.           console.info(this.TAG, 'bluetooth statues: ' + btStateMessage);
91.           callbackBluetoothState(data);
92.         })
93.       }else{
94.         console.info(this.TAG, 'bluetooth disableBluetooth 1');
95.         access.disableBluetooth();
96.         console.info(this.TAG, 'bluetooth disableBluetooth 2');
97.         access.on('stateChange', (data: access.BluetoothState) => {
98.           let btStateMessage = this.switchState(data);
99.           if (btStateMessage == 'STATE_OFF') {
100.             access.off('stateChange');
101.           }
102.           console.info(this.TAG, "bluetooth statues: " + btStateMessage);
103.           callbackBluetoothState(data);
104.         })
105.       }
106.     } catch (err) {
107.       console.error(this.TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
108.     }
109.   }
111.   private switchState(data: access.BluetoothState){
112.     let btStateMessage = '';
113.     switch (data) {
114.       case 0:
115.         btStateMessage += 'STATE_OFF';
116.         break;
117.       case 1:
118.         btStateMessage += 'STATE_TURNING_ON';
119.         break;
120.       case 2:
121.         btStateMessage += 'STATE_ON';
122.         break;
123.       case 3:
124.         btStateMessage += 'STATE_TURNING_OFF';
125.         break;
126.       case 4:
127.         btStateMessage += 'STATE_BLE_TURNING_ON';
128.         break;
129.       case 5:
130.         btStateMessage += 'STATE_BLE_ON';
131.         break;
132.       case 6:
133.         btStateMessage += 'STATE_BLE_TURNING_OFF';
134.         break;
135.       default:
136.         btStateMessage += 'unknown status';
137.         break;
138.     }
139.     return btStateMessage;
140.   }
142.   /**
143.    * 主播蓝牙广播
144.    */
145.   public registerBroadcast(){
146.     try {
147.       ble.on('advertisingStateChange', (data: ble.AdvertisingStateChangeInfo) => {
148.         console.info(this.TAG, 'bluetooth advertising state = ' + JSON.stringify(data));
149.         AppStorage.setOrCreate('advertiserState', data.state);
150.       });
151.     } catch (err) {
152.       console.error(this.TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
153.     }
154.   }
156.   /**
157.    * 开启蓝牙广播
158.    */
159.   public async startBroadcast(valueBuffer: Uint8Array){
161.     // 表示发送广播的相关参数。
162.     let setting: ble.AdvertiseSetting = {
163.       // 表示广播间隔，最小值设置160个slot表示100ms，最大值设置16384个slot，默认值设置为1600个slot表示1s。
164.       interval: 160,
165.       // 表示发送功率，最小值设置-127，最大值设置1，默认值设置-7，单位dbm。推荐值：高档(1)，中档(-7)，低档(-15)。
166.       txPower: 0,
167.       // 表示是否是可连接广播，默认值设置为true，表示可连接，false表示不可连接。
168.       connectable: true
169.     };
171.     // BLE广播数据包的内容。
172.     let manufactureDataUnit: ble.ManufactureData = {
173.       // 表示制造商的ID，由蓝牙SIG分配。
174.       manufactureId: 4567,
175.       manufactureValue: valueBuffer.buffer
176.     };
178.     let serviceValueBuffer = new Uint8Array(4);
179.     serviceValueBuffer[0] = 5;
180.     serviceValueBuffer[1] = 6;
181.     serviceValueBuffer[2] = 7;
182.     serviceValueBuffer[3] = 8;
184.     // 广播包中服务数据内容。
185.     let serviceDataUnit: ble.ServiceData = {
186.       serviceUuid: "00001888-0000-1000-8000-00805f9b34fb",
187.       serviceValue: serviceValueBuffer.buffer
188.     };
190.     // 表示广播的数据包内容。
191.     let advData: ble.AdvertiseData = {
192.       serviceUuids: ["00001888-0000-1000-8000-00805f9b34fb"],
193.       manufactureData: [manufactureDataUnit],
194.       serviceData: [serviceDataUnit],
195.       includeDeviceName: false // 表示是否携带设备名，可选参数。注意带上设备名时广播包长度不能超出31个字节。
196.     };
198.     // 表示回复扫描请求的响应内容。
199.     let advResponse: ble.AdvertiseData = {
200.       serviceUuids: ["00001888-0000-1000-8000-00805f9b34fb"],
201.       manufactureData: [manufactureDataUnit],
202.       serviceData: [serviceDataUnit]
203.     };
205.     // 首次启动广播设置的参数。
206.     let advertisingParams: ble.AdvertisingParams = {
207.       advertisingSettings: setting,
208.       advertisingData: advData,
209.       advertisingResponse: advResponse,
210.       //         表示发送广播持续的时间。单位为10ms，有效范围为1(10ms)到65535(655350ms)，如果未指定此参数或者将其设置为0，则会连续发送广播。
211.       duration: 0 // 可选参数，若大于0，则广播发送一段时间后，则会临时停止，可重新启动发送
212.     }
214.     // 首次启动广播，且获取所启动广播的标识ID
215.     try {
216.       this.registerBroadcast();
217.       this.advHandle = await ble.startAdvertising(advertisingParams);
218.     } catch (err) {
219.       console.error(this.TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
220.     }
221.   }
223.   /**
224.    * 开始蓝牙扫描
225.    */
226.   public startScanDevice(callback: Callback<Array<string>>){
227.     try {
228.       connection.on('bluetoothDeviceFind', (data: Array<string>)=>{
229.         // 随机MAC地址
230.         console.info(this.TAG, 'bluetooth device bluetoothDeviceFind = '+ JSON.stringify(data));
231.         callback(data);
232.       });
233.       connection.startBluetoothDiscovery();
234.     } catch (err) {
235.       console.error(this.TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
236.     }
237.   }
239.   /**
240.    * 停止蓝牙扫描
241.    */
242.   public stopScanDevice(){
243.     try {
244.       connection.off('bluetoothDeviceFind');
245.       connection.stopBluetoothDiscovery();
246.     } catch (err) {
247.       console.error(this.TAG, 'errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
248.     }
249.   }
251.   public getDeviceName(deviceID: string){
252.     let remoteDeviceName: string = "";
253.     try {
254.       remoteDeviceName = connection.getRemoteDeviceName(deviceID);
255.       console.info(this.TAG, 'getDeviceName device = '+ JSON.stringify(remoteDeviceName));
256.     } catch (err) {
257.       console.error(this.TAG, 'getDeviceName errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
258.     }
259.     return remoteDeviceName;
260.   }
262.   public getDeviceClass(deviceID: string){
263.     let remoteDeviceClass: string = "";
264.     try {
265.       let classObj = connection.getRemoteDeviceClass(deviceID);
266.       remoteDeviceClass = JSON.stringify(classObj);
267.     } catch (err) {
268.       console.error(this.TAG, 'getDeviceName errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
269.     }
270.     return remoteDeviceClass;
271.   }
273.   // BondState
274.   // BOND_STATE_INVALID        0        无效的配对。
275.   // BOND_STATE_BONDING        1        正在配对。
276.   // BOND_STATE_BONDED        2        已配对。
278.   /**
279.    * 发起配对蓝牙
280.    */
281.   public pairDevice(deviceID: string){
282.     try {
283.       connection.on('bondStateChange', (data: connection.BondStateParam) =>{
284.         console.info(this.TAG, 'pairDevice pair state = '+ JSON.stringify(data));
285.         // 当蓝牙配对类型PinType为PIN_TYPE_ENTER_PIN_CODE或PIN_TYPE_PIN_16_DIGITS时调用此接口，请求用户输入PIN码。
286.       });
287.       connection.pairDevice(deviceID, (err: BusinessError) => {
288.         console.info(this.TAG, 'pairDevice device name err:' + JSON.stringify(err));
289.       });
290.     } catch (err) {
291.       console.error(this.TAG, 'pairDevice errCode: ' + (err as BusinessError).code + ', errMessage: ' + (err as BusinessError).message);
292.     }
293.   }
295. }

复制代码

         

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