package com.hdl.photovoltaic.utils;
|
|
import android.Manifest;
|
import android.bluetooth.BluetoothAdapter;
|
import android.bluetooth.BluetoothDevice;
|
import android.bluetooth.BluetoothGatt;
|
import android.bluetooth.BluetoothGattCallback;
|
import android.bluetooth.BluetoothGattCharacteristic;
|
import android.bluetooth.BluetoothGattDescriptor;
|
import android.bluetooth.BluetoothGattService;
|
import android.bluetooth.BluetoothManager;
|
import android.bluetooth.BluetoothProfile;
|
import android.bluetooth.le.BluetoothLeScanner;
|
import android.bluetooth.le.ScanCallback;
|
import android.bluetooth.le.ScanFilter;
|
import android.bluetooth.le.ScanResult;
|
import android.bluetooth.le.ScanSettings;
|
import android.content.Context;
|
import android.content.pm.PackageManager;
|
import android.os.Build;
|
import android.os.Handler;
|
import android.os.Looper;
|
import android.util.Log;
|
|
import androidx.annotation.RequiresPermission;
|
import androidx.core.app.ActivityCompat;
|
|
import com.google.gson.Gson;
|
|
import java.nio.charset.StandardCharsets;
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.Objects;
|
import java.util.UUID;
|
|
/**
|
* 手机端通过 BLE 向设备写入 Wi-Fi SSID 和密码的工具类。
|
* 典型用法：
|
* 1. 创建实例 BleWifiConfigurator configurator = new BleWifiConfigurator(context);
|
* 2. 设置自定义 UUID（可选，默认使用常见 UUID）
|
* 3. 调用 startScan() 扫描设备
|
* 4. 在 onDeviceFound 回调中选择目标设备，调用 connect() 连接
|
* 5. 连接成功后调用 writeCredentials(ssid, password) 写入凭证
|
* 6. 监听回调处理结果
|
*/
|
public class BleWifiConfiguratorUtils {
|
|
private static final String TAG = "BleWifiConfigurator";
|
// 默认的 UUID（设备端需要定义以下服务和特征）
|
//这是主服务，包含所有配网相关的特征。
|
public static final UUID DEFAULT_SERVICE_UUID = UUID.fromString("000000ff-0000-1000-8000-00805f9b34fb");
|
//特征值 1: 0000fff1-0000-1000-8000-00805f9b34fb (SSID)
|
//用途：写入 Wi-Fi 的 SSID 名称
|
//属性：Write (可写)
|
//数据类型：UTF-8 字符串
|
//示例："MyWiFi_5G"
|
public static final UUID DEFAULT_CHAR_UUID = UUID.fromString("0000ff01-0000-1000-8000-00805f9b34fb");
|
//特征值 3: 0000fff3-0000-1000-8000-00805f9b34fb (通知，可选)
|
//用途：接收设备端的响应消息
|
//属性：Notify (通知)
|
//数据类型：UTF-8 字符串
|
//示例响应："SUCCESS", "FAIL: Invalid SSID"
|
public static final UUID DEFAULT_NOTIFY_CHAR_UUID = UUID.fromString("0000ff01-0000-1000-8000-00805f9b34fb"); // 可选，用于接收设备响应
|
|
// 上下文
|
private Context context;
|
|
// 蓝牙适配器和扫描器
|
private BluetoothAdapter bluetoothAdapter;
|
private BluetoothLeScanner bleScanner;
|
|
// GATT 相关
|
private BluetoothGatt bluetoothGatt;
|
private BluetoothGattService targetService;
|
private BluetoothGattCharacteristic characteristic;
|
private BluetoothGattCharacteristic notifyCharacteristic; // 可选
|
|
// 自定义 UUID（允许调用者修改）
|
private UUID serviceUuid = DEFAULT_SERVICE_UUID;
|
private UUID charUuid = DEFAULT_CHAR_UUID;
|
private UUID notifyCharUuid = DEFAULT_NOTIFY_CHAR_UUID;
|
|
// 回调接口
|
private ScanListener scanListener;
|
private ConnectListener connectListener;
|
private WriteListener writeListener;
|
|
// 内部状态
|
private boolean isScanning = false;
|
private boolean isConnected = false;
|
private String dataToWrite; // 待写入的数据
|
|
// 用于将 BLE 回调抛到主线程
|
private final Handler callbackHandler = new Handler(Looper.getMainLooper());
|
|
// ==================== 构造函数和设置 ====================
|
|
public BleWifiConfiguratorUtils(Context context) {
|
this.context = context.getApplicationContext();
|
initBluetooth();
|
}
|
|
private void initBluetooth() {
|
BluetoothManager bluetoothManager = (BluetoothManager) context.getSystemService(Context.BLUETOOTH_SERVICE);
|
if (bluetoothManager != null) {
|
bluetoothAdapter = bluetoothManager.getAdapter();
|
}
|
}
|
|
/**
|
* 设置自定义 Service UUID（可选）
|
*/
|
public void setServiceUuid(UUID serviceUuid) {
|
this.serviceUuid = serviceUuid;
|
}
|
|
/**
|
* 设置自定义特征 UUID（可选）
|
*/
|
public void setCharUuid(UUID charUuid) {
|
this.charUuid = charUuid;
|
}
|
|
/**
|
* 设置自定义通知特征 UUID（可选，用于接收设备响应）
|
*/
|
public void setNotifyCharUuid(UUID notifyCharUuid) {
|
this.notifyCharUuid = notifyCharUuid;
|
}
|
|
/**
|
* 检查蓝牙连接状态
|
*/
|
public boolean getBluetoothStatus() {
|
return this.isConnected;
|
}
|
|
// ==================== 权限检查 ====================
|
|
/**
|
* 检查是否拥有必要的运行时权限（Android 12+ 需动态申请新权限）
|
*
|
* @return 缺失的权限列表，为空则表示全部拥有
|
*/
|
public List<String> getMissingPermissions() {
|
List<String> missing = new ArrayList<>();
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
|
//在应用里--权限名称--附近的设备
|
if (context.checkSelfPermission(android.Manifest.permission.BLUETOOTH_SCAN) != android.content.pm.PackageManager.PERMISSION_GRANTED) {
|
missing.add(android.Manifest.permission.BLUETOOTH_SCAN);
|
Log.d(TAG, "No Permissions: android.Manifest.permission.BLUETOOTH_SCAN");
|
}
|
if (context.checkSelfPermission(android.Manifest.permission.BLUETOOTH_CONNECT) != android.content.pm.PackageManager.PERMISSION_GRANTED) {
|
missing.add(android.Manifest.permission.BLUETOOTH_CONNECT);
|
Log.d(TAG, "No Permissions: android.Manifest.permission.BLUETOOTH_CONNECT");
|
}
|
if (context.checkSelfPermission(android.Manifest.permission.ACCESS_FINE_LOCATION) != android.content.pm.PackageManager.PERMISSION_GRANTED) {
|
missing.add(android.Manifest.permission.ACCESS_FINE_LOCATION);
|
Log.d(TAG, "No Permissions: android.Manifest.permission.ACCESS_FINE_LOCATION");
|
}
|
} else {
|
if (context.checkSelfPermission(android.Manifest.permission.ACCESS_FINE_LOCATION) != android.content.pm.PackageManager.PERMISSION_GRANTED) {
|
missing.add(android.Manifest.permission.ACCESS_FINE_LOCATION);
|
Log.d(TAG, "No Permissions: android.Manifest.permission.ACCESS_FINE_LOCATION");
|
}
|
if (context.checkSelfPermission(android.Manifest.permission.ACCESS_COARSE_LOCATION) != android.content.pm.PackageManager.PERMISSION_GRANTED) {
|
missing.add(android.Manifest.permission.ACCESS_COARSE_LOCATION);
|
Log.d(TAG, "No Permissions: android.Manifest.permission.ACCESS_COARSE_LOCATION");
|
}
|
|
}
|
return missing;
|
}
|
|
// ==================== 扫描相关 ====================
|
|
/**
|
* 开始扫描 BLE 设备，默认不设置过滤（由 ScanListener 自行判断）
|
*
|
* @param listener 扫描回调
|
*/
|
@RequiresPermission(Manifest.permission.BLUETOOTH_SCAN)
|
public void startScan(ScanListener listener) {
|
try {
|
this.scanListener = listener;
|
if (!checkBluetoothEnabled()) {
|
notifyScanFailed(ScanListener.ERROR_BLUETOOTH_DISABLED);
|
return;
|
}
|
if (bleScanner == null) {
|
bleScanner = bluetoothAdapter.getBluetoothLeScanner();
|
if (bleScanner == null) {
|
notifyScanFailed(ScanListener.ERROR_SCANNER_NULL);
|
return;
|
}
|
}
|
if (isScanning) {
|
stopScan();
|
}
|
ScanSettings settings = new ScanSettings.Builder()
|
.setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
|
// .setCallbackType(ScanSettings.CALLBACK_TYPE_ALL_MATCHES) //CALLBACK_TYPE_FIRST_MATCH 仅当首次匹配到设备时回调一次// 或 CALLBACK_TYPE_ALL_MATCHES 每次收到广播都回调。
|
// .setMatchMode(ScanSettings.MATCH_MODE_AGGRESSIVE)
|
// .setNumOfMatches(ScanSettings.MATCH_NUM_MAX_ADVERTISEMENT)
|
.build();
|
// 可以添加基于 serviceUuid 的过滤，但保留由 listener 自行过滤的灵活性
|
List<ScanFilter> filters = new ArrayList<>();
|
// 可选：添加服务 UUID 过滤（如果需要）
|
// filters.add(new ScanFilter.Builder().setServiceUuid(new ParcelUuid(serviceUuid)).build());
|
if (!this.getMissingPermissions().isEmpty()) {
|
callbackHandler.post(() -> this.scanListener.onScanFailed(ScanListener.ERROR_No_Permissions)); // 没有权限
|
return;
|
}
|
bleScanner.startScan(filters, settings, scanCallback);
|
isScanning = true;
|
Log.d(TAG, "BLE scan started");
|
} catch (Exception e) {
|
Log.d(TAG, "BLE scan fail");
|
}
|
}
|
|
/**
|
* 停止扫描
|
*/
|
@RequiresPermission(Manifest.permission.BLUETOOTH_SCAN)
|
public void stopScan() {
|
if (isScanning && bleScanner != null) {
|
if (!this.getMissingPermissions().isEmpty()) {
|
callbackHandler.post(() -> this.scanListener.onScanFailed(ScanListener.ERROR_No_Permissions)); // 没有权限
|
return;
|
}
|
bleScanner.stopScan(scanCallback);
|
isScanning = false;
|
Log.d(TAG, "BLE scan stopped");
|
}
|
}
|
|
private final ScanCallback scanCallback = new ScanCallback() {
|
@Override
|
public void onScanResult(int callbackType, ScanResult result) {
|
BluetoothDevice device = result.getDevice();
|
// // 关键：获取设备的蓝牙类型
|
// int bluetoothType = device.getType();
|
// switch (bluetoothType) {
|
// case BluetoothDevice.DEVICE_TYPE_CLASSIC:
|
// Log.d(TAG, "📞 经典蓝牙设备：" + device.getName());
|
// // 例如：蓝牙耳机、车载音响
|
// break;
|
//
|
// case BluetoothDevice.DEVICE_TYPE_LE:
|
// Log.d(TAG, "💡 低功耗蓝牙设备：" + device.getName());
|
// // 例如：手环、智能灯、你的 HDL 设备
|
// break;
|
//
|
// case BluetoothDevice.DEVICE_TYPE_DUAL:
|
// Log.d(TAG, "🔄 双模设备（支持两种）：" + device.getName());
|
// // 例如：高端蓝牙耳机
|
// break;
|
//
|
// case BluetoothDevice.DEVICE_TYPE_UNKNOWN:
|
// Log.d(TAG, "❓ 未知类型");
|
// break;
|
// }
|
|
Log.d("===", "onDeviceFound: " + Objects.requireNonNull(result.getScanRecord()).getDeviceName());
|
// if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
|
// if (ActivityCompat.checkSelfPermission(context, Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED) {
|
// // TODO: Consider calling
|
// // ActivityCompat#requestPermissions
|
// // here to request the missing permissions, and then overriding
|
// // public void onRequestPermissionsResult(int requestCode, String[] permissions,
|
// // int[] grantResults)
|
// // to handle the case where the user grants the permission. See the documentation
|
// // for ActivityCompat#requestPermissions for more details.
|
// scanListener.onScanFailed(ScanListener.ERROR_No_Permissions);
|
// return;
|
// }
|
// }
|
int rssi = result.getRssi();
|
byte[] scanRecord = result.getScanRecord() != null ? result.getScanRecord().getBytes() : null;
|
if (scanListener != null) {
|
callbackHandler.post(() -> scanListener.onDeviceFound(device, rssi, scanRecord, result));
|
}
|
}
|
|
@Override
|
public void onBatchScanResults(List<ScanResult> results) {
|
// 批量结果，可根据需要处理
|
Log.d("=====", "onDeviceFound: " + new Gson().toJson(results));
|
}
|
|
@Override
|
public void onScanFailed(int errorCode) {
|
Log.e(TAG, "Scan failed, error: " + errorCode);
|
notifyScanFailed(errorCode);
|
}
|
};
|
|
private void notifyScanFailed(int errorCode) {
|
if (this.scanListener != null) {
|
callbackHandler.post(() -> this.scanListener.onScanFailed(errorCode));
|
}
|
isScanning = false;
|
}
|
|
// ==================== 连接相关 ====================
|
|
/**
|
* 连接指定的 BLE 设备(系统默认连接超时30秒)
|
*
|
* @param deviceAddress 目标设备BluetoothDevice
|
* @param listener 连接状态回调
|
*/
|
@RequiresPermission(Manifest.permission.BLUETOOTH_CONNECT)
|
public void connect(String deviceAddress, ConnectListener listener) {
|
this.connectListener = listener;
|
if (!checkBluetoothEnabled()) {
|
notifyConnectionFailed("Bluetooth disabled");
|
return;
|
}
|
if (!this.getMissingPermissions().isEmpty()) {
|
callbackHandler.post(() -> this.connectListener.onConnectionFailed("No permissions")); // 没有权限
|
return;
|
}
|
|
if (bluetoothGatt != null) {
|
bluetoothGatt.disconnect(); // 先断开连接
|
bluetoothGatt.close();
|
bluetoothGatt = null;
|
Log.d(TAG, "Connecting to 先断开旧蓝牙连接");
|
}
|
BluetoothDevice device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(deviceAddress);
|
// 自动连接 = false，避免系统缓存连接
|
bluetoothGatt = device.connectGatt(context, false, gattCallback);
|
Log.d(TAG, "Connecting to " + device.getAddress());
|
}
|
|
/**
|
* 断开当前连接
|
*/
|
public void disconnect() {
|
if (bluetoothGatt != null) {
|
if (ActivityCompat.checkSelfPermission(this.context, Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED) {
|
// TODO: Consider calling
|
// ActivityCompat#requestPermissions
|
// here to request the missing permissions, and then overriding
|
// public void onRequestPermissionsResult(int requestCode, String[] permissions,
|
// int[] grantResults)
|
// to handle the case where the user grants the permission. See the documentation
|
// for ActivityCompat#requestPermissions for more details.
|
return;
|
}
|
bluetoothGatt.disconnect();
|
bluetoothGatt.close();
|
bluetoothGatt = null;
|
}
|
isConnected = false;
|
targetService = null;
|
characteristic = null;
|
notifyCharacteristic = null;
|
}
|
|
private final BluetoothGattCallback gattCallback = new BluetoothGattCallback() {
|
@RequiresPermission(Manifest.permission.BLUETOOTH_CONNECT)
|
@Override
|
public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
|
//如果连接超时系统会报133
|
if (newState == BluetoothProfile.STATE_CONNECTED) {
|
Log.d(TAG, "Connected to GATT server, attempting service discovery");
|
gatt.discoverServices();
|
} else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
|
isConnected = false;
|
// if (bluetoothGatt != null) {
|
// bluetoothGatt.close();
|
// bluetoothGatt = null;
|
// }
|
if (connectListener != null) {
|
callbackHandler.post(() -> connectListener.onDisconnected());
|
}
|
|
Log.d(TAG, "Connected to GATT server, onDisconnected");
|
}//
|
}
|
|
@RequiresPermission(Manifest.permission.BLUETOOTH_CONNECT)
|
@Override
|
public void onServicesDiscovered(BluetoothGatt gatt, int status) {
|
if (status == BluetoothGatt.GATT_SUCCESS) {
|
targetService = gatt.getService(serviceUuid);
|
if (targetService == null) {
|
Log.e(TAG, "Service not found: " + serviceUuid);
|
notifyConnectionFailed("Service not found");
|
return;
|
}
|
characteristic = targetService.getCharacteristic(charUuid);
|
notifyCharacteristic = targetService.getCharacteristic(notifyCharUuid);
|
boolean mtuRequestResult = gatt.requestMtu(512); // 默认设置请求最大 MTU，有设备可能不支持
|
Log.d(TAG, "requestMtu(512) 结果：" + mtuRequestResult);
|
|
if (characteristic == null) {
|
Log.e(TAG, "Required characteristics not found");
|
notifyConnectionFailed("Characteristics not found");
|
return;
|
}
|
Log.e(TAG, "Required characteristics find");
|
// 如果支持通知，可以开启通知（可选）
|
if (notifyCharacteristic != null) {
|
enableNotification(notifyCharacteristic);
|
}
|
|
isConnected = true;
|
if (connectListener != null) {
|
callbackHandler.post(() -> connectListener.onConnected());
|
}
|
} else {
|
Log.e(TAG, "Service discovery failed, status: " + status);
|
notifyConnectionFailed("Service discovery failed");
|
}
|
}
|
|
@RequiresPermission(Manifest.permission.BLUETOOTH_CONNECT)
|
@Override
|
public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
|
boolean success = status == BluetoothGatt.GATT_SUCCESS;
|
if (!success) {
|
Log.e(TAG, "Write failed, status: " + status);
|
if (writeListener != null) {
|
callbackHandler.post(() -> writeListener.onWriteFailed(status));
|
}
|
return;
|
}
|
Log.d(TAG, "onCharacteristicWrite: 写入成功回复");
|
if (characteristic.getUuid().equals(charUuid)) {
|
//写入成功
|
if (writeListener != null) {
|
callbackHandler.post(() -> writeListener.onWriteSuccess());
|
callbackHandler.post(() -> writeListener.onWriteComplete(true));
|
}
|
}
|
}
|
|
@Override
|
public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
|
Log.d(TAG, "onCharacteristicChanged: " + characteristic.getUuid());
|
|
//收到蓝牙回复的数
|
if (characteristic.getUuid().equals(notifyCharUuid) && writeListener != null) {
|
byte[] value = characteristic.getValue();
|
// Log.d(TAG, "打印十六进制: " + bytesToHexString(value));
|
String response = new String(value, StandardCharsets.UTF_8);
|
callbackHandler.post(() -> writeListener.onDeviceResponse(response));
|
}
|
}
|
|
@Override
|
public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
|
Log.d(TAG, "onDescriptorWrite: status=" + status +
|
", descriptor=" + descriptor.getUuid());
|
// 通知描述符写入完成，可以忽略
|
if (status == BluetoothGatt.GATT_SUCCESS) {
|
Log.d(TAG, "通知开启成功，可以接收设备响应了");
|
} else {
|
Log.e(TAG, "通知开启失败：" + status);
|
if (writeListener != null) {
|
callbackHandler.post(() -> writeListener.onWriteFailed(status));
|
}
|
}
|
}
|
|
@Override
|
public void onMtuChanged(BluetoothGatt gatt, int mtu, int status) {
|
//todo 后面兼用mtc分包的，目前默认设置512字节
|
if (status == BluetoothGatt.GATT_SUCCESS) {
|
// currentMtu = mtu;
|
Log.d(TAG, "✅ MTU 协商成功：当前 MTU = " + mtu + " 字节");
|
Log.d(TAG, " 有效数据长度 = " + (mtu - 5) + " 字节");
|
|
// // MTU 设置成功后，标记连接成功
|
// isConnected = true;
|
// if (connectListener != null) {
|
// callbackHandler.post(() -> {
|
// Log.d(TAG, "通知连接成功回调");
|
// connectListener.onConnected();
|
// });
|
// }
|
} else {
|
// Log.w(TAG, "⚠️ MTU 协商失败，status: " + status + "，使用默认 MTU=23");
|
//// currentMtu = 23;
|
// // 即使 MTU 失败，也认为连接成功（使用默认 MTU）
|
// isConnected = true;
|
// if (connectListener != null) {
|
// callbackHandler.post(() -> connectListener.onConnected());
|
// }
|
}
|
}
|
|
|
};
|
|
@RequiresPermission(Manifest.permission.BLUETOOTH_CONNECT)
|
private void enableNotification(BluetoothGattCharacteristic characteristic) {
|
if (bluetoothGatt == null) return;
|
if (!this.getMissingPermissions().isEmpty()) {
|
return;
|
}
|
// 第 1 步：在协议栈层面开启通知
|
boolean enabled = bluetoothGatt.setCharacteristicNotification(characteristic, true);
|
if (enabled) {
|
// 根据 Android 版本和设备厂商动态调整延迟
|
int delayMs = calculateNotificationDelay();
|
callbackHandler.postDelayed(() -> {
|
|
// 第 2 步：获取客户端特征配置描述符 (CCCD)
|
// ↑ 00002902 是标准的 CCCD 描述符 UUID
|
BluetoothGattDescriptor descriptor = characteristic.getDescriptor(
|
UUID.fromString("00002902-0000-1000-8000-00805f9b34fb"));
|
if (descriptor != null) {
|
// // 第 3 步：设置描述符的值
|
// // 先检查特征属性，决定使用 NOTIFY 还是 INDICATE
|
int charProp = characteristic.getProperties();
|
if ((charProp & BluetoothGattCharacteristic.PROPERTY_NOTIFY) > 0) {
|
descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
|
Log.d(TAG, "使用 NOTIFICATION 模式");
|
} else if ((charProp & BluetoothGattCharacteristic.PROPERTY_INDICATE) > 0) {
|
descriptor.setValue(BluetoothGattDescriptor.ENABLE_INDICATION_VALUE);
|
Log.d(TAG, "使用 INDICATION 模式");
|
} else {
|
Log.e(TAG, "该特征不支持通知/指示");
|
return;
|
}
|
// 第 3 步：设置描述符的值为 ENABLE_NOTIFICATION_VALUE，
|
// ↑ 这个值是 byte[]{0x01, 0x00}，告诉设备端"我要订阅通知"
|
// descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
|
// 第 4 步：写入描述符到设备
|
//↑ 只有写入成功后，告诉设备端，设备才会开始发送通知，
|
bluetoothGatt.writeDescriptor(descriptor);
|
|
Log.d(TAG, "writeDescriptor success");
|
}
|
}, delayMs);
|
}
|
}
|
|
private void notifyConnectionFailed(String reason) {
|
if (connectListener != null) {
|
callbackHandler.post(() -> connectListener.onConnectionFailed(reason));
|
}
|
disconnect();
|
}
|
|
// ==================== 写入凭证 ====================
|
|
/**
|
* 写入数据（必须在连接成功后调用）
|
*
|
* @param data 数据
|
* @param listener 写入结果回调
|
*/
|
@RequiresPermission(Manifest.permission.BLUETOOTH_CONNECT)
|
public void writeCredentials(String data, WriteListener listener) {
|
Log.d(TAG, "writeCredentials :准备写入");
|
this.writeListener = listener;
|
if (!isConnected || characteristic == null) {
|
if (listener != null) {
|
callbackHandler.post(() -> listener.onWriteFailed(-1)); // 自定义错误码
|
}
|
return;
|
}
|
// 开始写
|
writeCharacteristic(characteristic, data);
|
}
|
|
@RequiresPermission(Manifest.permission.BLUETOOTH_CONNECT)
|
private void writeCharacteristic(BluetoothGattCharacteristic characteristic, String value) {
|
|
Log.d(TAG, "writeCharacteristic :开始写入");
|
if (!this.getMissingPermissions().isEmpty()) {
|
callbackHandler.post(() -> this.writeListener.onWriteFailed(-2)); // 没有权限
|
return;
|
}
|
characteristic.setValue(value.getBytes(StandardCharsets.UTF_8));
|
characteristic.setWriteType(BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT);
|
bluetoothGatt.writeCharacteristic(characteristic);
|
Log.d(TAG, "writeCharacteristic :开始完成");
|
}
|
|
|
|
/**
|
* 根据 Android 版本和设备厂商计算延迟时间
|
* Android 10/11 不需要延迟 原因：系统处理快，无严格检查
|
* Android 12 需要100-200ms延迟 原因：系统需要时间准备 BLE 协议栈
|
* Android 13 需要50-100ms延迟 原因：优化后速度稍快
|
* Android 14 需要50ms延迟 原因：进一步优化
|
*/
|
private int calculateNotificationDelay() {
|
int sdkVersion = Build.VERSION.SDK_INT;
|
|
// Android 12 (SDK 31) 需要最长延迟
|
if (sdkVersion == Build.VERSION_CODES.S) {
|
// 小米/红米设备可能需要更长延迟
|
if ("Xiaomi".equals(Build.MANUFACTURER)) {
|
Log.d(TAG, "检测到小米设备，增加延迟到 200ms");
|
return 200;
|
}
|
// 其他 Android 12 设备
|
return 100;
|
}
|
|
// Android 13+ 优化后延迟可以短一些
|
if (sdkVersion >= Build.VERSION_CODES.TIRAMISU) {
|
return 50;
|
}
|
|
// Android 11 及以下不需要延迟
|
return 0;
|
}
|
|
// ==================== 工具方法 ====================
|
|
/**
|
* 检查蓝牙是否开启
|
*/
|
public boolean checkBluetoothEnabled() {
|
return bluetoothAdapter != null && bluetoothAdapter.isEnabled();
|
}
|
|
/**
|
* 释放资源（在 Activity/Fragment 销毁时调用）
|
*/
|
@RequiresPermission(Manifest.permission.BLUETOOTH_SCAN)
|
public void release() {
|
stopScan();
|
disconnect();
|
}
|
|
// ==================== 回调接口定义 ====================
|
|
public interface ScanListener {
|
/**
|
* 蓝牙没有开启
|
*/
|
int ERROR_BLUETOOTH_DISABLED = 1;
|
int ERROR_SCANNER_NULL = 2;
|
int ERROR_No_Permissions = 3;
|
|
/**
|
* 发现设备（可能多次回调）
|
*/
|
void onDeviceFound(BluetoothDevice device, int rssi, byte[] scanRecord, ScanResult scanResult);
|
|
/**
|
* 扫描失败
|
*/
|
void onScanFailed(int errorCode);
|
}
|
|
public interface ConnectListener {
|
/**
|
* 连接成功，服务已发现，特征已获取
|
*/
|
void onConnected();
|
|
/**
|
* 连接断开（包括主动断开和意外断开）
|
*/
|
void onDisconnected();
|
|
/**
|
* 连接失败（服务未找到、特征缺失、GATT 错误等）
|
*/
|
void onConnectionFailed(String reason);
|
}
|
|
public interface WriteListener {
|
/**
|
* 写入成功
|
*/
|
void onWriteSuccess();
|
|
/**
|
* 全部写入完成（成功为 true）
|
*/
|
void onWriteComplete(boolean success);
|
|
/**
|
* 写入失败
|
*/
|
void onWriteFailed(int status);
|
|
/**
|
* 设备通过通知返回的响应（如果有）
|
*/
|
void onDeviceResponse(String response);
|
}
|
}
|
