sfms3.0-uniapp/src/components/kk-printer/utils/bluetoolth.js

/**
 * @export
 * @param {string} name 微信api的名称 ，如 uniAsyncPromise("getSystemInfo",options)
 * @param {object} options 除了success 和 fail 的其他参数
 * @returns
 */
export function uniAsyncPromise(name, options) {
	return new Promise((resolve, reject) => {
		uni[name]({
			...(options || {}),
			// ...options,
			success: (res) => {
				resolve(res);
			},
			fail: (err) => {
				reject(err);
			}
		});
	});
}
//微信小程序向蓝牙打印机发送数据进行打印的坑：
//小程序api向蓝牙打印机发送数据打印，发送的任何内容都应该要转成二进制数据，而且蓝牙打印的文本编码是GBK的，发送中文需转成GBK编码再转成二进制数据发送
//发送打印机指令也要转成二进制数据发送
//蓝牙打印机一次接收的二级制数据有限制，不同的系统不同的蓝牙设备限制可能不同，微信建议一次20个字节，需做递归分包发送
//发送完要打印的内容后，一定要发送一个打印的指令才能顺利打印 （有些指令就不需要）

//一、初始化蓝牙、开始检索蓝牙设备
// { allowDuplicatesKey: true, interval: 500}
export function openBlue() {
	return uniAsyncPromise('openBluetoothAdapter')
}

export function startBluetoothDevicesDiscovery(option) {
	console.log('开始蓝牙扫描');
	uniAsyncPromise('startBluetoothDevicesDiscovery', option).then((res) => {
		console.log('正在搜寻蓝牙设备', res);
	});
}

export function getConnectedBluetoothDevices(option) {
	console.log('开始获取已连接设备');
	return uniAsyncPromise('getConnectedBluetoothDevices', option)
}
//二、
/**
 *
 *
 * @export
 * @param {function} getDevices uni.getBluetoothDevices的监听回调函数
 */
export function onfindBlueDevices(getDevices) {
	//监听寻找到新设备的事件
	uni.onBluetoothDeviceFound((devices)=>{
		//获取在蓝牙模块生效期间所有已发现的蓝牙设备
		uniAsyncPromise('getBluetoothDevices').then((res) => {
			getDevices && getDevices(res.devices);
		});
	});
}

/**
 * @export
 * @param {function} stopBlueDevicesDiscovery 关闭蓝牙扫描
 */
export function stopBlueDevicesDiscovery() {
	//监听寻找到新设备的事件
	console.log('停止蓝牙扫描');
	return uniAsyncPromise('stopBluetoothDevicesDiscovery').then((res) => {
		console.log('停止搜寻蓝牙设备', res);
	});
}



//三、连接蓝牙设备
/**
 * @export
 * @param {function} createBLEConnection 
 * @param {number} deviceId 蓝牙设备id
 */
export function createBLEConnection(deviceId, sucess, fail) {
	//连接蓝牙设备
	console.log('连接蓝牙设备', deviceId);
	uniAsyncPromise("createBLEConnection", {
			deviceId
		})
		.then(res => {
			//连接成功可选择停止搜索蓝牙
			//stopBlueDevicesDiscovery();
			console.log('连接成功');
			sucess && sucess({
				res: res,
			});
		})
		.catch(res => {
			console.log('连接设备异常' + res);
			fail && fail({
				res: res,
			});
		})
	/*.finally(res=>{
	    console.log('连接成功');
	    sucess && sucess({
	        res: res,
	    });
	});*/
}

export function closeBLEConnection(deviceId) {
	console.log('断开蓝牙设备', deviceId);
	uniAsyncPromise("closeBLEConnection", {
			deviceId
		})
		.then(res => {
			console.log('BLEDisconnect complete', res);
		})
		.catch(res => {
			console.log('断开设备异常' + res);
		})
	/*.finally(res=>{
	    console.log('BLEDisconnect complete', res);            
	});  */
}

//四、连接成功后， 获取蓝牙设备的service服务
// uniAsyncPromise("getBLEDeviceServices",{deviceId:""}).then(res=>{})
export function getBLEDeviceServices(deviceId, success, fail) {
	console.log('获取ServiceId', deviceId);
	//加延迟避免取不到service
	setTimeout(()=>{
		uniAsyncPromise("getBLEDeviceServices", {
			deviceId:deviceId
		})
		.then(res => {
			console.log('服务', res);
			success && success({
				serviceId: res.services,
			});
		})
		.catch((res) => {
			//getBLEDeviceServices(deviceId, success, fail);
			console.log('获取ServiceId异常' + res);
			fail && fail({
				res: res,
			});
		});
	},1000)
}

//五、获取的service服务可能有多个，递归获取特征值（最后要用的是能读，能写，能监听的那个值的uuid作为特征值id）
/**
 *
 *
 * @export
 * @param {number} deviceId 蓝牙设备id
 * @param {array} services uniAsyncPromise("getBLEDeviceServices",{deviceId:""}).then(res=>{})获取的res.services
 * @param {function} success 成功取得有用特征值uuid的回调函数
 */
export function getDeviceCharacteristics(deviceId, services, success, fail) {
	//services = services.slice(0);
	console.log('获取Characteristics', deviceId, services);
	if (services.length) {
		const serviceId = services.shift().uuid;
		console.log('ServceID ', serviceId);
		uniAsyncPromise('getBLEDeviceCharacteristics', {
				deviceId,
				serviceId,
			})
			.then((res) => {
				console.log('getBLEDeviceCharacteristics', deviceId, serviceId, res);
				let finished = false;
				let write = false;
				let notify = false;
				let indicate = false;
				var readId;
				var writeId;
				//有斑马品牌的一款打印机中res.characteristics的所有uuid都是相同的，找所有的properties存在(notify || indicate) && write这种情况就说明这个uuid是可用的（不确保所有的打印机都能用这种方式取得uuid,在主要测试得凯盛诺打印机res.characteristic只有一个uuid,所以也能用这个方式）
				for (var i = 0; i < res.characteristics.length; i++) {
					if (!notify) {
						notify = res.characteristics[i].properties.notify;
						if (notify) readId = res.characteristics[i].uuid;
					}
					if (!indicate) {
						indicate = res.characteristics[i].properties.indicate;
						if (indicate) readId = res.characteristics[i].uuid;
					}
					if (!write) {
						write = res.characteristics[i].properties.write;
						writeId = res.characteristics[i].uuid;
					}
					if ((notify || indicate) && write) {
						/* 获取蓝牙特征值uuid */
						success &&
							success({
								serviceId,
								writeId: writeId,
								readId: readId,
							});
						finished = true;
						break;
					}
				}

				if (!finished) {
					getDeviceCharacteristics(deviceId, services, success, fail);
				}
			})
			.catch((res) => {
				getDeviceCharacteristics(deviceId, services, success, fail);
			});
	} else {
		fail && fail();
	}
}

//六、启动notify 蓝牙监听功能 然后使用 uni.onBLECharacteristicValueChange用来监听蓝牙设备传递数据
/**
 * @export
 * @param {object} options
 * {
            deviceId,//蓝牙设备id
            serviceId,//服务id
            characteristicId,//可用特征值uuid
    }
 * @param {function} onChange 监听蓝牙设备传递数据回调函数
 */
export function onGetBLECharacteristicValueChange(options, onChange = function() {}) {
	console.log('deviceId ', options.deviceId);
	console.log('serviceId ', options.serviceId);
	console.log('characteristicId ', options.characteristicId);
	uniAsyncPromise('notifyBLECharacteristicValueChange', {
		state: true,
		...options,
	}).then((res) => {
		console.log('onBLECharacteristicValueChange ');
		uni.onBLECharacteristicValueChange(onChange);
	});
}

//七、发送数据(递归分包发送)
/**
 * @export
 * @param {object} options
 * {
            deviceId,
            serviceId,
            characteristicId,
			value [ArrayBuffer],
			lasterSuccess,
            onceLength
    }
 */

export function sendDataToDevice(options) {
	let byteLength = options.value.byteLength;
	//这里默认一次20个字节发送
	const speed = options.onceLength; //20; 
	console.log("send data 20");
	console.log(options);
	if (byteLength > 0) {
		uniAsyncPromise('writeBLECharacteristicValue', {
				...options,
				value: options.value.slice(0, byteLength > speed ? speed : byteLength),
			})
			.then((res) => {
				if (byteLength > speed) {
					sendDataToDevice({
						...options,
						value: options.value.slice(speed, byteLength),
					});
				} else {
					options.lasterSuccess && options.lasterSuccess();
				}
			})
			.catch((res) => {
				console.log(res);
			});
	}
}
export function charToArrayBuffer(str) {
	var out = new ArrayBuffer(str.length);
	var uint8 = new Uint8Array(out);
	var strs = str.split('');
	for (var i = 0; i < strs.length; i++) {
		uint8[i] = strs[i].charCodeAt();
	}
	return uint8;
}
export function charToArray(str) {
	var arr = [];
	var strs = str.split('');
	for (var i = 0; i < strs.length; i++) {
		arr[i] = strs[i].charCodeAt();
	}
	return arr;
}
//打印二维码
/**
 * @export
 * @param {object} options
 * {
            deviceId,
            serviceId,
            characteristicId,
            value,//ArrayBuffer:二维码的数据
    }
 */
export function printQR(options) {
	//打印二维码的十进制指令data：
	let data = [29, 107, 97, 7, 4, options.value.byteLength, 0];
	sendDataToDevice({
		...options,
		value: new Uint8Array(data).buffer,
		lasterSuccess: () => {
			//指令发送成功后，发送二维码的数据
			sendDataToDevice(options);
		},
	});
}

function grayPixle(pix) {
	return pix[0] * 0.299 + pix[1] * 0.587 + pix[2] * 0.114;
}

export function overwriteImageData(data) {
	let sendWidth = data.width,
		sendHeight = data.height;
	const threshold = data.threshold || 180;
	let sendImageData = new ArrayBuffer((sendWidth * sendHeight) / 8);
	sendImageData = new Uint8Array(sendImageData);
	let pix = data.imageData;
	const part = [];
	let index = 0;
	for (let i = 0; i < pix.length; i += 32) {
		//横向每8个像素点组成一个字节（8位二进制数）。
		for (let k = 0; k < 8; k++) {
			const grayPixle1 = grayPixle(pix.slice(i + k * 4, i + k * 4 + (4 - 1)));
			//阈值调整
			if (grayPixle1 > threshold) {
				//灰度值大于threshold位   白色 为第k位0不打印
				part[k] = 0;
			} else {
				part[k] = 1;
			}
		}
		let temp = 0;
		for (let a = 0; a < part.length; a++) {
			temp += part[a] * Math.pow(2, part.length - 1 - a);
		}
		//开始不明白以下算法什么意思，了解了字节才知道，一个字节是8位的二进制数，part这个数组存的0和1就是二进制的0和1，传输到打印的位图数据的一个字节是0-255之间的十进制数，以下是用权相加法转十进制数，理解了这个就用上面的for循环替代了
		// const temp =
		//     part[0] * 128 +
		//     part[1] * 64 +
		//     part[2] * 32 +
		//     part[3] * 16 +
		//     part[4] * 8 +
		//     part[5] * 4 +
		//     part[6] * 2 +
		//     part[7] * 1;
		sendImageData[index++] = temp;
	}
	return {
		array: Array.from(sendImageData),
		width: sendWidth / 8,
		height: sendHeight,
	};
}
/**
 * printImage
 * @param {object} opt
 * {
            deviceId,//蓝牙设备id
            serviceId,//服务id
            characteristicId,//可用特征值uuid
            lasterSuccess , //最后完成的回调
    }
 */
export function printImage(opt = {}, imageInfo = {}) {
	let arr = imageInfo.array,
		width = imageInfo.width;
	const writeArray = [];
	const xl = width % 256;
	const xh = width / 256;
	//分行发送图片数据,用的十进制指令
	const command = [29, 118, 48, 0, xl, xh, 1, 0]; //1D 76 30 00 w h 
	const enter = [13, 10];
	for (let i = 0; i < arr.length / width; i++) {
		const subArr = arr.slice(i * width, i * width + width);
		const tempArr = command.concat(subArr);
		writeArray.push(new Uint8Array(tempArr));
	}
	writeArray.push(new Uint8Array(enter));
	//console.log(writeArray);
	const print = (options, writeArray) => {
		if (writeArray.length) {
			console.log("send");
			sendDataToDevice({
				...options,
				value: writeArray.shift().buffer,
				lasterSuccess: () => {
					if (writeArray.length) {
						print(options, writeArray);
					} else {
						options.lasterSuccess && options.lasterSuccess();
					}
				},
			});
		}
	};
	console.log("start print");
	print(opt, writeArray);
}

/* 16hex insert 0 */
function Hex2Str(num) {
	if (num.toString(16).length < 2) return "0" + num.toString(16);
	else
		return num.toString(16);
}
/*****CPCL指令接口****/

/**
 * 配置项如下
 *
 * width: 标签纸的宽度，单位像素點
 * height: 标签纸的高度，单位像素點
 * 8像素=1mm
 * printNum: 打印张数，默认为1
 * rotation：页面整体旋转 1-90度 2-180度 3-270度 其他-不旋转
 */
export function CreatCPCLPage(width, height, printNum, rotation = 0, offset = 0) {
	var strCmd = '! ' + offset + ' 200 200 ' + height + ' ' + printNum + '\n';
	strCmd += "PAGE-WIDTH " + width + '\n';
	if (rotation == 1)
		strCmd += "ZPROTATE90\n";
	else if (rotation == 2)
		strCmd += "ZPROTATE180\n";
	else if (rotation == 3)
		strCmd += "ZPROTATE270\n";
	else
		strCmd += "ZPROTATE0\n";
	return strCmd;
}

/**
 * 打印文字
 * x: 文字方块左上角X座标，单位dot
 * y: 文字方块左上角Y座标，单位dot
 * fontName,fontSize: 字体，取值： 參考文檔
 * rotation: 旋转 1-90度 2-180度 3-270度 其他-不旋转 
 * content: 文字内容
 */
export function addCPCLText(x, y, fontName, fontSize, rotation, content) {
	//console.log(fontName,fontSize,rotation, content);   
	var strCmd = '';
	if (rotation == 1) {
		strCmd += 'T90 ';
	}
	if (rotation == 2) {
		strCmd += 'T180 ';
	}
	if (rotation == 3) {
		strCmd += 'T270 ';
	} else {
		strCmd += 'T ';
	}
	strCmd += fontName + ' ' + fontSize + ' ' + x + ' ' + y + ' ' + content + '\n';
	return strCmd;
};

/**
 * 打印一维码
 *
 * x: 文字方块左上角X座标，单位dot
 * y: 文字方块左上角Y座标，单位dot
 * codeType: 条码类型，取值为128、UPCA、UPCA2、UPCA5、UPCE、UPCE2、UPC5、EAN13、EAN13+2、EAN13+5、
 *      EAN8、EAN8+2、EAN8+5、39、39C、F39、F39C、93、CODABAR、CODABAR16、ITF、I2OF5
 * h: 条码高度，单位dot 
 * rotation: 顺时针旋转角度，取值如下：
 *     - 0 不旋转
 *     - 1 顺时针旋转90度
 *     
 * narrow: 窄条码比例因子(dot) 取值： 參考文檔
 * wide: 宽条码比例因子(dot) 取值： 參考文檔
 * content: 文字内容
 *
 */
export function addCPCLBarCode(x, y, codeType, h, rotation, narrow, wide, content) {
	var strCmd = '';
	if (rotation == 0)
		strCmd += 'B ';
	else
		strCmd += 'VB ';
	strCmd += codeType + ' ' + narrow + ' ' + wide + ' ' + h + ' ' + x + ' ' + y + ' ' + content + '\n'
	return strCmd;
};

/**
 * 打印二维码
 *
 * x: 文字方块左上角X座标，单位dot
 * y: 文字方块左上角Y座标，单位dot
 * level: 错误纠正能力等级，取值为L(7%)、M(15%)、Q(25%)、H(30%)
 * ver: 1-10 版本，根据内容调整以获取合适容量
 * scale: 1-10 放大倍数
 * content: 文字内容
 *
 */
export function addCPCLQRCode(x, y, level, ver, scale, content) {
	var strCmd = 'B QR ' + x + ' ' + y + ' M ' + ver + ' U ' + scale + '\n' + level + 'A,' + content + '\n';
	strCmd += 'ENDQR\n';
	return strCmd;
};

/**
 * 放大指令
 * scaleX: 横向放大倍数 1，2，3等整数
 * scaleY: 纵向放大倍数 1，2，3等整数
 */
export function addCPCLSETMAG(scaleX, scaleY) {
	var strCmd = 'SETMAG ' + scaleX + ' ' + scaleY + '\n';
	return strCmd;
};

/**
 * 对齐指令 0-左对齐 1-右对齐 2-居中
 */
export function addCPCLLocation(set) {
	var strCmd = '';
	if (set == 1) {
		strCmd += 'RIGHT\n';
	} else if (set == 2) {
		strCmd += 'CENTER\n';
	} else {
		strCmd += 'LEFT\n';
	}
	return strCmd;
};

/**
 * 反白线 x0,y0,x1,y1,width
 */
export function addCPCLInverseLine(x0, y0, x1, y1, width) {
	var strCmd = 'IL ' + x0 + ' ' + y0 + ' ' + x1 + ' ' + y1 + ' ' + width + '\n';
	return strCmd;
};

/**
 * 画线 x0,y0,x1,y1,width
 */
export function addCPCLLine(x0, y0, x1, y1, width) {
	var strCmd = 'L ' + x0 + ' ' + y0 + ' ' + x1 + ' ' + y1 + ' ' + width + '\n';
	return strCmd;
};

/**
 * 画框 x0,y0,x1,y1,width
 */
export function addCPCLBox(x0, y0, x1, y1, width) {
	var strCmd = 'BOX ' + x0 + ' ' + y0 + ' ' + x1 + ' ' + y1 + ' ' + width + '\n';
	return strCmd;
};

/**
 * 字体加粗
 */
export function addCPCLSETBOLD(bold) {
	var strCmd = 'SETBOLD ' + bold + '\n';
	return strCmd;
};

/**
 * 字体下划线
 */
export function addCPCLUNDERLINE(c) {
	var strCmd = 'UNDERLINE ';
	if (c) strCmd += 'ON\n';
	else if (c) strCmd += 'OFF\n';
	return strCmd;
};

/**
 * 水印打印灰度等级 0-255
 */
export function addCPCLBACKGROUND(level) {
	var strCmd = 'BACKGROUND ';
	if (level > 255 || level < 0) level = 255;
	strCmd += level + '\n';
	return strCmd;
};

/**
 * 打印水印文字
 * x: 文字方块左上角X座标，单位dot
 * y: 文字方块左上角Y座标，单位dot
 * fontName,fontSize: 字体，取值： 參考文檔
 * rotation: 旋转 1-90度 2-180度 3-270度 其他-不旋转 
 * content: 文字内容
 */
export function addCPCLBKVText(x, y, fontName, fontSize, rotation, content) {
	//console.log(fontName,fontSize,rotation, content);   
	var strCmd = '';
	if (rotation == 1) {
		strCmd += 'BKT90 ';
	}
	if (rotation == 2) {
		strCmd += 'BKT180 ';
	}
	if (rotation == 3) {
		strCmd += 'BKT270 ';
	} else {
		strCmd += 'BKT ';
	}
	strCmd += fontName + ' ' + fontSize + ' ' + x + ' ' + y + ' ' + content + '\n';
	return strCmd;
};


/**
 * 标签缝隙定位指令
 */
export function addCPCLGAP() {
	var strCmd = 'GAP-SENSE\nFORM\n';
	return strCmd;
};

/**
 * 标签右黑标检测指令
 */
export function addCPCLSENSE() {
	var strCmd = 'BAR-SENSE\nFORM\n';
	return strCmd;
};

/**
 * 标签左黑标检测指令
 */
export function addCPCLSENSELEFT() {
	var strCmd = 'BAR-SENSE LEFT\nFORM\n';
	return strCmd;
};

/**
 * 打印指令
 */
export function addCPCLPrint() {
	var strCmd = 'PRINT\n';
	return strCmd;
};

/**
 * 图片打印指令
 * x: 文字方块左上角X座标，单位dot
 * y: 文字方块左上角Y座标，单位dot
 * data{
            threshold,//0/1提取的灰度级
            width,//图像宽度
            height,//图像高度
            imageData , //图像数据
    }
 */
export function addCPCLImageCmd(x, y, data) {
	var strImgCmd = '';
	const threshold = data.threshold || 180;
	let myBitmapWidth = data.width,
		myBitmapHeight = data.height;
	let len = parseInt((myBitmapWidth + 7) / 8); //一行的数据长度
	//console.log('len=',len);
	//console.log('myBitmapWidth=',myBitmapWidth);
	//console.log('myBitmapHeight=',myBitmapHeight);
	let ndata = 0;
	let i = 0;
	let j = 0;
	let sendImageData = new ArrayBuffer(len * myBitmapHeight);
	sendImageData = new Uint8Array(sendImageData);
	let pix = data.imageData;
	console.log('pix=', pix);

	for (i = 0; i < myBitmapHeight; i++) {
		for (j = 0; j < len; j++) {
			sendImageData[ndata + j] = 0;
		}
		for (j = 0; j < myBitmapWidth; j++) {
			const grayPixle1 = grayPixle(pix.slice((i * myBitmapWidth + j) * 4, (i * myBitmapWidth + j) * 4 + 3));
			if (grayPixle1 < threshold)
				sendImageData[ndata + parseInt(j / 8)] |= (0x80 >> (j % 8));

		}
		ndata += len;
	}
	//console.log('sendImageData=',sendImageData);
	//CPCL指令图片数据 
	strImgCmd += 'EG ' + len + ' ' + myBitmapHeight + ' ' + x + ' ' + y + ' ';
	for (i = 0; i < sendImageData.length; i++) {
		strImgCmd += Hex2Str(sendImageData[i]);
	}
	strImgCmd += '\n';
	//console.log(strImgCmd);
	return strImgCmd;
}
/**
 * toast显示捕获的蓝牙异常
 */
export function catchToast(err) {
	const errMsg = {
		10000: '未初始化蓝牙模块',
		10001: '蓝牙未打开',
		10002: '没有找到指定设备',
		10003: '连接失败',
		10004: '没有找到指定服务',
		10005: '没有找到指定特征值',
		10006: '当前连接已断开',
		10007: '当前特征值不支持此操作',
		10008: '系统上报异常',
		10009: '系统版本低于 4.3 不支持BLE'
	};
	let coode = err.errCode ? err.errCode.toString() : '';
	let msg = errMsg[coode];
	plus.nativeUI.toast(msg || coode, {
		align: 'center',
		verticalAlign: 'center'
	});
}