BLE大文件传输故障咨询：求1MB级数据传输方案及代码

Hey there! Let's tackle your BLE large data transfer problems step by step. First, let's recap your scenario: you're trying to send image data over BLE, but transmission stops around the 1KB mark. Here are answers to your questions, plus modified code to support 1MB-scale transfers.

1. Effective Methods for BLE Large Data Transfer #

These are the most reliable approaches for sending large datasets over BLE:

• MTU Negotiation: The default BLE MTU (Maximum Transmission Unit) is 23 bytes (3 bytes for ATT header + 20 bytes of payload). Negotiate a larger MTU (up to 512 bytes, depending on device support) to reduce the total number of packets needed.
• Chunked Transfer with ACK: Split your large byte array into small, MTU-sized chunks. After sending each chunk, wait for an acknowledgment (ACK) from the BLE device before sending the next. This prevents overwhelming the device and ensures no data is lost.
• Reliable Writes: Use BLE's write-with-response feature (instead of write-without-response) to guarantee each chunk is received. Pair this with a custom ACK protocol from your device to confirm successful chunk processing.
• Avoid String Conversion: Binary data like images should never be converted to strings for transmission—this can corrupt bytes outside the ASCII range. Send raw byte arrays directly.

2. Is Adding Delays During Transmission Reasonable? #

Adding fixed delays is a quick, temporary workaround but not a robust long-term solution:

• It’s unreliable: Different BLE devices have varying processing speeds—what works for one device may cause timeouts or unnecessary waits on another.
• It doesn’t handle packet loss: If a chunk is lost, a delay won’t trigger a retransmission.
• That said, if you need a stopgap while implementing a proper ACK system, small delays (10-50ms) between chunks can help. But the correct approach is to build an ACK-based flow control system where you only send the next chunk after receiving confirmation from the device.

3. Sample Code for 1MB-Level BLE Data Transfer #

Below is modified code based on your existing implementation, with fixes for binary data handling, MTU negotiation, and ACK-based chunked transfer.

First, Update BluetoothLeService #

Add MTU negotiation, raw byte writing, and ACK broadcasting:

public class BluetoothLeService extends Service {
    // Existing constants...
    public static final String ACTION_CHUNK_ACK = "com.example.bluetooth.le.ACTION_CHUNK_ACK";
    public static final String EXTRA_CHUNK_INDEX = "com.example.bluetooth.le.EXTRA_CHUNK_INDEX";
    public int negotiatedMtu = 20; // Default payload size (MTU 23 - 3 ATT header)

    // Request MTU after connecting
    public void requestMtu(int desiredMtu) {
        if (mBluetoothGatt == null) {
            Log.w(TAG, "BluetoothGatt not initialized");
            return;
        }
        mBluetoothGatt.requestMtu(desiredMtu);
    }

    // Handle MTU negotiation result
    @Override
    public void onMtuChanged(BluetoothGatt gatt, int mtu, int status) {
        super.onMtuChanged(gatt, mtu, status);
        if (status == BluetoothGatt.GATT_SUCCESS) {
            negotiatedMtu = mtu - 3; // Subtract ATT header size
            Log.i(TAG, "Negotiated MTU payload: " + negotiatedMtu + " bytes");
        } else {
            Log.w(TAG, "MTU negotiation failed, using default 20 bytes");
        }
    }

    // Write raw byte arrays (no string conversion)
    public void writeCustomCharacteristic(byte[] data, String serviceUuid, String charaUuid) {
        if (mBluetoothAdapter == null || mBluetoothGatt == null) {
            Log.w(TAG, "BluetoothAdapter not initialized");
            return;
        }
        BluetoothGattService customService = mBluetoothGatt.getService(UUID.fromString(serviceUuid));
        if (customService == null) {
            Log.w(TAG, "Custom BLE Service not found");
            return;
        }
        BluetoothGattCharacteristic writeChar = customService.getCharacteristic(UUID.fromString(charaUuid));
        writeChar.setValue(data);
        mBluetoothGatt.writeCharacteristic(writeChar); // Use reliable write with response
    }

    // Broadcast ACK received from device
    private void broadcastChunkAck(int chunkIndex) {
        Intent intent = new Intent(ACTION_CHUNK_ACK);
        intent.putExtra(EXTRA_CHUNK_INDEX, chunkIndex);
        sendBroadcast(intent);
    }

    // Add this to your GATT callback's onCharacteristicRead to handle device ACKs
    @Override
    public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
        super.onCharacteristicRead(gatt, characteristic, status);
        if (status == BluetoothGatt.GATT_SUCCESS) {
            // Assume your device returns the index of the last received chunk as ACK
            int ackedIndex = characteristic.getIntValue(BluetoothGattCharacteristic.FORMAT_UINT32, 0);
            broadcastChunkAck(ackedIndex);
        }
    }

    // Existing service code...
}

Then, Modify RxTxActivity #

Implement ACK-based chunked transfer and fix image data handling:

public class RxTxActivity extends Activity {
    byte[] imageInByte;
    private int currentChunkIndex = 0;
    private int totalChunks = 0;
    private BluetoothLeService mBluetoothLeService;
    private Context context = this;

    // Existing initialization code...

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.data_transfer);
        // Existing setup...

        // Request maximum MTU after service connects
        mBluetoothLeService.requestMtu(512);
    }

    // Broadcast receiver for chunk ACKs
    private final BroadcastReceiver mChunkAckReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if (BluetoothLeService.ACTION_CHUNK_ACK.equals(action)) {
                int ackedIndex = intent.getIntExtra(BluetoothLeService.EXTRA_CHUNK_INDEX, -1);
                if (ackedIndex == currentChunkIndex) {
                    currentChunkIndex++;
                    sendNextChunk();
                }
            }
        }
    };

    @Override
    protected void onResume() {
        super.onResume();
        registerReceiver(mGattUpdateReceiver, makeGattUpdateIntentFilter());
        registerReceiver(mChunkAckReceiver, makeChunkAckIntentFilter());
        // Existing resume code...
    }

    @Override
    protected void onPause() {
        super.onPause();
        unregisterReceiver(mGattUpdateReceiver);
        unregisterReceiver(mChunkAckReceiver);
        // Existing pause code...
    }

    private static IntentFilter makeChunkAckIntentFilter() {
        IntentFilter filter = new IntentFilter();
        filter.addAction(BluetoothLeService.ACTION_CHUNK_ACK);
        return filter;
    }

    // Fixed image conversion (no string corruption)
    public void ClickConvert(View view) {
        TextView txtView = findViewById(R.id.textview_byte);
        ImageView imageView = findViewById(R.id.imageView1);
        Bitmap bitmap = ((BitmapDrawable) imageView.getDrawable()).getBitmap();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        bitmap.compress(Bitmap.CompressFormat.JPEG, 80, baos); // Lower quality if needed
        imageInByte = baos.toByteArray();
        txtView.setText("Image size: " + imageInByte.length + " bytes");
    }

    // Modified transfer method with ACK flow control
    public void ClickImage(View view) {
        if (imageInByte == null || imageInByte.length == 0) {
            Toast.makeText(context, "No image data to send!", Toast.LENGTH_SHORT).show();
            return;
        }

        totalChunks = (int) Math.ceil((double) imageInByte.length / mBluetoothLeService.negotiatedMtu);
        currentChunkIndex = 0;
        Toast.makeText(context, "Starting transfer: " + totalChunks + " chunks", Toast.LENGTH_SHORT).show();
        sendNextChunk();
    }

    private void sendNextChunk() {
        if (currentChunkIndex >= totalChunks) {
            Toast.makeText(context, "Transfer completed successfully!", Toast.LENGTH_LONG).show();
            return;
        }

        int start = currentChunkIndex * mBluetoothLeService.negotiatedMtu;
        int end = Math.min(start + mBluetoothLeService.negotiatedMtu, imageInByte.length);
        byte[] chunk = Arrays.copyOfRange(imageInByte, start, end);

        // Send chunk (your device should respond with an ACK containing currentChunkIndex)
        mBluetoothLeService.writeCustomCharacteristic(chunk, mServiceUUID, mCharaUUID);
    }

    // Existing activity code...
}

Key Improvements: #

• Raw Byte Transfer: Eliminates string conversion that corrupts binary image data.
• MTU Optimization: Uses the largest possible payload size to minimize packet count.
• ACK-Based Flow Control: Ensures each chunk is confirmed before sending the next, preventing data loss and device overload.
• Error Handling: Adds checks for missing image data and failed MTU negotiation.

内容的提问来源于stack exchange，提问作者Cherala Vivek