@Override public void onScanResult(int callbackType, ScanResult result) { BluetoothDevice device = result.getDevice(); Log.i(TAG, "onScanResult: 扫描到设备 " + device.getName() + " RSSI：" + result.getRssi()); int rssi = result.getRssi(); // 获取当前过滤设置 TriStateToggleButton.ToggleStatus filter_status; // 过滤为false, 全部检查 if(XbyActivity.filterProduct){ filter_status = TriStateToggleButton.ToggleStatus.on; }else{ // 三种过滤模式（普通） filter_status = mScanBack.getScanFilterStatus(); } // 过滤无名称设备 if (filter_status != TriStateToggleButton.ToggleStatus.off) { // on mid 都会走无名称过滤 if (device.getName() == null) { return; } }

这段代码是在扫描蓝牙设备时的回调函数，onScanResult()方法会在每扫描到一个设备时回调一次。回调参数包括callbackType和result，其中callbackType表示回调类型，result表示扫描到的设备信息。在方法中，首先通过result.getDevice()获取扫描到的蓝牙设备对象，然后使用Log.i()方法将设备名称和信号强度等信息打印到日志中。接着获取当前的过滤设置，如果过滤为false，则不对设备进行过滤检查；否则，根据过滤模式来对设备进行过滤，例如过滤无名称设备。最后，如果设备名称为null，则返回，否则继续执行后续操作。

相关问题

BluetoothLeScanner.startScan方法代码示例实现蓝牙扫描

好的，以下是BluetoothLeScanner.startScan方法代码示例实现蓝牙扫描：

// 获取蓝牙适配器
BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
if (bluetoothAdapter == null) {
    // 设备不支持蓝牙
    return;
}

// 获取蓝牙低功耗扫描器
BluetoothLeScanner bluetoothLeScanner = bluetoothAdapter.getBluetoothLeScanner();
if (bluetoothLeScanner == null) {
    // 设备不支持蓝牙低功耗
    return;
}

// 定义扫描过滤器，只扫描符合 UUID 的设备
List<ScanFilter> scanFilters = new ArrayList<>();
ScanFilter scanFilter = new ScanFilter.Builder()
        .setServiceUuid(ParcelUuid.fromString("0000180d-0000-1000-8000-00805f9b34fb")) // 服务 UUID
        .build();
scanFilters.add(scanFilter);

// 定义扫描设置，设置扫描模式和回调
ScanSettings scanSettings = new ScanSettings.Builder()
        .setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY) // 低延迟模式
        .build();

// 开始扫描
bluetoothLeScanner.startScan(scanFilters, scanSettings, new ScanCallback() {
    @Override
    public void onScanResult(int callbackType, ScanResult result) {
        // 扫描到设备的回调
        BluetoothDevice device = result.getDevice();
        String name = device.getName();
        String address = device.getAddress();
        int rssi = result.getRssi();

        // 处理扫描结果
        Log.d(TAG, "扫描到设备：name=" + name + ", address=" + address + ", rssi=" + rssi);
    }

    @Override
    public void onScanFailed(int errorCode) {
        // 扫描失败的回调
        Log.e(TAG, "扫描失败，errorCode=" + errorCode);
    }
});

// 停止扫描
bluetoothLeScanner.stopScan(new ScanCallback() {});

希望能够帮到你。

Android BLE扫描、连接、切断连续100次代码

以下是一个简单的 Android BLE 扫描、连接、切断的代码，在进行 100 次操作时，会打印出每一次的操作结果：

public class BleScanConnectDisconnect {

    private static final String TAG = "BleScanConnectDisconnect";
    private BluetoothAdapter mBluetoothAdapter;
    private BluetoothLeScanner mBluetoothLeScanner;
    private ScanCallback mScanCallback;
    private BluetoothGatt mBluetoothGatt;
    private Handler mHandler;

    public BleScanConnectDisconnect(Context context) {
        mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
        mBluetoothLeScanner = mBluetoothAdapter.getBluetoothLeScanner();
        mHandler = new Handler();
    }

    public void startScan() {
        Log.d(TAG, "startScan");
        mScanCallback = new ScanCallback() {
            @Override
            public void onScanResult(int callbackType, ScanResult result) {
                Log.d(TAG, "onScanResult: " + result.getDevice().getName() + " " + result.getDevice().getAddress());
            }

            @Override
            public void onScanFailed(int errorCode) {
                Log.e(TAG, "onScanFailed: " + errorCode);
            }
        };
        mBluetoothLeScanner.startScan(mScanCallback);
    }

    public void stopScan() {
        Log.d(TAG, "stopScan");
        mBluetoothLeScanner.stopScan(mScanCallback);
    }

    public void connect(String address) {
        Log.d(TAG, "connect: " + address);
        BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address);
        mBluetoothGatt = device.connectGatt(context, false, new BluetoothGattCallback() {
            @Override
            public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
                Log.d(TAG, "onConnectionStateChange: " + newState);
                if (newState == BluetoothProfile.STATE_CONNECTED) {
                    gatt.discoverServices();
                }
            }

            @Override
            public void onServicesDiscovered(BluetoothGatt gatt, int status) {
                Log.d(TAG, "onServicesDiscovered: " + status);
            }

            @Override
            public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
                Log.d(TAG, "onCharacteristicRead: " + characteristic.getUuid());
            }

            @Override
            public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
                Log.d(TAG, "onCharacteristicWrite: " + characteristic.getUuid());
            }

            @Override
            public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
                Log.d(TAG, "onCharacteristicChanged: " + characteristic.getUuid());
            }

            @Override
            public void onDescriptorRead(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
                Log.d(TAG, "onDescriptorRead: " + descriptor.getUuid());
            }

            @Override
            public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
                Log.d(TAG, "onDescriptorWrite: " + descriptor.getUuid());
            }

            @Override
            public void onReliableWriteCompleted(BluetoothGatt gatt, int status) {
                Log.d(TAG, "onReliableWriteCompleted");
            }

            @Override
            public void onReadRemoteRssi(BluetoothGatt gatt, int rssi, int status) {
                Log.d(TAG, "onReadRemoteRssi: " + rssi);
            }
        });
    }

    public void disconnect() {
        Log.d(TAG, "disconnect");
        if (mBluetoothGatt != null) {
            mBluetoothGatt.disconnect();
        }
    }

    public void close() {
        Log.d(TAG, "close");
        if (mBluetoothGatt != null) {
            mBluetoothGatt.close();
        }
    }

    public void test() {
        for (int i = 0; i < 100; i++) {
            Log.d(TAG, "============================= " + (i + 1) + " =============================");
            startScan();
            mHandler.postDelayed(new Runnable() {
                @Override
                public void run() {
                    stopScan();
                }
            }, 5000);
            mHandler.postDelayed(new Runnable() {
                @Override
                public void run() {
                    connect("00:00:00:00:00:00");
                }
            }, 6000);
            mHandler.postDelayed(new Runnable() {
                @Override
                public void run() {
                    disconnect();
                }
            }, 8000);
            mHandler.postDelayed(new Runnable() {
                @Override
                public void run() {
                    close();
                }
            }, 10000);
        }
    }
}

在 `test()` 方法中，我们进行了 100 次操作，每一次操作都包括开始扫描、停止扫描、连接、切断和关闭。每一次操作之间会有一定的时间间隔，可以根据实际情况进行调整。在操作完成后，会打印出每一次操作的结果。