let tempTimer = 0;
let util = null;
let mDeviceEvent = null;
let mac_id;
let self = {
	data: {
		deviceId: null,
		isConnected: false,
		failure: false,
		value: 0,
		desc: "请耐心等待...",
		isChecksum: true,
		isEncrypt: true,
		flagEnd: false,
		defaultData: 1,
		ssidType: 2,
		passwordType: 3,
		meshIdType: 3,
		deviceId: "",
		ssid: "",
		uuid: "",
		serviceId: "",
		password: "",
		meshId: "",
		processList: [],
		result: [],
		service_uuid: "000000FF-0000-1000-8000-00805F9B34FB",
		characteristic_write_uuid: "0000FF01-0000-1000-8000-00805F9B34FB",
		characteristic_read_uuid: "0000FF02-0000-1000-8000-00805F9B34FB",
		customData: null,
		md5Key: 0
	}
};

function Utf8ArrayToStr(buffer) {
	var out, i, len, c;
	var char2, char3;
	var array = new Uint8Array(buffer)
	// console.log('array',array);
	// console.log('array.ArrayBuffer',array.ArrayBuffer);
	// console.log('array[[Uint8Array]]',array.ArrayBuffer);
	out = "";
	len = array.length;
	i = 0;
	// console.log('len',len);
	while (i < len) {
		c = array[i++];
		switch (c >> 4) {
			case 0:
			case 1:
			case 2:
			case 3:
			case 4:
			case 5:
			case 6:
			case 7:
				// 0xxxxxxx
				out += String.fromCharCode(c);
				break;
			case 12:
			case 13:
				// 110x xxxx 10xx xxxx
				char2 = array[i++];
				out += String.fromCharCode(((c & 0x1F) << 6) | (char2 & 0x3F));
				break;
			case 14:
				// 1110 xxxx 10xx xxxx 10xx xxxx
				char2 = array[i++];
				char3 = array[i++];
				out += String.fromCharCode(((c & 0x0F) << 12) |
					((char2 & 0x3F) << 6) |
					((char3 & 0x3F) << 0));
				break;
		}
	}
	// console.log('out',out);
	return out;
}





function string2buffer(str) {
	var bytes = new Array();
	for (var i = 0; i < str.length; i++) {
		var c = str.charCodeAt(i);
		var s = parseInt(c).toString(2);
		if (c >= parseInt('000080', 16) && c <= parseInt('0007FF', 16)) {
			var af = '';
			for (var j = 0; j < (11 - s.length); j++) {
				af += '0';
			}
			af += s;
			var n1 = parseInt('110' + af.substring(0, 5), 2);
			var n2 = parseInt('110' + af.substring(5), 2);
			if (n1 > 127) n1 -= 256;
			if (n2 > 127) n2 -= 256;
			bytes.push(n1);
			bytes.push(n2);
		} else if (c >= parseInt('000800', 16) && c <= parseInt('00FFFF', 16)) {
			var af = '';
			for (var j = 0; j < (16 - s.length); j++) {
				af += '0';
			}
			af += s;
			var n1 = parseInt('1110' + af.substring(0, 4), 2);
			var n2 = parseInt('10' + af.substring(4, 10), 2);
			var n3 = parseInt('10' + af.substring(10), 2);
			if (n1 > 127) n1 -= 256;
			if (n2 > 127) n2 -= 256;
			if (n3 > 127) n3 -= 256;
			bytes.push(n1);
			bytes.push(n2);
			bytes.push(n3);
		} else if (c >= parseInt('010000', 16) && c <= parseInt('10FFFF', 16)) {
			var af = '';
			for (var j = 0; j < (21 - s.length); j++) {
				af += '0';
			}
			af += s;
			var n1 = parseInt('11110' + af.substring(0, 3), 2);
			var n2 = parseInt('10' + af.substring(3, 9), 2);
			var n3 = parseInt('10' + af.substring(9, 15), 2);
			var n4 = parseInt('10' + af.substring(15), 2);
			if (n1 > 127) n1 -= 256;
			if (n2 > 127) n2 -= 256;
			if (n3 > 127) n3 -= 256;
			if (n4 > 127) n4 -= 256;
			bytes.push(n1);
			bytes.push(n2);
			bytes.push(n3);
			bytes.push(n4);
		} else {
			bytes.push(c & 0xff);
		}
	}

	let array = [];
	for (let i = 0; i < bytes.length; i++) {
		array[i] = bytes[i]
	}
	let array_int8 = Uint8Array.from(array)

	return array_int8.buffer;
}
function buf2hex(buffer) {
	return Array.prototype.map.call(new Uint8Array(buffer), x => ('00' + x.toString(16)).slice(-2)).join('');
}


let attemptCount = 0;
let re_connect = 0;
function get_fuwu(deviceId) {
	attemptCount++;
	console.log("服务发现", deviceId)
	uni.getBLEDeviceServices({
		// 这里的 deviceId 需要已经通过 createBLEConnection 与对应设备建立链接
		deviceId: deviceId,
		success: function (res) {
			console.log("服务发现456", deviceId, res.services)
			var services = res.services;
			//"000000FF-0000-1000-8000-00805F9B34FB"
			if (services.length > 0) {
				for (var i = 0; i < services.length; i++) {
					if (services[i].uuid === self.data.service_uuid) {
						// re_connect = 0;
						attemptCount = 0;

						var serviceId = services[i].uuid;
						console.log("这里有进去")
						uni.getBLEDeviceCharacteristics({
							deviceId: deviceId,
							serviceId: serviceId,
							success: function (res) {
								console.log("获取蓝牙子")
								var list = res.characteristics;
								if (list.length > 0) {
									console.log("list@@@@@@@", list)
									for (var i = 0; i < list.length; i++) {
										var uuid = list[i].uuid;
										console.log("uuid", uuid)
										if (uuid == self.data.characteristic_write_uuid) {
											self.data.serviceId = serviceId;
											self.data.uuid = uuid;
											console.log("uuid", uuid)
											uni.notifyBLECharacteristicValueChange({
												state: true,
												// 启用 notify 功能
												deviceId: deviceId,
												serviceId: serviceId,
												characteristicId: list[0].uuid,
												success: function (res) {

													console.log("成功", res)
													setTimeout(() => {
														const mtu = 212;
														uni.setBLEMTU({
															deviceId: self.data.deviceId,
															mtu,
															success: (
																res
															) => {
																console
																	.log(
																		"set1212BLEMTU success>>",
																		res
																	)
															},
															fail: (
																res
															) => {
															},
														});
													}, 1000);

													uni.onBLECharacteristicValueChange(function (res) {
														var my_str = Utf8ArrayToStr(res.value)
														if (my_str.indexOf("wifi_ok") != -1) {
															console.log("获取到wifiok设备数据OK", my_str);
															mDeviceEvent.notifyDeviceMsgEvent({
																'type': mDeviceEvent.XBLUFI_TYPE.TYPE_CONNECT_ROUTER_RESULT,
																'result': true,
																'data': {
																	'progress': 100,
																	'ssid': ""
																}
															});
														} else if (my_str.indexOf("wifi_err") != -1) {
															console.log("获取到设备数据失败", my_str);
															mDeviceEvent.notifyDeviceMsgEvent({
																'type': mDeviceEvent.XBLUFI_TYPE.TYPE_CONNECT_ROUTER_RESULT,
																'result': false,
																'data': {
																	'progress': 0,
																	'ssid': ""
																}
															});
														}
														else {
															let obj = {
																'type': mDeviceEvent.XBLUFI_TYPE.TYPE_RECIEVE_CUSTON_DATA,
																'result': true,
																'data': my_str
															};
															mDeviceEvent.notifyDeviceMsgEvent(obj);

														}
													});
												},
												fail: function (res) {

													console.log("监听", res)
													uni.onBLECharacteristicValueChange(function (res) {
														var my_str = Utf8ArrayToStr(res.value)
														{
															let obj = {
																'type': mDeviceEvent.XBLUFI_TYPE.TYPE_RECIEVE_CUSTON_DATA,
																'result': true,
																'data': my_str
															};
															mDeviceEvent.notifyDeviceMsgEvent(obj);

														}
													});
												}
											});
										}
									}
								}
							},
							fail: function (res) {

							}
						});
						break;
					}

				}

			}
			// else
			{
				if (attemptCount > 0 && attemptCount < 10) {
					console.log('进入');
					re_connect = 1;
					setTimeout(() => {
						get_fuwu(deviceId); // 递归调用自身以重试  
					}, 1000); // 延迟1秒后重试  
					
					// uni.closeBLEConnection({
					// 	deviceId: self.data.deviceId,
					// 	success: function (res) {
					// 		console.log('断开成功', self.data.deviceId);
					// 		uni.createBLEConnection({
					// 			deviceId: self.data.deviceId,
					// 			success: function (res) {
					// 				console.log("链接成功？", re_connect);
					// 				re_connect = 0;
					// 				setTimeout(() => {
					// 					get_fuwu(deviceId); // 递归调用自身以重试  
					// 				}, 1000); // 延迟1秒后重试  
					// 			},
					// 			fail: function (res) {
					// 				console.log("链接失败", re_connect);
					// 				re_connect = 1;
					// 				attemptCount = 0;
					// 				let obj = {
					// 					'type': mDeviceEvent.XBLUFI_TYPE.TYPE_STATUS_CONNECTED,
					// 					'result': res.connected,
					// 					'data': res
					// 				};
					// 				mDeviceEvent.notifyDeviceMsgEvent(obj);
					// 			}
					// 		})
					// 	},
					// 	fail: function (res) {
					// 		re_connect = 0;
					// 		attemptCount = 0;
					// 		console.log("断开123失败", re_connect);
					// 		let obj = {
					// 			'type': mDeviceEvent.XBLUFI_TYPE.TYPE_STATUS_CONNECTED,
					// 			'result': res.connected,
					// 			'data': res
					// 		};
					// 		mDeviceEvent.notifyDeviceMsgEvent(obj);
					// 	}
					// });
				}
				else {
					re_connect = 0;
					attemptCount = 0;

				}
			}
		},
		fail: function (res) {
			console.log("服务发现失败", res)
		}
	});
}



// #define CMD_IAP_PROM 0x80   // IAP编程命令
// #define CMD_IAP_ERASE 0x81  // IAP擦除命令
// #define CMD_IAP_VERIFY 0x82 // IAP校验命令
// #define CMD_IAP_END 0x83    // IAP结束标志
// #define CMD_IAP_INFO 0x84   // IAP获取设备信息
// #define CMD_IAP_SUM 0x85    // 校验和
// #define CMD_OTHER 0xee      // 校验和

const CMD_IAP_PROM = 0x80;
const CMD_IAP_ERASE = 0x81;
const CMD_IAP_VERIFY = 0x82;
const CMD_IAP_END = 0x83;
const CMD_IAP_INFO = 0x84;
const CMD_IAP_SUM = 0x85;

function write_cmd_erase(deviceId, serviceId, characteristicId, data) {

	var value = util.write_ota_erase(CMD_IAP_ERASE, 4, 0, 0);
	var typedArray = new Uint8Array(value);
	console.log("送擦除数据")
	uni.writeBLECharacteristicValue({
		deviceId: deviceId,
		serviceId: serviceId,
		characteristicId: characteristicId,
		value: typedArray.buffer,
		// value: buffer,
		success: function (res) {
			//console.log("送数据成功")
		},
		fail: function (res) { //console.log(257);
		}
	});
}



function send_ota_data(deviceId, serviceId, characteristicId, data) {
	return new Promise(function (resolve, reject) {
		uni.writeBLECharacteristicValue({
			deviceId: deviceId,
			serviceId: serviceId,
			characteristicId: characteristicId,
			value: data,
			// value: buffer,
			success: function (res) {
				//console.log("送数据成功")
				let obj = {
					'type': mDeviceEvent
						.XBLUFI_TYPE
						.TYPE_RECIEVE_MY_DATA,
					'result': true,
					'data': 99
				};
				mDeviceEvent
					.notifyDeviceMsgEvent(
						obj
					);

				resolve(res)
			},
			fail: function (res) {
				//console.log("送数据失败")
				reject(res)
			}
		});
	});
}
let send_num = 0
function send_ota_data_num(deviceId, serviceId, characteristicId, data, num) {
	return new Promise(function (resolve, reject) {
		// console.log("送数12据")
		if (send_num++ % 5 == 0) {
			uni.writeBLECharacteristicValue({
				deviceId: deviceId,
				serviceId: serviceId,
				characteristicId: characteristicId,
				value: data,
				writeType: 'write',
				success: function (res) {
					res = true
					resolve(res)
				},
				fail: function (res) {
					res = false
					//console.log("送数据失败")
					// reject(FALSE)
					reject(res)
				}
			});
		}
		else {
			uni.writeBLECharacteristicValue({
				deviceId: deviceId,
				serviceId: serviceId,
				characteristicId: characteristicId,
				value: data,
				writeType: 'writeNoResponse',
				success: function (res) {
					res = true
					resolve(res)
				},
				fail: function (res) {
					//console.log("送数据失败", res)
					res = false
					reject(res)
				}
			});
		}
	});
}

function send_end_data(deviceId, serviceId, characteristicId, data) {
	return new Promise(function (resolve, reject) {
		uni.writeBLECharacteristicValue({
			deviceId: deviceId,
			serviceId: serviceId,
			characteristicId: characteristicId,
			value: data,
			// value: buffer,
			success: function (res) {
				//console.log("送数据成功")
				let obj = {
					'type': mDeviceEvent
						.XBLUFI_TYPE
						.TYPE_RECIEVE_MY_DATA,
					'result': true,
					'data': 100
				};
				mDeviceEvent
					.notifyDeviceMsgEvent(
						obj
					);
				resolve(res)
			},
			fail: function (res) {
				//console.log("送数据失败")
				reject(res)
			}
		});
	});
}


function sleep6() {

	return new Promise(function (resolve, reject) {

		setTimeout(function () {

			resolve('ok');

		}, 6000);

	});

}

var StreamBinaryString = function (s) {
	this._p = 0;
	this._s = this.fromBinaryString(s);
};
StreamBinaryString.prototype = {
	constructor: StreamBinaryString,

	fromBinaryString(e) {
		var t = e || '';
		var f = [];
		for (var i = 0; i < t.length; i++) {
			f[i] = String.fromCharCode(t.charCodeAt(i) & 255);
		}
		return f.join('');
	},

	read: function (array, offset, count) {
		if (arguments.length == 1) {
			var result = this._s.substr(this._p, array);
			this._p += array;
			return result;
		} else {
			var result = 0;
			for (var i = 0; i < count; i++) {
				array[i] = this._s.charCodeAt(this._p);
				this._p += 1;
				result++;
			}
			return result;
		}
	},

	readByte: function () {
		var result = this._s.charCodeAt(this._p);
		this._p += 1;
		return result;
	},

	readInt8: function (signed) {
		var result = this._s.charCodeAt(this._p);
		if (signed && result > 127) {
			result -= 256;
		}
		this._p += 1;
		return result;
	},

	readInt16: function () {
		var result = ((this._s.charCodeAt(this._p) << 8) + this._s.charCodeAt(this._p + 1));
		this._p += 2;
		return result;
	},

	readInt32: function () {
		var result = ((this._s.charCodeAt(this._p) << 24) + (this._s.charCodeAt(this._p + 1) << 16) + (this._s
			.charCodeAt(
				this._p + 2) << 8) + this._s.charCodeAt(this._p + 3));
		this._p += 4;
		return result;
	},

	eof: function () {
		return this._p >= this._s.length;
	}
};

// 使用 async 函数来等待异步操作  
function write_cmd_program(deviceId, serviceId, characteristicId, data) {
	var address = 0;
	var len = 0;
	var buf = 0;
	var dv = 0;
	let result;
	console.log("更新122")
	const mtu = 212;
	uni.setBLEMTU({
		deviceId: self
			.data
			.deviceId,
		mtu,
		success: (
			res
		) => {
			console
				.log(
					"setBLEMTU success>>",
					res
				)
		},
		fail: (
			res
		) => {
			console
				.log(
					"setBLEMTU fail>>",
					res
				)
		},
	});

	var value1 = util.write_ota_erase(CMD_IAP_ERASE, 4, 0, 0);
	var typedArray1 = new Uint8Array(value1);
	console.log("送擦除数据", result)
	send_ota_data(deviceId, serviceId, characteristicId, typedArray1.buffer);
	setTimeout(function () {
		uni.request({
			// url: 'https://www.zenghi.com/gj/地升幕.bin', //仅为示例，并非真实接口地址。
			//url: 'https://www.zenghi.com/gj/BLE钉钉.bin', //仅为示例，并非真实接口地址。
			// url: 'https://www.zenghi.com/gj/电子秤.bin', //仅为示例，并非真实接口地址。
			responseType: 'arraybuffer',
			success: (res) => {
				dv = new DataView(res.data);
				var bufferLength = dv.byteLength;
				var sum = 0;
				for (var i = 0; i < bufferLength; i++) {
					sum += dv.getUint8(i)
				}
				result = dv
				console.log(result);
				console.log("content-length", bufferLength);
				console.log("sum", sum);
				len = bufferLength
				var p_data = 0;
				var p_ii = 0;
				while (address <= len) {
					var offst = 176;
					if (address + 176 > len) {
						offst = len - address;
					}
					var value = util.write_ota_program(CMD_IAP_PROM, offst, address, result);
					var typedArray = new Uint8Array(value);
					send_ota_data_num(deviceId, serviceId, characteristicId, typedArray.buffer, (address /
						len));
					address = address + 176;

				}

				// return new Promise
				var value2 = util.write_ota_sum(CMD_IAP_SUM, bufferLength, sum);
				var typedArray2 = new Uint8Array(value2);
				console.log("送结束数据", value2)
				send_ota_data_num(deviceId, serviceId, characteristicId, typedArray2.buffer, 100);
			},
			fail: function (res) {
				console.log("获取失败");
			}
		})
	}

		, "1000");

	// var requestTask =
}

// 模拟一个异步操作，比如网络请求  
function fetchData() {
	return new Promise((resolve, reject) => {
		setTimeout(() => {
			resolve('Data fetched!');
		}, 20); // 模拟网络延迟 2 秒  
	});
}
// 模拟一个异步操作，比如网络请求
function fetchData2() {
	return new Promise((resolve, reject) => {
		setTimeout(() => {
			resolve('Data fetched!');
		}, 2000); // 模拟网络延迟 2 秒  
	});
}
// 使用 async 函数来等待异步操作  
async function main(res, my_sum, deviceId, serviceId, characteristicId) {
	var address = 0;
	var len = 0;
	var buf = 0;
	var dv = 0;
	let result;
	dv = new DataView(res.data);
	var bufferLength = dv.byteLength;
	var sum = 0;
	for (var i = 0; i < bufferLength; i++) {
		sum += dv.getUint8(i)
	}
	const data1 = await fetchData2();
	result = dv
	console.log(result);
	console.log("content-length", bufferLength);
	console.log("sum", sum);
	len = bufferLength
	if (sum != my_sum && my_sum != 100) {
		console.log("不相等my_sum", my_sum);
		return;
	}
	var p_data = 0;
	var p_ii = 0;
	while (address <= len) {
		var offst = 176;
		if (address + 176 > len) {
			offst = len - address;
		}
		var value = util.write_ota_program(CMD_IAP_PROM, offst, address, result);
		var typedArray = new Uint8Array(value);
		// console.log("12121")
		const data = await fetchData();

		var qq = await send_ota_data_num(deviceId, serviceId, characteristicId, typedArray.buffer, (address /
			len))
		if (qq == false) {
			console.log("返回", sum);
			return
		}
		address = address + 176;
		// //console.log("送数据", qq)
	}
	const data = await fetchData();
	// return new Promise
	var value2 = util.write_ota_sum(CMD_IAP_SUM, bufferLength, sum);
	var typedArray2 = new Uint8Array(value2);
	// console.log("送结束数据", value2)
	send_ota_data_num(deviceId, serviceId, characteristicId, typedArray2.buffer, 100);
}



function write_cmd_program_sum(web, sum, deviceId, serviceId, characteristicId, data) {
	var address = 0;
	var len = 0;
	var buf = 0;
	var dv = 0;
	let result;
	console.log("更新122")
	const mtu = 230;
	var value1 = util.write_ota_erase(CMD_IAP_ERASE, 4, 0, 0);
	var typedArray1 = new Uint8Array(value1);
	console.log("翻盖柜", typedArray1)
	console.log("翻盖柜", deviceId)
	console.log("翻盖柜", serviceId)
	console.log("翻盖柜", characteristicId)
	send_ota_data(deviceId, serviceId, characteristicId, typedArray1.buffer);
	// return;
	setTimeout(function () {
		uni.request({
			url: web, //仅为示例，并非真实接口地址。
			//url: 'https://www.zenghi.com/gj/BLE钉钉.bin', //仅为示例，并非真实接口地址。
			// url: 'https://www.zenghi.com/gj/电子秤.bin', //仅为示例，并非真实接口地址。
			responseType: 'arraybuffer',
			success: (res) => {
				main(res, sum, deviceId, serviceId, characteristicId)
			},
			fail: function (res) {
				console.log("获取失败");
			}
		})
	}
		, 3000);
}


function writeCutomsData(deviceId, serviceId, characteristicId, data) {
	console.log("data", data)
	if (data.sum != undefined) {
		if (data.http != undefined) {
			console.log("升级！ing", data.http)
			write_cmd_program_sum(data.http, data.sum, deviceId, serviceId, characteristicId, data)
		}
	}
	else {


		//console.log("送数据deviceId", deviceId)
		//console.log("送数据serviceId", serviceId)
		//console.log("送数据characteristicId", characteristicId)
		var buffer = string2buffer(data)
		uni.writeBLECharacteristicValue({
			deviceId: deviceId,
			serviceId: serviceId,
			characteristicId: characteristicId,
			value: buffer,
			writeType: 'write',
			success: function (res) {
				//console.log("送数据成功")
			},
			fail: function (res) {
				//console.log("送数据失败", res)
			}
		});
	}
}

let devicesList = [];
function init() {
	let mOnFire = require("./other/onfire.js");
	mDeviceEvent = require("./xBlufi.js");
	util = require("./util.js");
	uni.onBLEConnectionStateChange(function (res) {
		console.log("蓝牙状态改变", re_connect)
		console.log("conn", res.connected)
		if (re_connect == 0) {
			let obj = {
				'type': mDeviceEvent.XBLUFI_TYPE.TYPE_STATUS_CONNECTED,
				'result': res.connected,
				'data': res
			};
			mDeviceEvent.notifyDeviceMsgEvent(obj);
		}
		else{
			re_connect--;
			}

	});
	mDeviceEvent.listenStartDiscoverBle(true, function (options) {
		if (options.isStart) {
			//第一步检查蓝牙适配器是否可用
			uni.onBluetoothAdapterStateChange(function (res) {
				if (!res.available) { }
			}); //第二步关闭适配器，重新来搜索

			uni.closeBluetoothAdapter({
				complete: function (res) {
					// console.log("这里蓝牙数据")
					uni.openBluetoothAdapter({
						success: function (res) {
							uni.getBluetoothAdapterState({
								success: function (res) {
									// console.log("这里蓝牙数据222")
									{
										let countsTimes = 0;
										uni.onBluetoothDeviceFound(function (devices) {
											//剔除重复设备，兼容不同设备API的不同返回值
											var isnotexist = true;

											// console.log('devices',devices);
											if (devices.deviceId) {
												if (devices.advertisData) {
													devices.advertisData = buf2hex(devices.advertisData);
												} else {
													devices.advertisData = '';
												}

												for (var i = 0; i < devicesList.length; i++) {
													if (devices.deviceId === devicesList[i].deviceId) {
														isnotexist = false;
													}
												}

												if (isnotexist) {
													devicesList.push(devices);
												}
											} else if (devices.devices) {
												// console.log(devices.devices[0])
												if (devices.devices[0].name != '开发板'
													&& devices.devices[0].name != '钉子遥控'
													&& devices.devices[0].name != '智能伸缩台'
													&& devices.devices[0].name.indexOf("CT") == -1
													&& devices.devices[0].name.indexOf("BBLE") == -1
													&& devices.devices[0].name.indexOf("CY") == -1
												) {
													isnotexist = false;
												}
												else {
													if (devices.devices[0].name == 'perfectisan-tt') {
														// console.log("改变名字")
														devices.devices[0].name = "钉子科技电动幕"
													}
													if (devices.devices[0].name == '钉子遥控') {
														devices.devices[0].name = "钉子科技智能语音遥控器"
													}
												}

												if (devices.devices[0].advertisData) {
													devices.devices[0].advertisData = buf2hex(devices.devices[0].advertisData);
												} else {
													devices.devices[0].advertisData = '';
												}

												for (var i = 0; i < devicesList.length; i++) {
													if (devices.devices[0].deviceId == devicesList[i].deviceId) {
														isnotexist = false;
													}
												}

												if (isnotexist) {
													devicesList.push(devices.devices[0]);
												}
											} else if (devices[0]) {
												if (devices[0].advertisData) {
													devices[0].advertisData = buf2hex(devices[0].advertisData);
												} else {
													devices[0].advertisData = '';
												}

												for (var i = 0; i < devices_list.length; i++) {
													if (devices[0].deviceId == devicesList[i].deviceId) {
														isnotexist = false;
													}
												}

												if (isnotexist) {
													devicesList.push(devices[0]);
												}
											}
											if (isnotexist == true) {
												console.log("发射设备名称")
												let obj = {
													'type': mDeviceEvent.XBLUFI_TYPE.TYPE_GET_DEVICE_LISTS,
													'result': true,
													'data': devicesList
												};
												mDeviceEvent.notifyDeviceMsgEvent(obj);
											}

										});
										uni.startBluetoothDevicesDiscovery({
											allowDuplicatesKey: true,
											success: function (res) {
												let obj = {
													'type': mDeviceEvent.XBLUFI_TYPE.TYPE_GET_DEVICE_LISTS_START,
													'result': true,
													'data': res
												};
												mDeviceEvent.notifyDeviceMsgEvent(obj); //开始扫码，清空列表

												devicesList.length = 0;
											},
											fail: function (res) {
												let obj = {
													'type': mDeviceEvent.XBLUFI_TYPE.TYPE_GET_DEVICE_LISTS_START,
													'result': false,
													'data': res
												};
												mDeviceEvent.notifyDeviceMsgEvent(obj);
											}
										});
									}
								},
								fail: function (res) {
									let obj = {
										'type': mDeviceEvent.XBLUFI_TYPE.TYPE_GET_DEVICE_LISTS_START,
										'result': false,
										'data': res
									};
									mDeviceEvent.notifyDeviceMsgEvent(obj);
								}
							});
						},
						fail: function (res) {
							let obj = {
								'type': mDeviceEvent.XBLUFI_TYPE.TYPE_GET_DEVICE_LISTS_START,
								'result': false,
								'data': res
							};
							mDeviceEvent.notifyDeviceMsgEvent(obj);
						}
					});
				}
			});
		} else {
			uni.stopBluetoothDevicesDiscovery({
				success: function (res) {
					clearInterval(tempTimer);
					let obj = {
						'type': mDeviceEvent.XBLUFI_TYPE.TYPE_GET_DEVICE_LISTS_STOP,
						'result': true,
						'data': res
					};
					mDeviceEvent.notifyDeviceMsgEvent(obj);
				},
				fail: function (res) {
					let obj = {
						'type': mDeviceEvent.XBLUFI_TYPE.TYPE_GET_DEVICE_LISTS_STOP,
						'result': false,
						'data': res
					};
					mDeviceEvent.notifyDeviceMsgEvent(obj);
				}
			});
		}
	});
	//蓝牙链接或者断开
	mDeviceEvent.listenConnectBle(true, function (options) {
		console.log("我要连接？", options.deviceId,options.isStart);
		if (options.isStart) {
			uni.createBLEConnection({
				deviceId: options.deviceId,
				success: function (res) {
					console.log("链接成功？", res);
					self.data.deviceId = options.deviceId;
					mDeviceEvent.notifyDeviceMsgEvent({
						'type': mDeviceEvent.XBLUFI_TYPE.TYPE_CONNECTED,
						'result': true,
						'data': {
							deviceId: options.deviceId,
							name: options.name
						}
					});
				},
				fail: function (res) {
					self.data.deviceId = null;
					mDeviceEvent.notifyDeviceMsgEvent({
						'type': mDeviceEvent.XBLUFI_TYPE.TYPE_CONNECTED,
						'result': false,
						'data': res
					});
				}
			});
		}
		else {
			console.log("断开", options.deviceId);
			//这里重新扫描，保证退出界面能重新获取名字
			devicesList = [];
			 uni.closeBLEConnection({
				deviceId: options.deviceId,
				success: function (res) {
					console.log('断开成功');
					self.data.deviceId = null;
					mDeviceEvent.notifyDeviceMsgEvent({
						'type': mDeviceEvent.XBLUFI_TYPE.TYPE_CLOSE_CONNECTED,
						'result': true,
						'data': {
							deviceId: options.deviceId,
							name: options.name
						}
					});
				},
				fail: function (res) {
					self.data.deviceId = null;
					console.log('断开失败');
					mDeviceEvent.notifyDeviceMsgEvent({
						'type': mDeviceEvent.XBLUFI_TYPE.TYPE_CLOSE_CONNECTED,
						'result': false,
						'data': res
					});
				}
			});
		}
	});
	mDeviceEvent.listenInitBleEsp32(true, function (options) {
		self = null;
		self = {
			data: {
				deviceId: null,
				isConnected: false,
				failure: false,
				value: 0,
				desc: "请耐心等待...",
				isChecksum: true,
				isEncrypt: true,
				flagEnd: false,
				defaultData: 1,
				ssidType: 2,
				passwordType: 3,
				meshIdType: 3,
				deviceId: "",
				ssid: "",
				uuid: "",
				serviceId: "",
				password: "",
				meshId: "",
				processList: [],
				result: [],
				service_uuid: "000000FF-0000-1000-8000-00805F9B34FB",
				characteristic_write_uuid: "0000FF01-0000-1000-8000-00805F9B34FB",
				characteristic_read_uuid: "0000FF02-0000-1000-8000-00805F9B34FB",
				customData: null,
				md5Key: 0
			}
		};
		let deviceId = options.deviceId;
		self.data.deviceId = options.deviceId;
		mac_id = options.deviceId;

		setTimeout(() => {
			get_fuwu(deviceId)
		}, 700);
	});

	mDeviceEvent.listenSendCustomData(true, function (options) {
		self.data.customData = options.customData;
		writeCutomsData(mac_id, self.data.service_uuid, self.data.characteristic_write_uuid, self.data.customData);
	});
}
/****************************** 对外  ***************************************/


module.exports = {
	init: init
};