基于CoreBluetooth的iOS设备间图片传输异常问题求助

Hey there! Let’s walk through why your CoreBluetooth image transfer is failing and how to fix it. The PNG invalid chunk error and mismatched byte counts are classic signs of unhandled large data transfer over Bluetooth—here’s the breakdown and solutions:

Core Issues Behind the Error #

• MTU Limitations: Strings work because they fit in CoreBluetooth’s default small MTU (max ~23 usable bytes), but image data is way larger. Without splitting data into chunks, you’ll get truncated or corrupted payloads, which breaks the PNG structure (hence the missing iEnd chunk).
• Unmanaged Data Concatenation: The larger received byte count likely means duplicate or out-of-order packets are being appended, muddling the final data.

Step-by-Step Fixes #

1. Negotiate a Larger MTU First #

Bluetooth allows increasing the MTU up to 512 bytes (device-dependent), which reduces the number of packets you need to send.

Central Side (after connection):

func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
    peripheral.requestMTU(512) // Request maximum supported MTU
}

Peripheral Side (confirm MTU update):

func peripheralManager(_ peripheral: CBPeripheralManager, didUpdateMTU mtu: Int) {
    print("Updated MTU to \(mtu)")
    // Use mtu - 3 for safe packet size (accounts for Bluetooth protocol overhead)
}

2. Validate Image-to-Data Conversion #

Ensure your image converts to valid PNG data before sending—UIImage.pngData() can return nil for unsupported image formats.

Peripheral Side:

guard let image = UIImage(named: "your-target-image"), 
      let imageData = image.pngData() else {
    print("Failed to generate valid PNG data from image")
    return
}
print("Original image data size: \(imageData.count) bytes")

3. Implement Chunked Data Sending #

Split the image data into small, MTU-compliant chunks and send them sequentially (wait for confirmation before sending the next chunk).

Peripheral Side Chunk Logic:

var imageData: Data!
var currentChunkIndex = 0
let maxChunkSize = 500 // Adjust based on your negotiated MTU (leave buffer for overhead)

func startImageTransfer(with image: UIImage) {
    guard let data = image.pngData() else { return }
    imageData = data
    currentChunkIndex = 0
    sendNextChunk()
}

private func sendNextChunk() {
    guard imageData != nil else { return }
    
    let remainingBytes = imageData.count - currentChunkIndex
    let chunkSize = min(remainingBytes, maxChunkSize)
    let chunk = imageData.subdata(in: currentChunkIndex..<currentChunkIndex+chunkSize)
    
    // Send chunk to your characteristic
    peripheralManager.updateValue(chunk, for: yourTransferCharacteristic, onSubscribedCentrals: nil)
    
    currentChunkIndex += chunkSize
}

// Callback to trigger next chunk after successful send
func peripheralManager(_ peripheral: CBPeripheralManager, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
    guard error == nil else {
        print("Failed to send chunk: \(error!)")
        return // Add retry logic here if needed
    }
    
    if currentChunkIndex < imageData.count {
        sendNextChunk()
    } else {
        print("All image chunks sent successfully!")
    }
}

4. Properly Concatenate Chunks on the Central Side #

Track received data, verify completeness, and avoid duplicate/out-of-order chunks. Add a pre-transfer step to send the total expected byte count so the central knows when transfer is done.

Central Side Reception Logic:

var receivedImageData = Data()
var expectedTotalBytes = 0
var isReceivingImage = false

func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
    guard let data = characteristic.value else { return }
    
    if !isReceivingImage {
        // First packet = total expected bytes (stored as 4-byte UInt32)
        if data.count == 4 {
            expectedTotalBytes = Int(data.withUnsafeBytes { $0.load(as: UInt32.self) })
            receivedImageData.removeAll()
            isReceivingImage = true
            print("Starting image transfer, expecting \(expectedTotalBytes) bytes")
        }
    } else {
        receivedImageData.append(data)
        print("Received \(data.count) bytes | Total so far: \(receivedImageData.count)")
        
        // Check if transfer is complete
        if receivedImageData.count == expectedTotalBytes {
            isReceivingImage = false
            // Validate and use the image
            if let receivedImage = UIImage(data: receivedImageData) {
                print("Image transfer successful!")
                // Display or process the image here
            } else {
                print("Invalid image data—check chunk ordering or integrity")
                // Debug: Print first/last 8 bytes to verify PNG signature/iEnd chunk
                print("First 8 bytes: \(receivedImageData.subdata(in: 0..<8))")
                print("Last 8 bytes: \(receivedImageData.subdata(in: receivedImageData.count-8..<receivedImageData.count))")
            }
        }
    }
}

5. Add Chunk Sequencing (Optional but Recommended) #

To prevent out-of-order chunks, add a 2-byte sequence number to each packet. The central can then store chunks in a dictionary and concatenate them in order once all are received.

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