当前位置：首页 > article >正文

Android 蓝牙工具类封装：支持经典蓝牙与 BLE，兼容高版本权限

article 2025/3/13 0:53:15

为了优化经典蓝牙（Classic Bluetooth）和低功耗蓝牙（Bluetooth Low Energy, BLE）的操作，我们可以将功能封装到一个工具类中，支持扫描、连接、通信，并兼容高版本 Android 的动态权限申请。以下是完整的工具类实现。

工具类功能
经典蓝牙：

扫描设备。

连接设备。

发送和接收数据。

BLE 蓝牙：

扫描设备。

连接设备。

发送和接收数据（通过 GATT 特征值）。

权限管理：

动态申请权限（包括 ACCESS_FINE_LOCATION、BLUETOOTH_SCAN、BLUETOOTH_CONNECT）。

高版本兼容：

支持 Android 12 及以上版本的权限要求。

工具类实现
2.1 BluetoothHelper.java

import android.Manifest;
import android.annotation.SuppressLint;
import android.bluetooth.*;
import android.bluetooth.le.BluetoothLeScanner;
import android.bluetooth.le.ScanCallback;
import android.bluetooth.le.ScanResult;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageManager;
import android.os.Build;
import android.os.Handler;
import android.os.Looper;
import androidx.annotation.NonNull;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

public class BluetoothHelper {

    private static final UUID MY_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"); // SPP UUID
    private static final int PERMISSION_REQUEST_CODE = 100;

    private Context context;
    private BluetoothAdapter bluetoothAdapter;
    private BluetoothLeScanner bleScanner;
    private BluetoothSocket bluetoothSocket;
    private BluetoothGatt bluetoothGatt;
    private Handler handler;
    private List<BluetoothDevice> classicDevices = new ArrayList<>();
    private List<BluetoothDevice> bleDevices = new ArrayList<>();

    // BLE 相关变量
    private BluetoothGattCharacteristic writeCharacteristic;
    private BluetoothGattCharacteristic notifyCharacteristic;

    // 回调接口
    public interface ScanCallback {
        void onClassicDeviceFound(BluetoothDevice device);
        void onBleDeviceFound(BluetoothDevice device);
        void onScanFailed(String error);
    }

    public interface ConnectionCallback {
        void onConnected();
        void onConnectionFailed(String error);
    }

    public interface DataCallback {
        void onDataReceived(byte[] data);
        void onDataSent(boolean success);
    }

    public BluetoothHelper(Context context) {
        this.context = context;
        this.handler = new Handler(Looper.getMainLooper());
        this.bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
        if (bluetoothAdapter != null) {
            this.bleScanner = bluetoothAdapter.getBluetoothLeScanner();
        }
    }

    // 检查权限
    public boolean checkPermissions() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
            return ContextCompat.checkSelfPermission(context, Manifest.permission.BLUETOOTH_SCAN) == PackageManager.PERMISSION_GRANTED &&
                    ContextCompat.checkSelfPermission(context, Manifest.permission.BLUETOOTH_CONNECT) == PackageManager.PERMISSION_GRANTED &&
                    ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED;
        } else {
            return ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED;
        }
    }

    // 请求权限
    public void requestPermissions() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
            ActivityCompat.requestPermissions((MainActivity) context,
                    new String[]{
                            Manifest.permission.BLUETOOTH_SCAN,
                            Manifest.permission.BLUETOOTH_CONNECT,
                            Manifest.permission.ACCESS_FINE_LOCATION
                    },
                    PERMISSION_REQUEST_CODE);
        } else {
            ActivityCompat.requestPermissions((MainActivity) context,
                    new String[]{
                            Manifest.permission.ACCESS_FINE_LOCATION
                    },
                    PERMISSION_REQUEST_CODE);
        }
    }

    // 开始扫描经典蓝牙设备
    public void startClassicScan(ScanCallback callback) {
        if (!checkPermissions()) {
            callback.onScanFailed("Permissions not granted");
            return;
        }

        classicDevices.clear();
        IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
        context.registerReceiver(new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                String action = intent.getAction();
                if (BluetoothDevice.ACTION_FOUND.equals(action)) {
                    BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
                    classicDevices.add(device);
                    callback.onClassicDeviceFound(device);
                }
            }
        }, filter);

        bluetoothAdapter.startDiscovery();
    }

    // 开始扫描 BLE 设备
    @SuppressLint("MissingPermission")
    public void startBleScan(ScanCallback callback) {
        if (!checkPermissions()) {
            callback.onScanFailed("Permissions not granted");
            return;
        }

        bleDevices.clear();
        bleScanner.startScan(new ScanCallback() {
            @Override
            public void onScanResult(int callbackType, ScanResult result) {
                BluetoothDevice device = result.getDevice();
                bleDevices.add(device);
                callback.onBleDeviceFound(device);
            }

            @Override
            public void onScanFailed(int errorCode) {
                callback.onScanFailed("BLE scan failed with error code: " + errorCode);
            }
        });
    }

    // 停止扫描
    @SuppressLint("MissingPermission")
    public void stopScan() {
        bluetoothAdapter.cancelDiscovery();
        if (bleScanner != null) {
            bleScanner.stopScan(null);
        }
    }

    // 连接经典蓝牙设备
    public void connectClassicDevice(BluetoothDevice device, ConnectionCallback callback) {
        new Thread(() -> {
            try {
                bluetoothSocket = device.createRfcommSocketToServiceRecord(MY_UUID);
                bluetoothSocket.connect();
                handler.post(callback::onConnected);
            } catch (IOException e) {
                handler.post(() -> callback.onConnectionFailed(e.getMessage()));
            }
        }).start();
    }

    // 连接 BLE 设备
    @SuppressLint("MissingPermission")
    public void connectBleDevice(BluetoothDevice device, BluetoothGattCallback gattCallback) {
        bluetoothGatt = device.connectGatt(context, false, gattCallback);
    }

    // 发送数据（经典蓝牙）
    public void sendClassicData(byte[] data, DataCallback callback) {
        new Thread(() -> {
            try {
                OutputStream outputStream = bluetoothSocket.getOutputStream();
                outputStream.write(data);
                handler.post(() -> callback.onDataSent(true));
            } catch (IOException e) {
                handler.post(() -> callback.onDataSent(false));
            }
        }).start();
    }

    // 接收数据（经典蓝牙）
    public void receiveClassicData(DataCallback callback) {
        new Thread(() -> {
            try {
                InputStream inputStream = bluetoothSocket.getInputStream();
                byte[] buffer = new byte[1024];
                int bytes;
                while ((bytes = inputStream.read(buffer)) != -1) {
                    byte[] receivedData = new byte[bytes];
                    System.arraycopy(buffer, 0, receivedData, 0, bytes);
                    handler.post(() -> callback.onDataReceived(receivedData));
                }
            } catch (IOException e) {
                handler.post(() -> callback.onDataReceived(null));
            }
        }).start();
    }

    // 发送数据（BLE）
    @SuppressLint("MissingPermission")
    public void sendBleData(byte[] data, DataCallback callback) {
        if (writeCharacteristic != null && bluetoothGatt != null) {
            writeCharacteristic.setValue(data);
            bluetoothGatt.writeCharacteristic(writeCharacteristic);
            handler.post(() -> callback.onDataSent(true));
        } else {
            handler.post(() -> callback.onDataSent(false));
        }
    }

    // 启用通知以接收数据（BLE）
    @SuppressLint("MissingPermission")
    public void enableBleNotifications(BluetoothGattCharacteristic characteristic, DataCallback callback) {
        if (bluetoothGatt != null) {
            bluetoothGatt.setCharacteristicNotification(characteristic, true);
            BluetoothGattDescriptor descriptor = characteristic.getDescriptor(
                    UUID.fromString("00002902-0000-1000-8000-00805f9b34fb"));
            if (descriptor != null) {
                descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
                bluetoothGatt.writeDescriptor(descriptor);
            }
        }
    }

    // 断开连接
    public void disconnect() {
        try {
            if (bluetoothSocket != null) {
                bluetoothSocket.close();
            }
            if (bluetoothGatt != null) {
                bluetoothGatt.disconnect();
                bluetoothGatt.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.2 使用示例
扫描设备

BluetoothHelper bluetoothHelper = new BluetoothHelper(this);

// 扫描经典蓝牙设备
bluetoothHelper.startClassicScan(new BluetoothHelper.ScanCallback() {
    @Override
    public void onClassicDeviceFound(BluetoothDevice device) {
        Log.d("BluetoothHelper", "Classic Device Found: " + device.getName());
    }

    @Override
    public void onBleDeviceFound(BluetoothDevice device) {
        Log.d("BluetoothHelper", "BLE Device Found: " + device.getName());
    }

    @Override
    public void onScanFailed(String error) {
        Log.e("BluetoothHelper", "Scan Failed: " + error);
    }
});

// 扫描 BLE 设备
bluetoothHelper.startBleScan(new BluetoothHelper.ScanCallback() {
    @Override
    public void onClassicDeviceFound(BluetoothDevice device) {
        Log.d("BluetoothHelper", "Classic Device Found: " + device.getName());
    }

    @Override
    public void onBleDeviceFound(BluetoothDevice device) {
        Log.d("BluetoothHelper", "BLE Device Found: " + device.getName());
    }

    @Override
    public void onScanFailed(String error) {
        Log.e("BluetoothHelper", "Scan Failed: " + error);
    }
});

连接设备

// 连接经典蓝牙设备
bluetoothHelper.connectClassicDevice(device, new BluetoothHelper.ConnectionCallback() {
    @Override
    public void onConnected() {
        Log.d("BluetoothHelper", "Classic Device Connected");
    }

    @Override
    public void onConnectionFailed(String error) {
        Log.e("BluetoothHelper", "Connection Failed: " + error);
    }
});

// 连接 BLE 设备
bluetoothHelper.connectBleDevice(device, new BluetoothGattCallback() {
    @Override
    public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
        if (newState == BluetoothProfile.STATE_CONNECTED) {
            Log.d("BluetoothHelper", "BLE Device Connected");
        } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
            Log.d("BluetoothHelper", "BLE Device Disconnected");
        }
    }
});

经典蓝牙发送和接收数据

// 发送数据（经典蓝牙）
bluetoothHelper.sendClassicData("Hello Bluetooth".getBytes(), new BluetoothHelper.DataCallback() {
    @Override
    public void onDataReceived(byte[] data) {
        // 处理接收到的数据
    }

    @Override
    public void onDataSent(boolean success) {
        Log.d("BluetoothHelper", "Data Sent: " + success);
    }
});

// 接收数据（经典蓝牙）
bluetoothHelper.receiveClassicData(new BluetoothHelper.DataCallback() {
    @Override
    public void onDataReceived(byte[] data) {
        Log.d("BluetoothHelper", "Data Received: " + new String(data));
    }

    @Override
    public void onDataSent(boolean success) {
        // 无需处理
    }
});

BLE蓝牙发送和接收数据

// 连接 BLE 设备
bluetoothHelper.connectBleDevice(device, new BluetoothGattCallback() {
    @Override
    public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
        if (newState == BluetoothProfile.STATE_CONNECTED) {
            gatt.discoverServices();
        }
    }

    @Override
    public void onServicesDiscovered(BluetoothGatt gatt, int status) {
        if (status == BluetoothGatt.GATT_SUCCESS) {
            BluetoothGattService service = gatt.getService(UUID.fromString("你的服务UUID"));
            if (service != null) {
                writeCharacteristic = service.getCharacteristic(UUID.fromString("写特征值UUID"));
                notifyCharacteristic = service.getCharacteristic(UUID.fromString("通知特征值UUID"));

                // 启用通知
                bluetoothHelper.enableBleNotifications(notifyCharacteristic, new BluetoothHelper.DataCallback() {
                    @Override
                    public void onDataReceived(byte[] data) {
                        Log.d("BluetoothHelper", "BLE Data Received: " + new String(data));
                    }

                    @Override
                    public void onDataSent(boolean success) {
                        // 无需处理
                    }
                });
            }
        }
    }

    @Override
    public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
        byte[] data = characteristic.getValue();
        Log.d("BluetoothHelper", "BLE Notification Data: " + new String(data));
    }
});

// 发送数据（BLE）
bluetoothHelper.sendBleData("Hello BLE".getBytes(), new BluetoothHelper.DataCallback() {
    @Override
    public void onDataReceived(byte[] data) {
        // 无需处理
    }

    @Override
    public void onDataSent(boolean success) {
        Log.d("BluetoothHelper", "BLE Data Sent: " + success);
    }
});

2.3 注意事项
权限管理：

在 Android 12 及以上版本，需要动态申请 BLUETOOTH_SCAN 和 BLUETOOTH_CONNECT 权限。

在 Android 11 及以下版本，需要动态申请 ACCESS_FINE_LOCATION 权限。

高版本兼容：

使用 @SuppressLint(“MissingPermission”) 忽略权限检查，确保在实际运行时已授予权限。

线程管理：

经典蓝牙的通信操作应在后台线程中进行，避免阻塞主线程。
通过以上工具类，你可以轻松实现经典蓝牙和 BLE 的扫描、连接和通信功能，并兼容高版本 Android 的权限要求。

查看全文

http://www.kler.cn/a/582063.html