蓝牙接口还有很多bug，同样的代码，在微信小程序上是无法正确获取服务的特征值（返回的特征值说write:false，但原生语言可以连上打印机并打印），在app上连蓝牙服务则直接报错误码10004没有找到指定服务的错误。已提BUG，各位大神请看看，谢谢。
IDE运行环境说明
[HBuilder 或 HBuilderX] HBuilderX
[IDE版本号] 20181228
[windows版本号] windwss10系统
App运行环境说明
[Android版本号] Android7.1.1
[手机型号] 360N6 Lite
[安装包]
安装包已上传附件
联系方式
[QQ]278996335
是调哪个蓝牙方法的时候出现的异常？
其他手机会不会出现上述情况，如果有，麻烦提供一下设备名称？
麻烦提供一下源代码。
2***@qq.com (作者)
1、调用uni.createBLEConnection方法在app上无法连接上蓝牙设备
2、调用uni.getBLEDeviceServices、uni.getBLEDeviceCharacteristics的蓝牙方法，没有返回正确的服务和特征值。
蓝牙设备名称： 佳博便携式热敏票据打印机
源码在上面的附件中。
2019-01-15 17:35
2***@qq.com (作者)
另外，我也用了两台不同牌子的蓝牙打印机来测试，调用uni.getBLEDeviceServices、uni.getBLEDeviceCharacteristics的蓝牙方法，都没有返回正确的服务和特征值。
2019-01-15 17:55
2***@qq.com (作者)
1、调用uni.createBLEConnection方法在app上无法连接上蓝牙设备
2、调用uni.getBLEDeviceServices、uni.getBLEDeviceCharacteristics的蓝牙方法，没有返回正确的服务和特征值。
蓝牙设备名称： 佳博便携式热敏票据打印机
源码: blutooth.rar在附件中。
蓝牙设备图片也在附件中
回复 2***@qq.com:如果是createBLEConnection出现问题，应该是当前设备被占用，或者设备deviceid不正确，确保当前设备支持ble传输。
2019-01-16 11:39
2***@qq.com (作者)
回复 DCloud_Android_zl:同样的代码，在app上是获取不了服务；在小程序上能获取服务，但是获取的特征值是write：false；
2019-01-16 13:37
2***@qq.com (作者)
回复 DCloud_Android_zl:小程序获取到3个service，但根据设备ID和服务ID去获取特征值时，获取的特征值是write：false；
2019-01-16 14:17
2***@qq.com (作者)
回复 DCloud_Android_zl:
小程序能获取到3个service，分别是：
service.uuid 49535343-FE7D-4AE5-8FA9-9FAFD205E455
deviceId 88:C2:55:C6:F4:05
service.uuid 00001800-0000-1000-8000-00805F9B34FB
deviceId 88:C2:55:C6:F4:05
service.uuid 00001801-0000-1000-8000-00805F9B34FB
deviceId 88:C2:55:C6:F4:05
2019-01-16 14:19
2***@qq.com (作者)
//检测蓝牙
private void checkBluetooth(final BillingOrderBean billingOrderBean) {
if (defaultAdapter == null) {
showToast("不支持蓝牙");
return;
}
if (defaultAdapter.isEnabled()) {
if (mBluetoothOpen != null && mBluetoothOpen.isShowing()) {
mBluetoothOpen.dismiss();
}
if (mBluetooth == null) {
mBluetooth = new PrinterBluetoothDialog(this);
}
mBluetooth.invalidateBondedBluetoothDevices(defaultAdapter.getBondedDevices());
mBluetooth.show();
// showDialog(mBluetooth);
mBluetooth.setOnDialogListener(new PrinterBluetoothDialog.OnDialogListener() {
@Override
public void onBluetoothDeviceSelect(BluetoothDevice device) {
//sendBluetoothPrintInfo();
mBluetooth.dismiss();
showProgressDialog("");
printTicket(device, billingOrderBean);
}
@Override
public void onDismiss() {
// ScanTicketOpeningActivity.this.finish();
mBluetooth.dismiss();
handler.postDelayed(new Runnable() {
@Override
public void run() {
TicketOpeningActivity.this.finish();
}
}, 1000);
}
});
} else {
showForceTurnOnBluetoothDialog();
}
} //打印
private void printTicket(BluetoothDevice which, BillingOrderBean billingOrderBean) {
if (connect(which)) {
dismissProgressDialog();
if (null != billingOrderBean && null != billingOrderBean.getData()) {
List<BillingOrderBean.DataBean> data = billingOrderBean.getData();
showToastUtils("打印中............");
PrintUtils.setOutputStream(outputStream);
PrintUtils.selectCommand(PrintUtils.RESET);
PrintUtils.selectCommand(PrintUtils.LINE_SPACING_DEFAULT);
PrintUtils.printText("--------------------------------\n");
for (int i = 0; i < data.size(); i++) {
BillingOrderBean.DataBean dataBean = data.get(i);
if ("text".equalsIgnoreCase(dataBean.getType())) {
if ("left".equalsIgnoreCase(dataBean.getAlign())) {
PrintUtils.selectCommand(PrintUtils.NORMAL);
PrintUtils.selectCommand(PrintUtils.BOLD_CANCEL);
PrintUtils.selectCommand(PrintUtils.ALIGN_LEFT);
PrintUtils.printText(PrintUtils.printTwoData(dataBean.getText(), "\n"));
}
if ("center".equalsIgnoreCase(dataBean.getAlign())) {
PrintUtils.selectCommand(PrintUtils.BOLD);
PrintUtils.selectCommand(PrintUtils.ALIGN_CENTER);
PrintUtils.printText(dataBean.getText() + "\n");
}
if ("right".equalsIgnoreCase(dataBean.getAlign())) {
PrintUtils.selectCommand(PrintUtils.NORMAL);
PrintUtils.selectCommand(PrintUtils.BOLD_CANCEL);
PrintUtils.selectCommand(PrintUtils.ALIGN_RIGHT);
PrintUtils.printText(dataBean.getText() + "\n");
}
}
if ("line".equalsIgnoreCase(dataBean.getType())) {
PrintUtils.printText("--------------------------------\n");
}
if ("qrcode".equalsIgnoreCase(dataBean.getType())) {
//ArrayList<byte[]> bytes = printQRCode(dataBean.getText());
ArrayList<byte[]> bytes = ticketOpeningPresenter.printQRCode(dataBean.getText());
if (null != bytes) {
PrintUtils.selectCommand(PrintUtils.ALIGN_CENTER);
PrintUtils.printImg(bytes);
}
}
}
PrintUtils.printText("\n");
PrintUtils.printText("\n");
PrintUtils.printText("\n");
handler.postDelayed(new Runnable() {
@Override
public void run() {
TicketOpeningActivity.this.finish();
}
}, 2000);
}
} else {
showToastUtils("蓝牙设备连接失败");
dismissProgressDialog();
handler.postDelayed(new Runnable() {
@Override
public void run() {
TicketOpeningActivity.this.finish();
}
}, 1000);
}
} 你看看，还需要我提供更多的方法吗？？如果需要，我再发其他的。谢谢
2019-01-16 15:42
2***@qq.com (作者)
回复 DCloud_Android_zl:
package com.gdfuture.cloudapp.base.utils;
import android.annotation.SuppressLint;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Color;
import android.graphics.Matrix;
import android.text.TextUtils;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.Charset;
import java.util.ArrayList;
public class PrintUtils {
/**
* 打印纸一行最大的字节
*/
private static final int LINE_BYTE_SIZE = 32;
private static final int LEFT_LENGTH = 20;
private static final int RIGHT_LENGTH = 12;
/**
* 左侧汉字最多显示几个文字
*/
private static final int LEFT_TEXT_MAX_LENGTH = 8;
/**
* 小票打印菜品的名称，上限调到8个字
*/
public static final int MEAL_NAME_MAX_LENGTH = 8;
private static OutputStream outputStream = null;
public static OutputStream getOutputStream() {
return outputStream;
}
public static void setOutputStream(OutputStream outputStream) {
PrintUtils.outputStream = outputStream;
}
/**
* 打印文字
*
* @param text 要打印的文字
*/
public static void printText(String text) {
try {
byte[] data = text.getBytes("gbk");
outputStream.write(data, 0, data.length);
outputStream.flush();
} catch (IOException e) {
//Toast.makeText(this.context, "发送失败！", Toast.LENGTH_SHORT).show();
e.printStackTrace();
}
}
/**
* 打印图片
*
* @param bytes 图片字节集合
*/
public static void printImg(ArrayList<byte[]> bytes){
try {
// byte[] data = text.getBytes("gbk");
for (int i = 0; i < bytes.size(); i++) {
byte[] bytes1 = bytes.get(i);
outputStream.write(bytes1, 0, bytes1.length);
outputStream.flush();
}
// outputStream.write(data, 0, data.length);
outputStream.flush();
} catch (IOException e) {
//Toast.makeText(this.context, "发送失败！", Toast.LENGTH_SHORT).show();
e.printStackTrace();
}
}
/**
* 设置打印格式
*
* @param command 格式指令
*/
public static void selectCommand(byte[] command) {
try {
outputStream.write(command);
outputStream.flush();
} catch (IOException e) {
//Toast.makeText(this.context, "发送失败！", Toast.LENGTH_SHORT).show();
e.printStackTrace();
}
}
/**
* 获取预打印数据并重置流
*
* @188508 预打印数据
* @throws IOException 异常
*/
public byte[] getDataAndReset() throws IOException {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
byte[] data;
bos.flush();
data = bos.toByteArray();
bos.reset();
return data;
}
/**
* 获取图片数据流
*
* @param res Resources
* @param id 资源ID
* @188508 数据流
*/
public static ArrayList<byte[]> getImageByte(Resources res, int id) {
int maxWidth = 380;
Bitmap image = PhotoUtils.scalingBitmap(res, id, maxWidth);
if (image == null) {
return null;
}
ArrayList<byte[]> data = decodeBitmapToDataList(image, 255);
image.recycle();
return data;
}
/**
* 获取图片数据流
*
* @param image 图片
* @188508 数据流
*/
public static ArrayList<byte[]> getImageByte(Bitmap image) {
int maxWidth = 380;
Bitmap scalingImage = PhotoUtils.scalingBitmap(image, maxWidth);
if (scalingImage == null) {
return null;
}
ArrayList<byte[]> data = decodeBitmapToDataList(image, 255);
image.recycle();
return data;
}
/**
* 复位打印机
*/
public static final byte[] RESET = {0x1b, 0x40};
/**
* 左对齐
*/
public static final byte[] ALIGN_LEFT = {0x1b, 0x61, 0x00};
/**
* 中间对齐
*/
public static final byte[] ALIGN_CENTER = {0x1b, 0x61, 0x01};
/**
* 右对齐
*/
public static final byte[] ALIGN_RIGHT = {0x1b, 0x61, 0x02};
/**
* 选择加粗模式
*/
public static final byte[] BOLD = {0x1b, 0x45, 0x01};
/**
* 取消加粗模式
*/
public static final byte[] BOLD_CANCEL = {0x1b, 0x45, 0x00};
/**
* 宽高加倍
*/
public static final byte[] DOUBLE_HEIGHT_WIDTH = {0x1d, 0x21, 0x11};
/**
* 宽加倍
*/
public static final byte[] DOUBLE_WIDTH = {0x1d, 0x21, 0x10};
/**
* 高加倍
*/
public static final byte[] DOUBLE_HEIGHT = {0x1d, 0x21, 0x01};
/**
* 字体不放大
*/
public static final byte[] NORMAL = {0x1d, 0x21, 0x00};
/**
* 设置默认行间距
*/
public static final byte[] LINE_SPACING_DEFAULT = {0x1b, 0x32};
/**
* 设置行间距
*/ // public static final byte[] LINE_SPACING = {0x1b, 0x32};//{0x1b, 0x33, 0x14}; // 20的行间距（0，255）
// final byte[][] byteCommands = {
// { 0x1b, 0x61, 0x00 }, // 左对齐
// { 0x1b, 0x61, 0x01 }, // 中间对齐
// { 0x1b, 0x61, 0x02 }, // 右对齐
// { 0x1b, 0x40 },// 复位打印机
// { 0x1b, 0x4d, 0x00 },// 标准ASCII字体
// { 0x1b, 0x4d, 0x01 },// 压缩ASCII字体
// { 0x1d, 0x21, 0x00 },// 字体不放大
// { 0x1d, 0x21, 0x11 },// 宽高加倍
// { 0x1b, 0x45, 0x00 },// 取消加粗模式
// { 0x1b, 0x45, 0x01 },// 选择加粗模式
// { 0x1b, 0x7b, 0x00 },// 取消倒置打印
// { 0x1b, 0x7b, 0x01 },// 选择倒置打印
// { 0x1d, 0x42, 0x00 },// 取消黑白反显
// { 0x1d, 0x42, 0x01 },// 选择黑白反显
// { 0x1b, 0x56, 0x00 },// 取消顺时针旋转90°
// { 0x1b, 0x56, 0x01 },// 选择顺时针旋转90°
// };
/**
* 打印两列
*
* @param leftText 左侧文字
* @param rightText 右侧文字
* @188508
*/
@SuppressLint("NewApi")
public static String printTwoData(String leftText, String rightText) {
StringBuilder sb = new StringBuilder();
int leftTextLength = getBytesLength(leftText);
int rightTextLength = getBytesLength(rightText);
sb.append(leftText);
// 计算两侧文字中间的空格
int marginBetweenMiddleAndRight = LINE_BYTE_SIZE - leftTextLength - rightTextLength;
for (int i = 0; i < marginBetweenMiddleAndRight; i++) {
sb.append(" ");
}
sb.append(rightText);
return sb.toString();
}
/**
* 打印三列
*
* @param leftText 左侧文字
* @param middleText 中间文字
* @param rightText 右侧文字
* @188508
*/
@SuppressLint("NewApi")
public static String printThreeData(String leftText, String middleText, String rightText) {
StringBuilder sb = new StringBuilder();
// 左边最多显示 LEFT_TEXT_MAX_LENGTH 个汉字 + 两个点
if (leftText.length() > LEFT_TEXT_MAX_LENGTH) {
leftText = leftText.substring(0, LEFT_TEXT_MAX_LENGTH) + "..";
}
int leftTextLength = getBytesLength(leftText);
int middleTextLength = getBytesLength(middleText);
int rightTextLength = getBytesLength(rightText);
sb.append(leftText);
// 计算左侧文字和中间文字的空格长度
int marginBetweenLeftAndMiddle = LEFT_LENGTH - leftTextLength - middleTextLength / 2;
for (int i = 0; i < marginBetweenLeftAndMiddle; i++) {
sb.append(" ");
}
sb.append(middleText);
// 计算右侧文字和中间文字的空格长度
int marginBetweenMiddleAndRight = RIGHT_LENGTH - middleTextLength / 2 - rightTextLength;
for (int i = 0; i < marginBetweenMiddleAndRight; i++) {
sb.append(" ");
}
// 打印的时候发现，最右边的文字总是偏右一个字符，所以需要删除一个空格
sb.delete(sb.length() - 1, sb.length()).append(rightText);
return sb.toString();
}
/**
* 获取数据长度
*
* @param msg
* @188508
*/
@SuppressLint("NewApi")
private static int getBytesLength(String msg) {
return msg.getBytes(Charset.forName("GB2312")).length;
}
/**
* 格式化菜品名称，最多显示MEAL_NAME_MAX_LENGTH个数
*
* @param name
* @188508
*/
public static String formatMealName(String name) {
if (TextUtils.isEmpty(name)) {
return name;
}
if (name.length() > MEAL_NAME_MAX_LENGTH) {
return name.substring(0, 8) + "..";
}
return name;
}
/**
* 解码图片
*
* @param image 图片
* @param parting 高度分割值
* @188508 数据流
*/
public static ArrayList<byte[]> decodeBitmapToDataList(Bitmap image, int parting) {
if (parting <= 0 || parting > 255) {
parting = 255;
}
if (image == null) {
return null;
}
final int width = image.getWidth();
final int height = image.getHeight();
if (width <= 0 || height <= 0) {
return null;
}
if (width > 2040) {
// 8位9针，宽度限制2040像素（但一般纸张都没法打印那么宽，但并不影响打印）
final float scale = 2040 / (float) width;
Matrix matrix = new Matrix();
matrix.postScale(scale, scale);
Bitmap resizeImage;
try {
resizeImage = Bitmap.createBitmap(image, 0, 0, width, height, matrix, true);
} catch (OutOfMemoryError e) {
return null;
}
ArrayList<byte[]> data = decodeBitmapToDataList(resizeImage, parting);
resizeImage.recycle();
return data;
}
// 宽命令
String widthHexString = Integer.toHexString(width % 8 == 0 ? width / 8 : (width / 8 + 1));
if (widthHexString.length() > 2) {
// 超过2040像素才会到达这里
return null;
} else if (widthHexString.length() == 1) {
widthHexString = "0" + widthHexString;
}
widthHexString += "00";
// 每行字节数(除以8，不足补0)
String zeroStr = "";
int zeroCount = width % 8;
if (zeroCount > 0) {
for (int i = 0; i < (8 - zeroCount); i++) {
zeroStr += "0";
}
}
ArrayList<String> commandList = new ArrayList<>();
// 高度每parting像素进行一次分割
int time = height % parting == 0 ? height / parting : (height / parting + 1);// 循环打印次数
for (int t = 0; t < time; t++) {
int partHeight = t == time - 1 ? height % parting : parting;// 分段高度
// 高命令
String heightHexString = Integer.toHexString(partHeight);
if (heightHexString.length() > 2) {
// 超过255像素才会到达这里
return null;
} else if (heightHexString.length() == 1) {
heightHexString = "0" + heightHexString;
}
heightHexString += "00";
// 宽高指令
String commandHexString = "1D763000";
commandList.add(commandHexString + widthHexString + heightHexString);
ArrayList<String> list = new ArrayList<>(); //binaryString list
StringBuilder sb = new StringBuilder();
// 像素二值化，非黑即白
for (int i = 0; i < partHeight; i++) {
sb.delete(0, sb.length());
for (int j = 0; j < width; j++) {
// 实际在图片中的高度
int startHeight = t * parting + i;
//得到当前像素的值
int color = image.getPixel(j, startHeight);
int red, green, blue;
if (image.hasAlpha()) {
//得到alpha通道的值
int alpha = Color.alpha(color);
//得到图像的像素RGB的值
red = Color.red(color);
green = Color.green(color);
blue = Color.blue(color);
final float offset = alpha / 255.0f;
// 根据透明度将白色与原色叠加
red = 0xFF + (int) Math.ceil((red - 0xFF) * offset);
green = 0xFF + (int) Math.ceil((green - 0xFF) * offset);
blue = 0xFF + (int) Math.ceil((blue - 0xFF) * offset);
} else {
//得到图像的像素RGB的值
red = Color.red(color);
green = Color.green(color);
blue = Color.blue(color);
}
// 接近白色改为白色。其余黑色
if (red > 160 && green > 160 && blue > 160) {
sb.append("0");
} else {
sb.append("1");
}
}
// 每一行结束时，补充剩余的0
if (zeroCount > 0) {
sb.append(zeroStr);
}
list.add(sb.toString());
}
// binaryStr每8位调用一次转换方法，再拼合
ArrayList<String> bmpHexList = new ArrayList<>();
for (String binaryStr : list) {
sb.delete(0, sb.length());
for (int i = 0; i < binaryStr.length(); i += 8) {
String str = binaryStr.substring(i, i + 8);
// 2进制转成16进制
String hexString = binaryStrToHexString(str);
sb.append(hexString);
}
bmpHexList.add(sb.toString());
}
// 数据指令
commandList.addAll(bmpHexList);
}
ArrayList<byte[]> data = new ArrayList<>();
for (String hexStr : commandList) {
data.add(hexStringToBytes(hexStr));
}
return data;
}
/**
* 解码图片
*
* @param image 图片
* @param parting 高度分割值
* @188508 数据流
*/
public static byte[] decodeBitmap(Bitmap image, int parting) {
ArrayList<byte[]> data = decodeBitmapToDataList(image, parting);
int len = 0;
for (byte[] srcArray : data) {
len += srcArray.length;
}
byte[] destArray = new byte[len];
int destLen = 0;
for (byte[] srcArray : data) {
System.arraycopy(srcArray, 0, destArray, destLen, srcArray.length);
destLen += srcArray.length;
}
return destArray;
}
/**
* 解码图片
*
* @param image 图片
* @188508 数据流
*/
public static byte[] decodeBitmap(Bitmap image) {
return decodeBitmap(image, 255);
}
/**
* 16进制串转byte数组
*
* @param hexString 16进制串
* @188508 byte数组
*/
public static byte[] hexStringToBytes(String hexString) {
if (hexString == null || "".equals(hexString)) {
return null;
}
hexString = hexString.toUpperCase();
int length = hexString.length() / 2;
char[] hexChars = hexString.toCharArray();
byte[] d = new byte[length];
for (int i = 0; i < length; i++) {
int pos = i * 2;
d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
}
return d;
}
private static String hexStr = "0123456789ABCDEF";
/**
* 16进制char 转 byte
*
* @param c char
* @188508 byte
*/
private static byte charToByte(char c) {
return (byte) hexStr.indexOf(c);
}
private static String[] binaryArray = {"0000", "0001", "0010", "0011",
"0100", "0101", "0110", "0111", "1000", "1001", "1010", "1011",
"1100", "1101", "1110", "1111"};
/**
* 2进制转成16进制
*
* @param binaryStr 2进制串
* @188508 16进制串
*/
public static String binaryStrToHexString(String binaryStr) {
String hex = "";
String f4 = binaryStr.substring(0, 4);
String b4 = binaryStr.substring(4, 8);
for (int i = 0; i < binaryArray.length; i++) {
if (f4.equals(binaryArray[i])) {
hex += hexStr.substring(i, i + 1);
}
}
for (int i = 0; i < binaryArray.length; i++) {
if (b4.equals(binaryArray[i])) {
hex += hexStr.substring(i, i + 1);
}
}
return hex;
} }
2019-01-16 16:20
2***@qq.com (作者)
回复 DCloud_Android_zl:
商家下班的技术客服人员下班已经下班了，只能明天再问他们技术客服了，但我看到这台打印机的Mode:BLE4.0 & BT3.0，也就是说兼容了经典蓝牙（BT3.0是经典蓝牙中的高速蓝牙）和低功耗蓝牙（BLE4.0）
2019-01-16 17:38
2***@qq.com (作者)
回复 DCloud_Android_zl:
那如果想使用uniapp框架开发app，但蓝牙设备不支持ble传输数据，那应该怎么做好呢？
2019-01-16 18:17
回复 DCloud_Android_zl:https://ask.dcloud.net.cn/article/35416 uni原生插件已经支持，可以参考文档自定义插件，然后通过云打包生成apk
2019-01-16 18:40
2***@qq.com (作者)
回复 DCloud_Android_zl:
打印机商家技术人员回复说这台打印机支持ble传输数据的，那是不是uniapp的蓝牙接口还是有点问题？
2019-01-17 11:25
2***@qq.com (作者)
回复 DCloud_Android_zl:
打印机商家有提供他们的SDK源码，但有35M大，上传不了到你们的平台上； 现在能上传打印机商家提供的java demo，你留意查收下。
2019-01-17 13:54
你好，可以共享这个蓝牙实现打印的代码吗？？
回复 2***@qq.com: 蓝牙连接教程： https://note.youdao.com/ynoteshare1/index.html?id=709fd8ab0fbd333898fef1b587ecd3c2&type=note#/ 还没去试
2019-01-17 14:02
2***@qq.com (作者)
回复 1***@qq.com:
我现在的问题是，使用了uniapp的蓝牙接口，在安卓app上获取获取不了蓝牙设备服务；而在小程序上则获取的蓝牙设备特征值write：false，总结的问题就是获取不了蓝牙服务、获取不了正确的特征值，从而无法完成打印功能。
2019-01-17 14:44
DCloud 即数字天堂(北京)网络技术有限公司是W3C成员及HTML5中国产业联盟发起单位
京ICP备12046007号-4 | 京公网安备：11010802035340号 | 国家信息安全等级保护三级，证书编号：11010813802-20001
