iOS
Mitteilungen

Syntax

• UIUserNotificationSettings.types: UIUserNotificationType // Eine Bitmaske der Benachrichtigungstypen, die Ihre App verwenden darf
• UIUserNotificationSettings.categories: Set // Die registrierten Aktionsgruppen der App

Parameter

Gerät für Push-Benachrichtigungen registrieren

Fügen Sie Ihrer AppDelegate-Datei in der didFinishLaunchingWithOptions Methode den folgenden Code hinzu, um Ihr Gerät für Push-Benachrichtigungen zu registrieren:

Schnell

func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
    // Override point for customization after application launch.
    if UIDevice.currentDevice().systemVersion.compare(v, options: .NumericSearch) == NSOrderedAscending { 
        // Register for Push Notitications, if running iOS < 8
        if application.respondsToSelector("registerUserNotificationSettings:") {
            let types:UIUserNotificationType = (.Alert | .Badge | .Sound)
            let settings:UIUserNotificationSettings = UIUserNotificationSettings(forTypes: types, categories: nil)

            application.registerUserNotificationSettings(settings)
            application.registerForRemoteNotifications()
        } else {      
            // Register for Push Notifications before iOS 8
            application.registerForRemoteNotificationTypes(.Alert | .Badge | .Sound)
        }
    } else {
        var center = UNUserNotificationCenter.currentNotificationCenter()
        center.delegate = self
        center.requestAuthorizationWithOptions((UNAuthorizationOptionSound | UNAuthorizationOptionAlert | UNAuthorizationOptionBadge)) {(granted: Bool, error: NSError) -> Void in
            if !error {
                UIApplication.sharedApplication().registerForRemoteNotifications()
                // required to get the app to do anything at all about push notifications
                print("Push registration success.")
            } else {
                print("Push registration FAILED")
                print("ERROR: \(error.localizedFailureReason!) - \(error.localizedDescription)")
                print("SUGGESTIONS: \(error.localizedRecoveryOptions) - \(error.localizedRecoverySuggestion!)")
            })
    }

    return true
}

Ziel c

#define SYSTEM_VERSION_LESS_THAN(v) ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] == NSOrderedAscending)

if( SYSTEM_VERSION_LESS_THAN( @"10.0" ) )
{
        if ([application respondsToSelector:@selector(isRegisteredForRemoteNotifications)])
    {
        // iOS 8 Notifications
        [application registerUserNotificationSettings:[UIUserNotificationSettings settingsForTypes:(UIUserNotificationTypeSound | UIUserNotificationTypeAlert | UIUserNotificationTypeBadge) categories:nil]];
        
        [application registerForRemoteNotifications];
    }
    else
    {
        // iOS < 8 Notifications
        [application registerForRemoteNotificationTypes:
         (UIRemoteNotificationTypeBadge | UIRemoteNotificationTypeAlert | UIRemoteNotificationTypeSound)];
    }

}
else
{
    UNUserNotificationCenter *center = [UNUserNotificationCenter currentNotificationCenter];
    center.delegate = self;
    [center requestAuthorizationWithOptions:(UNAuthorizationOptionSound | UNAuthorizationOptionAlert | UNAuthorizationOptionBadge) completionHandler:^(BOOL granted, NSError * _Nullable error)
     {
         if( !error )
         {
             [[UIApplication sharedApplication] registerForRemoteNotifications];  // required to get the app to do anything at all about push notifications
             NSLog( @"Push registration success." );
         }
         else
         {
             NSLog( @"Push registration FAILED" );
             NSLog( @"ERROR: %@ - %@", error.localizedFailureReason, error.localizedDescription );
             NSLog( @"SUGGESTIONS: %@ - %@", error.localizedRecoveryOptions, error.localizedRecoverySuggestion );  
         }  
     }];  
}


//to check if your App lunch from Push notification 
//---------------------------------------------------
    //Handel Push notification
    if (launchOptions != nil)
    {
        // Here app will open from pushnotification
        //RemoteNotification
        NSDictionary* dictionary1 = [launchOptions objectForKey:UIApplicationLaunchOptionsRemoteNotificationKey];
        //LocalNotification
        NSDictionary* dictionary2 = [launchOptions objectForKey:UIApplicationLaunchOptionsLocalNotificationKey];
        if (dictionary1 != nil)
        {
            //RemoteNotification Payload
            NSLog(@"Launched from push notification: %@", dictionary1);
            //here handle your push notification
        }
        if (dictionary2 != nil)
        {
            NSLog(@"Launched from dictionary2dictionary2dictionary2 notification: %@", dictionary2);
            double delayInSeconds = 7;
            dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC));
            dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
                // [self addMessageFromRemoteNotification:dictionary2 updateUI:NO];
            });
        }
        
     }
     else
         {}
    //------------------------------------------------

Der obige Code versucht, mit dem APNs-Server zu kommunizieren, um ein Gerätetoken zu erhalten (Voraussetzung, dass in Ihrem iOS-Bereitstellungsprofil APNs aktiviert sind).

Sobald eine zuverlässige Verbindung zum APNs-Server hergestellt ist, stellt der Server ein Gerätetoken zur Verfügung.

Nachdem Sie den obigen Code hinzugefügt haben, fügen Sie der AppDelegate Klasse diese Methoden AppDelegate :

Schnell

func application(application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: NSData) {
    print("DEVICE TOKEN = \(deviceToken)")
}

func application(application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: NSError) {
    print(error)
}

Ziel c

- (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken
{    
NSString * deviceTokenString = [[[[deviceToken description]
                     stringByReplacingOccurrencesOfString: @"<" withString: @""] 
                    stringByReplacingOccurrencesOfString: @">" withString: @""] 
                   stringByReplacingOccurrencesOfString: @" " withString: @""];

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

- (void)application:(UIApplication*)application didFailToRegisterForRemoteNotificationsWithError:(NSError*)error
{
    NSLog(@"Failed to get token, error: %@", error.description);
}

Die obigen Methoden werden entsprechend dem Registrierungserfolgs- oder -ausfallszenario aufgerufen.

Erfolgsszenario fordert:

Schnell

func application(application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: NSData) {
    print("DEVICE TOKEN = \(deviceToken)")
}

In Swift3:

@objc(userNotificationCenter:willPresentNotification:withCompletionHandler:) @available(iOS 10.0, *)
func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void)
{
    //To show notifications in foreground.
   print("Userinfo2 \(notification.request.content.userInfo)")
}

Ziel c

- (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken
{
if(application.applicationState == UIApplicationStateInactive) { 
    NSLog(@"Inactive - the user has tapped in the notification when app was closed or in background");
    //do some tasks
    [self handelPushNotification:userInfo];
}
else if (application.applicationState == UIApplicationStateBackground) {
    NSLog(@"application Background - notification has arrived when app was in background");
    [self handelPushNotification:userInfo];
}
else {
    NSLog(@"application Active - notication has arrived while app was opened");
    //Show an in-app banner
    //do tasks
}
}

Fehlerszenario-Aufrufe:

Schnell

func application(application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: NSError) {
    print(error)
}

Ziel c

- (void)application:(UIApplication*)application didFailToRegisterForRemoteNotificationsWithError:(NSError*)error

Hinweis

Wenn keine der oben genannten Methoden aufgerufen wird, kann Ihr Gerät keine zuverlässige Verbindung mit dem APNs-Server herstellen, was möglicherweise auf Probleme beim Internetzugang zurückzuführen ist.

Überprüfen Sie, ob Ihre App bereits für die Push-Benachrichtigung registriert ist

Schnell

let isPushEnabled = UIApplication.sharedApplication().isRegisteredForRemoteNotifications()

Registrieren für die (nicht interaktive) Push-Benachrichtigung

Es wird empfohlen, die Logik der Registrierung für Push-Benachrichtigungen in AppDelegate.swift da die Callback-Funktionen (Erfolg, Fehler) als ihre bezeichnet werden. Um sich anzumelden, gehen Sie wie folgt vor:

let application = UIApplication.sharedApplication()
let settings = UIUserNotificationSettings(forTypes: [.Alert, .Badge, .Sound], categories: nil)
application.registerUserNotificationSettings(settings)

Dann wird die Callback-Funktion didRegisterUserNotificationSettings aufgerufen. In diesem Fall lösen Sie das Register einfach folgendermaßen aus:

func application(application: UIApplication, didRegisterUserNotificationSettings notificationSettings: UIUserNotificationSettings) {
    application.registerForRemoteNotifications()
}

In diesem Fall wird ein Systemalarm angezeigt, in dem Sie aufgefordert werden, eine Push-Benachrichtigung zu erhalten. Eine der folgenden Rückruffunktionen wird aufgerufen:

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("Push token: \(tokenString)")
}

func application(application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: NSError) {
    print("didFailToRegisterForRemoteNotificationsWithError: \(error)")
            
}

In sehr seltenen Fällen werden weder Erfolgs- noch Fehlerrückruffunktionen aufgerufen. Dies ist der Fall, wenn Sie Probleme mit der Internetverbindung haben oder die APNS-Sandbox inaktiv ist. Das System führt einen API-Aufruf an APNS aus, um einige Überprüfungen durchzuführen. Andernfalls wird keine der beiden Callbacks-Funktionen aufgerufen. Besuchen Sie den Apple-Systemstatus , um sicherzustellen, dass alles in Ordnung ist.

Umgang mit Push-Benachrichtigung

Sobald der Benutzer eine Push-Benachrichtigung anklickt, wird die folgende Rückruffunktion aufgerufen. Sie können die JSON-Analyse analysieren, um bestimmte Informationen vom Backend zu erhalten, die Ihnen beim Deep Linking helfen:

Schnell

func application(application: UIApplication, didReceiveRemoteNotification userInfo: [NSObject : AnyObject]) {
    print("Received notification: \(userInfo)")
}

Ziel c

- (void)application:(UIApplication *)application didReceiveRemoteNotification: (NSDictionary *)userInfo
{
    NSLog(@"Received notification: %@", userInfo);
}

iOS 10

#define SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO(v)  ([[[UIDevice currentDevice] systemVersion] compare:v options:NSNumericSearch] != NSOrderedAscending)

-(void) application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void                              (^)(UIBackgroundFetchResult))completionHandler
{
    // iOS 10 will handle notifications through other methods
    NSLog(@"Received notification: %@", userInfo);


    if( SYSTEM_VERSION_GREATER_THAN_OR_EQUAL_TO( @"10.0" ) )
    {
        NSLog( @"iOS version >= 10. Let NotificationCenter handle this one." );
        // set a member variable to tell the new delegate that this is background
        return;
    }
    NSLog( @"HANDLE PUSH, didReceiveRemoteNotification: %@", userInfo );

    // custom code to handle notification content

    if( [UIApplication sharedApplication].applicationState == UIApplicationStateInactive )
   {
       NSLog( @"INACTIVE" );
       completionHandler( UIBackgroundFetchResultNewData );
   }
   else if( [UIApplication sharedApplication].applicationState == UIApplicationStateBackground )
   {  
       NSLog( @"BACKGROUND" );  
       completionHandler( UIBackgroundFetchResultNewData );  
   }  
   else  
   {  
       NSLog( @"FOREGROUND" );  
       completionHandler( UIBackgroundFetchResultNewData );  
   }  
}

- (void)userNotificationCenter:(UNUserNotificationCenter *)center
   willPresentNotification:(UNNotification *)notification
     withCompletionHandler:(void (^)(UNNotificationPresentationOptions options))completionHandler
{
    NSLog( @"Handle push from foreground" );
   // custom code to handle push while app is in the foreground
    NSLog(@"%@", notification.request.content.userInfo);
}

- (void)userNotificationCenter:(UNUserNotificationCenter *)center didReceiveNotificationResponse:(UNNotificationResponse *)response
     withCompletionHandler:(void (^)())completionHandler
{

    NSLog( @"Handle push from background or closed" );
    // if you set a member variable in didReceiveRemoteNotification, you  will know if this is from closed or background
    NSLog(@"%@", response.notification.request.content.userInfo);
}

Registrieren der App-ID für die Verwendung mit Push-Benachrichtigungen

Dinge, die du brauchst

• Eine bezahlte Apple Developer Program-Mitgliedschaft
• Eine gültige App-ID und ein gültiger Bezeichner für Ihre App (z. B. com.example.MyApp), der zuvor nicht verwendet wurde
• Zugriff auf developer.apple.com und Member Center
• Ein iOS-Gerät zum Testen (da Push-Benachrichtigungen auf dem Simulator nicht funktionieren)

Aktivieren des APNs-Zugriffs für die App-ID im Apple Developer Center

1- Melden Sie sich im Mitgliedercenter von developer.apple.com an (der Konto-Link auf der Startseite).

2- Gehe zu "Zertifikate"

3- Wählen Sie "App ID" im linken Bereich aus

4- Klicken Sie oben rechts auf "+"

5- App-ID mit Push-Benachrichtigungen hinzufügen aktiviert

6- Klicken Sie auf die erstellte App-ID und wählen Sie Bearbeiten

7- Klicken Sie im Bereich Push-Benachrichtigungen auf Konfigurieren

8- Öffnen Sie die App "Keychain Access" in Ihrem Mac

9- Klicken Sie im Menü Schlüsselzugriff auf Zertifikatassistent -> Zertifikat von einer Zertifizierungsstelle anfordern

10- Geben Sie Ihre Mail in das erste Textfeld ein

11- Geben Sie Ihren Namen in das zweite Textfeld ein

12- Lassen Sie die CA-E-Mail-Adresse leer

13- Wählen Sie Gespeichert auf Datenträger statt E-Mail an die Zertifizierungsstelle

14- Klicken Sie auf Weiter und laden Sie die generierte Datei hoch

15- Laden Sie die generierte Datei von Apple herunter und öffnen Sie sie, während Keychain Access geöffnet ist

Aktivieren des APNs-Zugriffs in Xcode

1- Wählen Sie Ihr Projekt aus

2- Öffnen Sie die Registerkarte Funktionen

3- Push-Benachrichtigungen suchen und einschalten

4-Finden Sie die Hintergrundmodi, schalten Sie sie ein und überprüfen Sie die Remote-Benachrichtigungen

Registrierung von Push-Benachrichtigungen aufheben

Um die Registrierung von Remote-Benachrichtigungen programmatisch aufzuheben, können Sie verwenden

Ziel c

[[UIApplication sharedApplication] unregisterForRemoteNotifications];

Schnell

UIApplication.sharedApplication().unregisterForRemoteNotifications()

Dies ist vergleichbar mit der Einstellung Ihres Telefons und dem manuellen Deaktivieren von Benachrichtigungen für die Anwendung.

HINWEIS: In seltenen Fällen benötigen Sie dies (z. B. wenn Ihre App Push-Benachrichtigungen nicht mehr unterstützt).

Wenn Sie dem Benutzer nur erlauben möchten, Benachrichtigungen vorübergehend zu deaktivieren. Sie sollten eine Methode implementieren, um das Gerätetoken in der Datenbank Ihres Servers zu entfernen. Wenn Sie die Benachrichtigung nur lokal auf Ihrem Gerät deaktivieren, sendet der Server weiterhin Nachrichten.

Einstellen der Anwendungssymbol-Ausweisnummer

Verwenden Sie den folgenden Code, um die someNumber in Ihrer Anwendung someNumber (vorausgesetzt, dass zuvor someNumber deklariert wurde):

Ziel c

[UIApplication sharedApplication].applicationIconBadgeNumber = someNumber;

Schnell

UIApplication.shared.applicationIconBadgeNumber = someNumber

Um das Abzeichen vollständig zu entfernen , setzen someNumber = 0 einfach someNumber = 0 .

Testen von Push-Benachrichtigungen

Es empfiehlt sich immer, die Funktionsweise von Push-Benachrichtigungen zu testen, noch bevor Sie die Serverseite für sie vorbereitet haben. Nur um sicherzustellen, dass alles auf Ihrer Seite richtig eingerichtet ist. Es ist ziemlich einfach, sich selbst eine Push-Benachrichtigung mit dem folgenden PHP-Skript zu senden.

1. Speichern Sie das Skript als Datei (zum Beispiel send_push.php) im selben Ordner wie Ihr Zertifikat (Entwicklung oder Produktion).
2. Bearbeiten Sie es, um das Gerätetoken und das Kennwort aus dem Zertifikat zu speichern
3. Wählen Sie den korrekten Pfad zum Öffnen einer Verbindung, dev_path oder prod_path (hier erfolgt die Verbindung zum APNS-Server im Skript.)
4. cd in den Ordner im Terminal und den Befehl 'php send_push' ausführen
5. Erhalten Sie die Benachrichtigung auf Ihrem Gerät

<?php

// Put your device token here (without spaces):   
$deviceToken = '20128697f872d7d39e48c4a61f50cb11d77789b39e6fc6b4cd7ec80582ed5229';
// Put your final pem cert name here. it is supposed to be in the same folder as this script
$cert_name = 'final_cert.pem';
// Put your private key's passphrase here:
$passphrase = '1234';

// sample point
$alert = 'Hello world!';
$event = 'new_incoming_message';
    
// You can choose either of the paths, depending on what kind of certificate you are using
$dev_path = 'ssl://gateway.sandbox.push.apple.com:2195';
$prod_path = 'ssl://gateway.push.apple.com:2195';
    
////////////////////////////////////////////////////////////////////////////////

$ctx = stream_context_create();
stream_context_set_option($ctx, 'ssl', 'local_cert', $cert_name);
stream_context_set_option($ctx, 'ssl', 'passphrase', $passphrase);

// Open a connection to the APNS server
$fp = stream_socket_client(
    $dev_path, $err,
    $errstr, 60, STREAM_CLIENT_CONNECT|STREAM_CLIENT_PERSISTENT, $ctx);

if (!$fp)
    exit("Failed to connect: $err $errstr" . PHP_EOL);

echo 'Connected to APNS' . PHP_EOL;

// Create the payload body
// it should be as short as possible
// if the notification doesnt get delivered that is most likely
// because the generated message is too long
$body['aps'] = array(
                     'alert' => $alert,
                     'sound' => 'default',
                     'event' => $event
                     );

// Encode the payload as JSON
$payload = json_encode($body);

// Build the binary notification
$msg = chr(0) . pack('n', 32) . pack('H*', $deviceToken) . pack('n', strlen($payload)) . $payload;

// Send it to the server
$result = fwrite($fp, $msg, strlen($msg));

if (!$result)
    echo 'Message not delivered' . PHP_EOL;
else
    echo 'Message successfully delivered' . PHP_EOL;

// Close the connection to the server
fclose($fp);

Generierung eines .pem-Zertifikats aus Ihrer .cer-Datei, um sie an den Server-Entwickler weiterzuleiten

1. Aps.cer in einem Ordner speichern

2. Öffnen Sie "Schlüsselbundzugriff" und exportieren Sie den Schlüssel, der sich unter diesem Zertifikat befindet, in eine P12-Datei (nennen Sie sie key.p12). Klicken Sie dazu mit der rechten Maustaste darauf und wählen Sie Exportieren. Speichern Sie es in demselben Ordner wie in Schritt 1. Beim Export werden Sie aufgefordert, ein Kennwort einzugeben. Machen Sie sich etwas aus und merken Sie es sich.

   

3. cd zu diesem Ordner in Terminal und führen Sie die folgenden Befehle aus:

4. Konvertieren Sie .cer in ein .pem-Zertifikat

openssl x509 -in aps.cer -inform der -out aps.pem    

5. Konvertieren Sie Ihren Schlüssel in das PEM-Format. Um den Schlüssel zu öffnen, geben Sie in Schritt 2 das Kennwort ein, mit dem Sie es aus dem Schlüsselbund exportiert haben. Geben Sie dann ein anderes Kennwort ein, das die exportierte Datei schützt. Sie werden zweimal zur Bestätigung aufgefordert.

openssl pkcs12 -nocerts -out key.pem -in key.p12

6. Fügen Sie die Dateien in einer endgültigen Datei zusammen

cat key.pem aps.pem > final_cert.pem

7. Das final_cert.pem ist das Endergebnis. Geben Sie es mit dem Kennwort aus Schritt 5 an Serverentwickler weiter, damit sie das geschützte Zertifikat verwenden können.