uniapp操作蓝牙工具类

最新推荐文章于 2024-10-08 22:23:32 发布
最新推荐文章于 2024-10-08 22:23:32 发布
阅读量4k 收藏 16
点赞数 1
分类专栏： uniapp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41217541/article/details/114010343
版权

上代代码

蓝牙类

import {
	storage,
	keys
} from '../utils/js/storage.js'
import store from '../store/index.js'
export default class ble {
	constructor() {
		let that = this;
		// 用户绑定了的设备
		this.userBind = [];
		// 蓝牙开启状态
		this.startFlag = false
		// 蓝牙是否开启适配器
		this.startAdapter = false
		//搜索到的所有的设备的数组
		this.deviceArray = [];
		// 正在连接的智能尺id
		this.deviceId = ''

		this.serviceId = "6E400001-B5A3-F393-E0A9-E50E54DCCAA9";
		this.readCharacteristicId = "6E400003-B5A3-F393-E0A9-E50E54DCCAA9";
		this.writeCharacteristicId = "6E400002-B5A3-F393-E0A9-E50E54DCCAA9";

		// 开启蓝牙
		this.openBluetooth()
		
		// this.openBluetoothAdapter()
		// 监听客户是否主动打开蓝牙
		setInterval(() => {
			this.intervalBluStart()
		}, 1200)
	}
	openBluetooth() {
		let that = this
		let main, BluetoothAdapter, BAdapter, Context, BManager;

		switch (uni.getSystemInfoSync().platform) {
			case 'android':
				main = plus.android.runtimeMainActivity()
				BluetoothAdapter = plus.android.importClass('android.bluetooth.BluetoothAdapter')
				BAdapter = BluetoothAdapter.getDefaultAdapter()

				if (!BAdapter.isEnabled()) {
					let a = BAdapter.enable()
					console.log(a)
					if (a) {
						let checkedNum = 5

						let b = setInterval(() => {
							checkedNum--
							if (checkedNum < 0) {
								clearInterval(b)
								// 适配器开启失败
								uni.showToast({
									title: '蓝牙未打开，请打开蓝牙！',
									icon: 'none',
									duration: 3000
								})
							} else {
								if (BAdapter.isEnabled()) {
									that.openBluetoothAdapter()
									clearInterval(b)
								}
							}
						}, 1000)
					} else {
						// 适配器开启失败
						let b = setTimeout(() => {
							uni.showToast({
								title: '蓝牙未打开，请打开蓝牙！',
								icon: 'none',
								duration: 3000
							})
							clearTimeout(b)
						}, 1600)
					}
				}
				break

		}
	}
	// 定时监听蓝牙是否开启
	intervalBluStart() {
		let that = this
		let main, BluetoothAdapter, BAdapter, Context, BManager;

		switch (uni.getSystemInfoSync().platform) {
			case 'android':
				main = plus.android.runtimeMainActivity()
				BluetoothAdapter = plus.android.importClass('android.bluetooth.BluetoothAdapter')
				BAdapter = BluetoothAdapter.getDefaultAdapter()

				if (BAdapter.isEnabled()) {
					//console.log('startAdapter',that.startAdapter)
					// 蓝牙以打开，并且没有开启适配器
					if (!that.startAdapter) {
						that.openBluetoothAdapter()
					}
				}
				break
		}
}
//添加事件监听器
addEvent() {

	let that = this;
	/**
	 * 开始搜索设备
	 * @param {String} data 已经绑定了的设备id
	 * */
	uni.$on("scanEquipment", function(data) {
		that.startBluetoothDevicesDiscovery();
	})
	/**
	 * 创建连接
	 * @param {String} deviceId 需要连接的设备id
	 * */
	uni.$on("createCon", function(deviceId) {
		console.log('收到创建事件:', deviceId)
		that.createBLEConnection(deviceId)
	})
	// 断开蓝牙连接
	uni.$on('closeBLEConnection', (deviceId) => {
		that.closeBLEConnection(deviceId)
	})

	/**
	 * 向蓝牙发送数据
	 * @param {buffArray} 数组 需要发送的数据
	 * */
	uni.$on("writeTodevice", function(buffArray) {
		that.writeBLECharacteristicValue(buffArray)
	})

	/**
	 * 停止扫描蓝牙设备
	 * */
	uni.$on("stopScan", function() {
		that.stopBluetoothDevicesDiscovery();
	})
	/**
	 * 搜索并连接已经绑定的设备
	 * */
	uni.$on("bindCreateCon", function(list) {
		console.log("已绑定的设备调用连接");
		console.log(list);
		console.log(storage.getStorageSync("devicelist"))
		that.startBluetoothDevicesDiscovery();
	})
	console.log('开始监听蓝牙事件')
}
openBluetoothAdapter() {
	console.log('打开蓝牙适配器')
	let that = this
	uni.openBluetoothAdapter({
		success() {
			console.log("openBluetoothAdapter success")
			that.startAdapter = true
			that.startFlag = false
			that.addEvent();
			//监听寻找到新设备
			that.onBluetoothDeviceFound()
			//监听连接状态
			that.onBLEConnectionStateChange();
			//监听值的变化
			that.onBLECharacteristicValueChange();
			// 主动连接已绑定过得设备
			that.getBluetoothDevices()
			
			uni.$emit("bindCreateCon",null)
		},
		fail() {
			this.startFlag = false
			console.log("openBluetoothAdapter fail")

			uni.showToast({
				title: '蓝牙未打开，请打开蓝牙！',
				icon: 'none',
				duration: 3000
			})
		}
	})
}
// 获取在蓝牙模块生效期间所有已发现的蓝牙设备
getBluetoothDevices(){
	 uni.getBluetoothDevices({
	   success(res) {
	     console.log(JSON.stringify(res))
	     if (res.devices[0]) {
	      
	     }
	   }
	 })
}
/**
 * 开始搜寻附近的蓝牙外围设备。此操作比较耗费系统资源
 * @param {String} data 要过滤的id  
 * */
startBluetoothDevicesDiscovery(data) {
	uni.startBluetoothDevicesDiscovery({
		// services: [],
		allowDuplicatesKey: true,
		interval: 0,
		success(e) {
			console.log("调用搜索设备成功", JSON.stringify(e))
		},
		fail() {
			console.log("调用搜索设备失败")
		}
	})
}
//监听寻找到新设备的事件
onBluetoothDeviceFound() {
	var that = this;
	console.log('监听寻找到新设备的事件')
	uni.onBluetoothDeviceFound(function(devices) {
		//console.log('新设备', JSON.stringify(devices))
		if (devices.devices[0].name == "meter") {
			let mydevices = devices
			mydevices.devices = mydevices.devices.filter(item => {

				if (item.name == "meter") {
					return item
				}
			})
			uni.$emit("deviceFound", mydevices)
			let deviceArray = devices.devices;
			for (let i = 0; i < deviceArray.length; i++) {
				that.deviceArray.push(deviceArray[i])
			}
			console.log(JSON.stringify(devices))
			let userBind = storage.getStorageSync("devicelist");
			console.log(userBind)
			for (let i = 0; i < userBind.length; i++) {
				if (devices.devices[0].deviceId == userBind[i].devicId) {
					console.log("是已经绑定的设备")
					that.createBLEConnection(devices.devices[0].deviceId)
					break;
				}
			}
		}
	},(e)=>{
		console.log(JSON.stringify(e))
	})
}
// 断开蓝牙连接
closeBLEConnection(deviceId) {
	if (!deviceId) return;
	uni.closeBLEConnection({
		deviceId,
		success(res) {
			console.log(res)
		},
		fail() {

		}
	})
}
/**
 * 开始连接设备
 * @param {String} deviceId  需要连接的设备id
 * */
createBLEConnection(deviceId) {
	let that = this
	if (deviceId && deviceId == this.deviceId) {
		return uni.showToast({
			title: '蓝牙已连接',
			icon: 'none',
			duration: 4000
		})
	} else if (deviceId && deviceId != this.deviceId) {
		let id = this.deviceId
		uni.closeBLEConnection({
			id,
			success(res) {
				that.createConnetFunction(deviceId)
			},
			fail() {
				that.createConnetFunction(deviceId)
			}
		})
		return
	}
}
createConnetFunction(deviceId) {
	let that = this;
	let serverArry = that.deviceArray;
	let contentStatus = false;
	uni.showToast({
		title: '连接中...',
		icon: 'loading',
		duration: 4000
	})
	uni.createBLEConnection({
		deviceId: deviceId,
		timeout: 4000,
		success: () => {
			that.deviceId = deviceId
			uni.$emit('deviceConnectChange', deviceId)
			// todo修改连接状态

			uni.showToast({
				title: '蓝牙连接成功',
				icon: 'none',
				duration: 2000
			})

		},
		fail: (e) => {
			uni.showToast({
				title: '蓝牙连接失败',
				icon: 'none',
				duration: 3000
			})
		}
	})
}
//监听低功耗蓝牙连接状态的改变事件。包括开发者主动连接或断开连接，设备丢失，连接异常断开等等
onBLEConnectionStateChange() {
	let that = this;
	uni.onBLEConnectionStateChange(function(res) {
		console.log("监听到设备连接状态" + JSON.stringify(res))
		if (res.connected == true) {
			that.deviceId = res.deviceId
			uni.$emit("ConnectEd", res)
			uni.$emit('deviceConnectChange', that.deviceId)
			that.stopBluetoothDevicesDiscovery();
			let userBind = storage.getStorageSync("devicelist");
			for (let i = 0; i < userBind.length; i++) {
				if (userBind[i].devicId == res.deviceId) {
					userBind[i].is_content = true;
					userBind[i].connected = true;
					storage.setStorageSync("devicelist", userBind)
				}
			}
			console.log(storage.getStorageSync("devicelist"))

			setTimeout(function() {
				that.notifyBLECharacteristicValueChange();
			}, 2000)
		} else {
			that.startAdapter = false
			that.deviceId = ''
			uni.$emit('deviceConnectChange', that.deviceId)

			uni.showToast({
				title: '蓝牙连接断开',
				icon: 'none',
				duration: 3000
			})
		}
	})
}
//启用低功耗蓝牙设备特征值变化时的 notify 功能，
notifyBLECharacteristicValueChange() {
	uni.notifyBLECharacteristicValueChange({
		deviceId: this.deviceId,
		serviceId: this.serviceId,
		characteristicId: this.readCharacteristicId,
		state: true,
		success(res) {
			console.log("开启notify服务成功" + JSON.stringify(res))
		},
		fail(ret) {
			console.log("开启notify服务失败" + JSON.stringify(ret))
		}
	})
}
//监听低功耗蓝牙设备的特征值变化事件。必须先启用 notifyBLECharacteristicValueChange 接口才能接收到设备推送的 notification。
onBLECharacteristicValueChange() {

	let that = this;
	uni.onBLECharacteristicValueChange(function(res) {

		let valueInfo = that.ab2hex(res.value);

		if (valueInfo.substr(3, 1) != 1) {
			console.log("数据变化了" + valueInfo)
			uni.$emit("deviceValueChange", valueInfo);
		}
		if (valueInfo.substr(3, 1) == 2) {
			// 确认单次数据
			console.log("获取到数据" + valueInfo)
			console.log(valueInfo.substr(8, 2) + valueInfo.substr(6, 2))
		}
	})
}
//写入数据
writeBLECharacteristicValue(ArrayBuff) {
	let that = this;

	// 向蓝牙设备发送一个0x00的16进制数据
	const buffer = new ArrayBuffer(ArrayBuff.length)

	const dataView = new DataView(buffer)
	for (let i = 0; i < ArrayBuff.length; i++) {
		dataView.setUint8(i, ArrayBuff[i])
	}

	var hex = ArrayBuff //要发送的信息
	console.log('要发送的信息是：' + hex)
	var typedArray = new Uint8Array(hex.match(/[\da-f]{2}/gi).map(function(h) {
		return parseInt(h, 16)
	}))
	console.log(typedArray)
	var buffer1 = typedArray.buffer
	console.log("写入数据" + this.ab2hex(buffer) + '-buffer1:' + buffer1 + '-str:' + this.ab2hex(buffer1))

	uni.writeBLECharacteristicValue({
		deviceId: that.deviceId,
		serviceId: that.serviceId,
		characteristicId: that.writeCharacteristicId,
		value: buffer1,
		success(res) {
			console.log('writeBLECharacteristicValue success', JSON.stringify(res))
		},
		fail(res) {
			console.log('writeBLECharacteristicValue fail', JSON.stringify(res))
		},
		complete(res) {
			console.log('writeBLECharacteristicValue compe', JSON.stringify(res))
		}
	})
}
//停止扫描蓝牙设备
stopBluetoothDevicesDiscovery() {
	console.log("停止扫描设备");
	uni.stopBluetoothDevicesDiscovery({
		success(res) {
			console.log(res)
		}
	})
}
// ArrayBuffer转16进度字符串示例
ab2hex(buffer) {
	const hexArr = Array.prototype.map.call(
		new Uint8Array(buffer),
		function(bit) {
			return ('00' + bit.toString(16)).slice(-2)
		}
	)
	return hexArr.join('')
}
string2buffer(str) {
	// 首先将字符串转为16进制
	let val = ""
	for (let i = 0; i < str.length; i++) {
		if (val === '') {
			val = str.charCodeAt(i).toString(16)
		} else {
			val += ',' + str.charCodeAt(i).toString(16)
		}
	}
	// 将16进制转化为ArrayBuffer
	return new Uint8Array(val.match(/[\da-f]{2}/gi).map(function(h) {
		return parseInt(h, 16)
	})).buffer
}
}

储存类storage.js

export const keys = {
   
}
class Storage {
    constructor() {

    }
    //存储在本地缓存指定的name中
    setStorageSync(name, data) {

            try {
                data = JSON.stringify(data)
                uni.setStorageSync(name, data);
            } catch (e) {
                console.log(e)
            }
        }
        //存储在本地缓存指定的name中(异步)
    setStorage(name, data) {
            try {
                data = JSON.stringify(data)
                uni.setStorage(name, data);
            } catch (e) {
                console.log(e)
            }
        }
        //从本地缓存中读取置顶name对应的内容(异步)
    getStorage(name) {
            let data;
            try {
                data = uni.getStorage(name);
            } catch (e) {
                console.log(e);
            }
            return data;
        }
        //从本地缓存中读取置顶name对应的内容
    getStorageSync(name) {
            let data;
            try {
                data = uni.getStorageSync(name);
                if (data) {
                    data = JSON.parse(data)
                }

            } catch (e) {
                console.log(e);
            }
            return data;
        }
        //从本地缓存中移出指定key
    removeStorageSync(name) {
            try {
                uni.removeStorageSync(name);
            } catch (e) {
                //TODO handle the exception
                console.log(e);
            }
        }
        //从本地缓存中移出指定key（异步）
    removeStorage(name) {
            try {
                uni.removeStorage(name);
            } catch (e) {
                //TODO handle the exception
                console.log(e);
            }
        }
        //返回一个布尔值,表示name是否在本地缓存之中
    checkStorageSync(name) {
            let value;
            try {
                const res = uni.getStorageInfoSync()
                value = res.keys.includes(name)
            } catch (e) {
                console.log(e)
            }
            return value
        }
        //返回一个布尔值,表示name是否在本地缓存之中（异步）
    checkStorage(name) {
            let value;
            try {
                const res = uni.getStorageInfo()
                value = res.keys.includes(name)
            } catch (e) {
                console.log(e)
            }
            return value
        }
        //清除本地数据缓存
    clearStorageSync() {
            try {
                uni.clearStorageSync();
            } catch (e) {
                console.log(e)
            }
        }
        //清除本地数据缓存（异步）
    clearStorage() {
        try {
            uni.clearStorage();
        } catch (e) {
            console.log(e)
        }
    }
}
export const storage = new Storage();
丢失的林夕
关注
专栏目录
uniapp-蓝牙篇1
yyx1958025835的博客
05-22 8151
作者自述，参考文献： 1.uniapp官网蓝牙api地址，参考模块（蓝牙，低功耗蓝牙）https://uniapp.dcloud.io/api/system/bluetooth 2.其他人写的demo（10个赞），看完基本上逻辑能清楚https://ask.dcloud.net.cn/article/36374 3.其他人写的demo（主要借鉴字符串写法），如果只需要传数字看前两篇就够了https://github.com/Jazei/uniapp-miniprogram-BuletoothPrin.
Uni-app实现蓝牙搜索、连接、传送数据实例
syq8023的博客
02-22 6742
<template> <!-- 自定义导航栏 --> <view class="bluetooth"> <view class="navBarBox"> <!-- 状态栏占位 --> <view class="statusBar" :style="{ paddingTop: statusBarHeight + 'px' }"></view> <!-- 真正的导航栏内容 -->.
uniapp-tools:uniapp工具类
05-10
uniapp-tools (停止维护) uniapp工具类
2021-04-17
llykingsohyun的博客
04-17 149
js 工具类 let _debounceTimeout = null, _throttleRunning = false /** * 防抖 * @param {Function} 执行函数 * @param {Number} delay 延时ms */ export const debounce = (fn, delay=500) => { clearTimeout(_debounceTimeout); _debounceTimeout = setTi
uniapp启用蓝牙
最新发布
bjxlyy的博客
10-08 335
uniapp蓝牙功能
uniapp-蓝牙模块封装
big_asm的博客
03-23 1375
蓝牙模块封装好了开箱即用里面有注释，有什么问题可直接提出来 连接地址： bluetooth module
uniapp 连接蓝牙 并下发命令
weixin_50236740的博客
12-28 1287
2:在你需要用到vue页面中引入 ly.js。1：创建ly.js 文件。3：连接蓝牙并下发命令。
uniapp封装连接蓝牙设备/蓝牙打印机
wilL-my的博客
01-27 3657
bluetooth.js import store from '@/store/index.js'; class Bluetooth { constructor(arg) { this.isSearching = false; this.list = []; //蓝牙设备列表 this.services = []; this.serviceId = 0; this.writeCharacter = false; this.readCharacter = false; thi
uniapp-蓝牙模块连接
03-06
uniapp-蓝牙模块连接
uniapp实现蓝牙打印功能源码解析
- buffer：在处理蓝牙通信时，数据往往是以字节流的形式进行传输的，Buffer类是Node.js中的全局类，用于在TCP流和文件系统操作中处理二进制数据。 - js-base64：在蓝牙数据传输过程中，可能需要将文本数据转换为...
BluetoothPrinter-master_蓝牙打印_uniapp_uniapp真机logo_uniapp蓝牙打印_unia
09-30
"uniapp蓝牙打印"和"uniapp打印"进一步强调了此项目是关于uni-app平台的蓝牙打印解决方案，提供了完整的源码供开发者参考和使用。 由于标签部分为空，我们无法获得额外的分类信息，但可以推测这个项目可能包含以下...
uniapp 蓝牙封装
明耀的博客
03-12 1211
BLETool.js import VueFunc from "./vue-func.js" import Constant from './constant.js' export default { scanDeviceList: [], storageDeviceList: [], crtName: null, conState: -1, //销毁 0:未连接 1:正在连接 2:已连接 checkTimer: null, init() { this.openBluetoothAdap
IOS开发：UniAPP实现BLE低功耗蓝牙开发1
热门推荐
努力才是唯一的入场券。
03-27 4万+
Uni-app介绍 uni-app 是使用 Vue.js 开发跨平台应用的前端框架，开发者编写一套代码，可编译到iOS、Android、H5、小程序等多个平台。 Uni-app优点 BLE开发流程 1、初始化蓝牙 uni.openBluetoothAdapter(OBJECT) 2、开始搜索蓝牙设备 uni.startBluetoothDevicesDiscovery(OBJECT) 3、发现外围设备 uni.onBluetoothDeviceFound(CALLBACK) 4、停止搜寻附近的蓝牙外围设
uni-app微信小程序如何开发蓝牙功能
您的博客
11-14 3217
uni-app小程序中开发蓝牙功能，uni-app微信小程序对接蓝牙功能，微信小程序开发蓝牙功能，支付宝小程序开发蓝牙功能。
uniapp 蓝牙模块封装
qq_44695769的博客
06-27 1526
实例化。
uni-app 蓝牙传输
yanhhillo的博客
07-11 986
最近在做一个项目，要求app通过蓝牙连接设备并将报文传输至设备中，在这个过程踩过了几个坑，总结如下：根据uni-app官网API主要涉及到“蓝牙”和“低功耗蓝牙”两个部分。
uniapp蓝牙连接操作详解
qq_52151772的博客
08-10 3976
蓝牙对接硬件操作详解
uniapp开发考试答题类小程序教程
资源摘要信息: "uniapp开发的考试答题类小程序.zip" 知识点说明： 1. uni-app框架： - uni-app是一个使用Vue.js开发所有前端应用的框架，能够编译到iOS、Android、H5、以及各种小程序等多个平台。 - 它提供了...
uni-app与蓝牙设备的传输
BlessingDN的博客
09-03 1万+
1、初始化蓝牙模块 2、搜索蓝牙设备 3、连接蓝牙设备 4、选择设备服务 5、获取服务的特征值 以上步骤与官网相同，详细文档请查看uni-app蓝牙API 6、订阅特征值 只有订阅特征值以后设备的特征值变化才能触发uni.onBLECharacteristicValueChange 回调 /** * 订阅操作成功后需要设备主动更新特征值的 value，才会触发 uni.onBL...
uniapp 蓝牙连接测温仪
qq_32439381的博客
06-17 1206
需求：app通过蓝牙连接硬件测温仪，使用uniapp的ble蓝牙连接
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值