Ich implementiere Push-Benachrichtigungen. Ich möchte mein APNS-Token als Zeichenfolge speichern.

- (void)application:(UIApplication *)application
didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)newDeviceToken
{
    NSString *tokenString = [NSString stringWithUTF8String:[newDeviceToken bytes]]; //[[NSString alloc]initWithData:newDeviceToken encoding:NSUTF8StringEncoding];
    NSLog(@"%@", tokenString);
    NSLog(@"%@", newDeviceToken);
}

Die erste Codezeile gibt null aus. Der zweite druckt den Token. Wie kann ich mein newDeviceToken als NSString erhalten?

benutze das :

NSString * deviceTokenString = [[[[deviceToken description]
                         stringByReplacingOccurrencesOfString: @"<" withString: @""] 
                        stringByReplacingOccurrencesOfString: @">" withString: @""] 
                       stringByReplacingOccurrencesOfString: @" " withString: @""];

NSLog(@"The generated device token string is : %@",deviceTokenString);

Wenn jemand nach einer Möglichkeit sucht, dies in Swift zu tun:

func application(application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: NSData) {
    let tokenChars = UnsafePointer<CChar>(deviceToken.bytes)
    var tokenString = ""

    for i in 0..<deviceToken.length {
        tokenString += String(format: "%02.2hhx", arguments: [tokenChars[i]])
    }

    print("tokenString: \(tokenString)")
}

Bearbeiten: Für Swift 3

Swift 3 führt den DataTyp mit Wertsemantik ein. Um das deviceTokenin einen String zu konvertieren , haben Sie folgende Möglichkeiten:

func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
    let token = deviceToken.map { String(format: "%02.2hhx", $0) }.joined()
    print(token)
}

Jemand hat mir dabei geholfen. Ich gehe nur weiter

- (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)devToken {

    const unsigned *tokenBytes = [deviceToken bytes];
    NSString *hexToken = [NSString stringWithFormat:@"%08x%08x%08x%08x%08x%08x%08x%08x",
                         ntohl(tokenBytes[0]), ntohl(tokenBytes[1]), ntohl(tokenBytes[2]),
                         ntohl(tokenBytes[3]), ntohl(tokenBytes[4]), ntohl(tokenBytes[5]),
                         ntohl(tokenBytes[6]), ntohl(tokenBytes[7])];

    [[MyModel sharedModel] setApnsToken:hexToken];
}

Sie könnten dies verwenden

- (NSString *)stringWithDeviceToken:(NSData *)deviceToken {
    const char *data = [deviceToken bytes];
    NSMutableString *token = [NSMutableString string];

    for (NSUInteger i = 0; i < [deviceToken length]; i++) {
        [token appendFormat:@"%02.2hhX", data[i]];
    }

    return [token copy];
}

Für diejenigen, die in Swift 3 und einfachste Methode wollen

func extractTokenFromData(deviceToken:Data) -> String {
    let token = deviceToken.reduce("", {$0 + String(format: "%02X", $1)})
    return token.uppercased();
}

Erklärung %02.2hhxin der Antwort mit hoher Stimme :

• %: Führt den xKonvertierungsspezifizierer ein.
• 02: Die Mindestbreite des konvertierten Werts beträgt 2. Wenn der konvertierte Wert weniger Bytes als die Feldbreite hat, wird er 0links aufgefüllt .
• .2: Gibt die Mindestanzahl von Stellen an, die für das angezeigt werden sollen x Konvertierungsspezifizierer angezeigt werden sollen.
• hh: Gibt an, dass die x Konvertierungsspezifizierer für ein vorzeichenbehaftetes Zeichen oder ein vorzeichenloses Zeichenargument gilt (das Argument wurde gemäß den ganzzahligen Heraufstufungen heraufgestuft, sein Wert wird jedoch vor dem Drucken in vorzeichenbehaftetes Zeichen oder vorzeichenloses Zeichen konvertiert).
• x: Das vorzeichenlose Argument wird im Stil "dddd" in ein vorzeichenloses Hexadezimalformat konvertiert. Die Buchstaben "abcdef" werden verwendet. Die Genauigkeit gibt die Mindestanzahl der anzuzeigenden Stellen an. Wenn der konvertierte Wert in weniger Ziffern dargestellt werden kann, wird er mit führenden Nullen erweitert. Die Standardgenauigkeit ist 1. Das Ergebnis der Konvertierung von Null mit einer expliziten Genauigkeit von Null darf keine Zeichen sein.

Weitere Informationen finden Sie in der IEEE-Druckspezifikation .

Aufgrund der obigen Erklärung denke ich, dass es besser ist, %02.2hhxzu %02xoder zu wechseln%.2x .

Für Swift 5 sind alle folgenden Methoden möglich:

deviceToken.map({String(format: "%02x", $0)}).joined()

deviceToken.map({String(format: "%.2x", $0)}).joined()

deviceToken.reduce("", {$0 + String(format: "%02x", $1)})

deviceToken.reduce("", {$0 + String(format: "%.2x", $1)})

Der Test ist wie folgt:

let deviceToken = (0..<32).reduce(Data(), {$0 + [$1]})
print(deviceToken.reduce("", {$0 + String(format: "%.2x", $1)}))
// Print content:
// 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f

Es ist meine Lösung und funktioniert gut in meiner App:

    NSString* newToken = [[[NSString stringWithFormat:@"%@",deviceToken] 
stringByTrimmingCharactersInSet:[NSCharacterSet characterSetWithCharactersInString:@"<>"]] stringByReplacingOccurrencesOfString:@" " withString:@""];

• convert NSDatazu NSStringmitstringWithFormat
• Trimmen Sie das "<>"
• Entfernen Sie die Leerzeichen

Ich denke, das Konvertieren von deviceToken in eine Hex-Byte-Zeichenfolge hat keinen Sinn. Warum? Sie senden es an Ihr Backend, wo es in Bytes umgewandelt wird, um an APNS gesendet zu werden. Verwenden Sie also die Methode von NSDatabase64EncodedStringWithOptions , übertragen Sie sie auf den Server und verwenden Sie dann umgekehrte base64decodierte Daten :) Das ist so viel einfacher :)

NSString *tokenString = [tokenData base64EncodedStringWithOptions:NSDataBase64EncodingEndLineWithLineFeed];

In iOS 13 descriptionwird kaputt gehen, also benutze dies

let deviceTokenString = deviceToken.map { String(format: "%02x", $0) }.joined()

Lassen Sie uns dies der Klarheit halber aufschlüsseln und jeden Teil erklären:

Die Kartenmethode bearbeitet jedes Element einer Sequenz. Da Daten in Swift eine Folge von Bytes sind, wird der übergebene Abschluss für jedes Byte in deviceToken ausgewertet. Der String (Format :) -Initialisierer wertet jedes Byte in den Daten (dargestellt durch den anonymen Parameter $ 0) unter Verwendung des Formatbezeichners% 02x aus, um eine mit Nullen aufgefüllte, zweistellige hexadezimale Darstellung der Byte / 8-Bit-Ganzzahl zu erzeugen. Nach dem Sammeln jeder von der Map-Methode erstellten Bytedarstellung verkettet join () jedes Element zu einer einzelnen Zeichenfolge.

PS Beschreibung nicht verwenden gibt unterschiedliche Zeichenfolgen in iOS 12 und iOS 13 und nicht sicher für zukünftige Umfang. Entwickler sollten sich bei der Beschreibung eines Objekts nicht auf ein bestimmtes Format verlassen haben.

// iOS 12
(deviceToken as NSData).description // "<965b251c 6cb1926d e3cb366f dfb16ddd e6b9086a 8a3cac9e 5f857679 376eab7C>"

// iOS 13
(deviceToken as NSData).description // "{length = 32, bytes = 0x965b251c 6cb1926d e3cb366f dfb16ddd ... 5f857679 376eab7c }"

Weitere Informationen finden Sie unter Dies .

In iOS 13 hat die Beschreibung ein anderes Format. Verwenden Sie bitte den folgenden Code, um das Geräte-Token abzurufen.

- (NSString *)fetchDeviceToken:(NSData *)deviceToken {
    NSUInteger len = deviceToken.length;
    if (len == 0) {
        return nil;
    }
    const unsigned char *buffer = deviceToken.bytes;
    NSMutableString *hexString  = [NSMutableString stringWithCapacity:(len * 2)];
    for (int i = 0; i < len; ++i) {
        [hexString appendFormat:@"%02x", buffer[i]];
    }
    return [hexString copy];
}

Dies ist eine etwas kürzere Lösung:

NSData *token = // ...
const uint64_t *tokenBytes = token.bytes;
NSString *hex = [NSString stringWithFormat:@"%016llx%016llx%016llx%016llx",
                 ntohll(tokenBytes[0]), ntohll(tokenBytes[1]),
                 ntohll(tokenBytes[2]), ntohll(tokenBytes[3])];

Funktionale Swift-Version

Einzeiler:

let hexString = UnsafeBufferPointer<UInt8>(start: UnsafePointer(data.bytes),
count: data.length).map { String(format: "%02x", $0) }.joinWithSeparator("")

Hier ist eine wiederverwendbare und selbstdokumentierende Erweiterungsform:

extension NSData {
    func base16EncodedString(uppercase uppercase: Bool = false) -> String {
        let buffer = UnsafeBufferPointer<UInt8>(start: UnsafePointer(self.bytes),
                                                count: self.length)
        let hexFormat = uppercase ? "X" : "x"
        let formatString = "%02\(hexFormat)"
        let bytesAsHexStrings = buffer.map {
            String(format: formatString, $0)
        }
        return bytesAsHexStrings.joinWithSeparator("")
    }
}

Alternativ können Sie verwenden, reduce("", combine: +)anstatt joinWithSeparator("")von Ihren Kollegen als funktionaler Master angesehen zu werden.

Bearbeiten: Ich habe String ($ 0, Radix: 16) in String (Format: "% 02x", $ 0) geändert, da einstellige Zahlen eine Auffüll-Null benötigen

(Ich weiß noch nicht, wie ich eine Frage als Duplikat dieser anderen Frage markieren soll , also habe ich meine Antwort einfach erneut gepostet.)

2020

Token als Text ...

let tat = deviceToken.map{ data in String(format: "%02.2hhx", data) }.joined()

oder wenn Sie es vorziehen

let tat2 = deviceToken.map { String(format: "%02.2hhx", $0) }.joined()

(Ergebnis ist das gleiche)

Ich warf meine Antwort auf den Stapel. Vermeiden Sie das Parsen von Zeichenfolgen. Die Dokumente garantieren nicht, dass NSData.description immer so funktioniert.

Swift 3-Implementierung:

extension Data {
    func hexString() -> String {
        var bytesPointer: UnsafeBufferPointer<UInt8> = UnsafeBufferPointer(start: nil, count: 0)
        self.withUnsafeBytes { (bytes) in
            bytesPointer = UnsafeBufferPointer<UInt8>(start: UnsafePointer(bytes), count:self.count)
        }
        let hexBytes = bytesPointer.map { return String(format: "%02hhx", $0) }
        return hexBytes.joined()
    }
}

Ich habe versucht, zwei verschiedene Methoden mit Format "%02.2hhx"und zu testen"%02x"

    var i :Int = 0
    var j: Int = 0
    let e: Int = Int(1e4)
    let time = NSDate.timeIntervalSinceReferenceDate
    while i < e {
        _ =  deviceToken.map { String(format: "%02x", $0) }.joined()
        i += 1
    }
    let time2 = NSDate.timeIntervalSinceReferenceDate
    let delta = time2-time
    print(delta)

    let time3 = NSDate.timeIntervalSinceReferenceDate
    while j < e {
        _ =  deviceToken.reduce("", {$0 + String(format: "%02x", $1)})
        j += 1
    }
    let time4 = NSDate.timeIntervalSinceReferenceDate
    let delta2 = time4-time3
    print(delta2)

und das Ergebnis ist, dass der schnellste "%02x"im Durchschnitt 2,0 gegenüber 2,6 für die reduzierte Version ist:

deviceToken.reduce("", {$0 + String(format: "%02x", $1)})

Die Verwendung von updateAccumulatingResult ist effizienter als die verschiedenen anderen hier beschriebenen Ansätze. Hier ist die schnellste Möglichkeit, Ihre DataBytes zu stringifizieren :

func application(_ application: UIApplication,
                 didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
    let token = deviceToken.reduce(into: "") { $0 += String(format: "%.2x", $1) }
    print(token)
}

Für Swift:

var characterSet: NSCharacterSet = NSCharacterSet( charactersInString: "<>" )
    var deviceTokenString: String = ( deviceToken.description as NSString )
    .stringByTrimmingCharactersInSet( characterSet )
    .stringByReplacingOccurrencesOfString( " ", withString: "" ) as String

println( deviceTokenString )

Was ist mit einer einzeiligen Lösung?

Ziel c

NSString *token = [[data.description componentsSeparatedByCharactersInSet:[[NSCharacterSet alphanumericCharacterSet]invertedSet]]componentsJoinedByString:@""];

Schnell

let token = data.description.componentsSeparatedByCharactersInSet(NSCharacterSet.alphanumericCharacterSet().invertedSet).joinWithSeparator("")

So geht's in Xamarin.iOS

public override void RegisteredForRemoteNotifications(UIApplication application, NSData deviceToken)
{
    var tokenStringBase64 = deviceToken.GetBase64EncodedString(NSDataBase64EncodingOptions.None);
    //now you can store it for later use in local storage
}

NSString *tokenString = [[newDeviceToken description] stringByReplacingOccurrencesOfString:@"[<> ]" withString:@"" options:NSRegularExpressionSearch range:NSMakeRange(0, [[newDeviceToken description] length])];

Schnell:

let tokenString = deviceToken.description.stringByReplacingOccurrencesOfString("[ <>]", withString: "", options: .RegularExpressionSearch, range: nil)

-(NSString *)deviceTokenWithData:(NSData *)data
{
    NSString *deviceToken = [[data description] stringByTrimmingCharactersInSet:[NSCharacterSet characterSetWithCharactersInString:@"<>"]];
    deviceToken = [deviceToken stringByReplacingOccurrencesOfString:@" " withString:@""];
    return deviceToken;
}

Schnell

    // make sure that we have token for the devie on the App
    func application(application: UIApplication
        , didRegisterForRemoteNotificationsWithDeviceToken deviceToken: NSData) {

            var tokenStr = deviceToken.description
            tokenStr = tokenStr.stringByReplacingOccurrencesOfString("<", withString: "", options: [], range: nil)
            tokenStr = tokenStr.stringByReplacingOccurrencesOfString(">", withString: "", options: [], range: nil)
            tokenStr = tokenStr.stringByReplacingOccurrencesOfString(" ", withString: "", options: [], range: nil)



            print("my token is: \(tokenStr)")

    }

Verwenden Sie ausgezeichnete Kategorie!

// .h Datei

@interface NSData (DeviceToken)

- (NSString *)stringDeviceToken;

@end    

// .m Datei

#import "NSData+DeviceToken.h"

@implementation NSData (DeviceToken)

- (NSString *)stringDeviceToken {
    const unsigned *deviceTokenBytes = [deviceToken bytes];
    NSString *deviceToken = [NSString stringWithFormat:@"%08x%08x%08x%08x%08x%08x%08x%08x",
                     ntohl(deviceTokenBytes[0]), ntohl(deviceTokenBytes[1]), ntohl(deviceTokenBytes[2]),
                     ntohl(deviceTokenBytes[3]), ntohl(deviceTokenBytes[4]), ntohl(deviceTokenBytes[5]),
                     ntohl(deviceTokenBytes[6]), ntohl(deviceTokenBytes[7])];
    return deviceToken;
}

@Ende

// AppDelegate.m

#import "NSData+DeviceToken.h"

- (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken
{
    NSString *token = deviceToken.stringDeviceToken;
}

Funktioniert gut!

Swift 3:

Wenn jemand nach einer Möglichkeit sucht, Geräte-Token in Swift 3 zu erhalten, verwenden Sie das unten modifizierte Snippet.

    let characterSet: CharacterSet = CharacterSet( charactersIn: "<>" )

    let deviceTokenString: String = (deviceToken.description as NSString)
        .trimmingCharacters(in: characterSet as CharacterSet)
        .replacingOccurrences(of: " ", with: "")
        .uppercased()

    print(deviceTokenString)

var token: String = ""
for i in 0..<deviceToken.count {
    token += String(format: "%02.2hhx", deviceToken[i] as CVarArg)
}

print(token)

Die hier veröffentlichte Lösung @kulss funktioniert zwar nicht elegant, hat aber die Einfachheit, funktioniert in iOS 13 nicht mehr, da descriptionsie für NSData anders funktioniert. Sie können jedoch weiterhin verwenden debugDescription.

NSString * deviceTokenString = [[[[deviceToken debugDescription]
                     stringByReplacingOccurrencesOfString: @"<" withString: @""] 
                    stringByReplacingOccurrencesOfString: @">" withString: @""] 
                   stringByReplacingOccurrencesOfString: @" " withString: @""];

Versuchen Sie dies, es sei denn, die Daten sind nullterminiert.

NSString* newStr = [[NSString alloc] initWithData:newDeviceToken encoding:NSUTF8StringEncoding];

NSString *tokenstring = [[NSString alloc] initWithData:token encoding:NSUTF8StringEncoding];