Senden von Bilddateien über Bluetooth 4.0 LE

Question

Ich versuche, eine .png-Bilddatei über Bluetooth 4.0 LE von einem iOS-Gerät an ein anderes zu senden.

Ich bin in der Lage, einfache Daten wie Zeichenfolgen, aber nicht erfolgreich senden und Bilddateien verwenden.

in dem Peripheriegerät, beginne ich mit diesem Dann

pictureBeforeData = [UIImage imageNamed:@"myImage.png"]; 
NSData *myData = UIImagePNGRepresentation(pictureBeforeData); 

I machen myData Wert einer Charakteristik.

_myCharacteristic = 
[[CBMutableCharacteristic alloc] initWithType:_myCharacteristicUUID 
            properties:CBCharacteristicPropertyRead 
             value:myData 
            permissions:CBAttributePermissionsReadable]; 

im Zentralgerät, habe ich dies, wenn der Wert des charakteristischen

- (void)peripheral:(CBPeripheral *)peripheral didUpdateValueForCharacteristic:(CBCharacteristic *)characteristic error:(NSError *)error { 
    if ([characteristic.UUID isEqual:[CBUUID UUIDWithString:_myCharacteristicUUID]]) { 
    NSLog(@"PICTURE CHARACTERISTIC FOUND"); // This successfully gets logged 

    NSData *dataFromCharacteristic = [[NSData alloc] initWithData:characteristic.value]; 

    UIImage *imageFromData = [[UIImage alloc]initWithData:dataFromCharacteristic]; 

    // This correctly logs the size of my image 
    NSLog(@"SIZE: %f, %f", imageFromData.size.height, imageFromData.size.width); 

    // This causes the imageView to turn completely black 
    _sentPictureImageView.image = imageFromData; 

    if (!([_myImagesArray containsObject:imageFromData])) 
    { 
     NSLog(@"DOES NOT CONTAIN"); // This is successfully logged 
     [_myImagesArray addObject:imageFromData]; // This runs but is apparently not adding the image to the array 
    } 

    NSLog(@"COUNT: %u", _contactsImagesArray.count); // This always logs 0 - The array is empty } 

8-27-13 EDIT aktualisiert: Ich bin in der Lage eine einzige Farbe 1by1 Pixel senden über .png Datei erfolgreich ist diese Datei ca. 5.600 Bytes groß. Ich kann keine mehrfarbige 20by20pixel.png-Datei senden, die nur etwa 2.000 Byte groß ist. Ich bin in der Lage, die größere Datei zu senden, die nur eine Farbe und weniger Pixel enthält, aber die kleinere Datei, die viele Farben und mehr Pixel enthält, nicht senden kann.

EDIT 8-30-13: Ich muss definitiv die Daten in kleinere Stücke analysieren. In einem von Apples Beispielprojekten habe ich eine Methode gefunden, die genau das tut. Ich kann nicht genau verstehen, wie ich das in meinem eigenen Code implementiere, aber ich versuche gerade herauszufinden, wie. Hier ist der Code:

- (void)sendData { 
// First up, check if we're meant to be sending an EOM 
static BOOL sendingEOM = NO; 

if (sendingEOM) { 

    // send it 
    BOOL didSend = [self.peripheralManager updateValue:[@"EOM" dataUsingEncoding:NSUTF8StringEncoding] forCharacteristic:self.transferCharacteristic onSubscribedCentrals:nil]; 

    // Did it send? 
    if (didSend) { 

     // It did, so mark it as sent 
     sendingEOM = NO; 

     NSLog(@"Sent: EOM"); 
    } 

    // It didn't send, so we'll exit and wait for peripheralManagerIsReadyToUpdateSubscribers to call sendData again 
    return; 
} 

// We're not sending an EOM, so we're sending data 

// Is there any left to send? 

if (self.sendDataIndex >= self.dataToSend.length) { 

    // No data left. Do nothing 
    return; 
} 

// There's data left, so send until the callback fails, or we're done. 

BOOL didSend = YES; 

while (didSend) { 

    // Make the next chunk 

    // Work out how big it should be 
    NSInteger amountToSend = self.dataToSend.length - self.sendDataIndex; 

    // Can't be longer than 20 bytes 
    if (amountToSend > NOTIFY_MTU) amountToSend = NOTIFY_MTU; 

    // Copy out the data we want 
    NSData *chunk = [NSData dataWithBytes:self.dataToSend.bytes+self.sendDataIndex length:amountToSend]; 

    // Send it 
    didSend = [self.peripheralManager updateValue:chunk forCharacteristic:self.transferCharacteristic onSubscribedCentrals:nil]; 

    // If it didn't work, drop out and wait for the callback 
    if (!didSend) { 
     return; 
    } 

    NSString *stringFromData = [[NSString alloc] initWithData:chunk encoding:NSUTF8StringEncoding]; 
    NSLog(@"Sent: %@", stringFromData); 

    // It did send, so update our index 
    self.sendDataIndex += amountToSend; 

    // Was it the last one? 
    if (self.sendDataIndex >= self.dataToSend.length) { 

     // It was - send an EOM 

     // Set this so if the send fails, we'll send it next time 
     sendingEOM = YES; 

     // Send it 
     BOOL eomSent = [self.peripheralManager updateValue:[@"EOM" dataUsingEncoding:NSUTF8StringEncoding] forCharacteristic:self.transferCharacteristic onSubscribedCentrals:nil]; 

     if (eomSent) { 
      // It sent, we're all done 
      sendingEOM = NO; 

      NSLog(@"Sent: EOM"); 
     } 

     return; 
    } 
}} 

Mein imageView das schwarze Quadrat ist, der das Bild anzeigt soll ich geschickt haben.

Answer 1

BTLE ist in Bezug auf die Menge der Daten, die sowohl in den Eigenschaften als auch in jedem Datenpaket gesendet werden können, erheblich eingeschränkt. Sie sollten die Verbindung zwischen den Geräten herstellen und dann die Bilddaten aufteilen und mehrere kleine Pakete senden. Die WWDC-Videos 2013 bieten Ihnen einen guten Überblick und Codebeispiele.

Answer 2

Auf iOS 6 können Sie mit BLE etwa 20 Byte große Datenblöcke senden. Für ein Beispiel, wie Sie die zu sendenden Daten teilen und Benachrichtigungen basierend auf der Übertragung verwenden können, laden Sie die BTLE Transfer Apple Example application herunter.

Um zu verstehen, welche Geschwindigkeiten Sie erreichen können, empfehle ich Ihnen, dieses Diagramm zu analysieren http://www.scriptreactor.com/conn_interval-throughput.pdf Es zeigt die erreichbaren Geschwindigkeiten als eine Funktion des Verbindungsintervalls. iOS gibt Ihnen keine so feinkörnige Kontrolle, aber diese Information ist immer noch wertvoll für Sie mit zu berechnen.