Übersicht

Bei eingehenden Ereignissen wie einer neuen Nachricht oder einem eingehenden Anruf erwartet der Nutzer oft eine Push-Benachrichtigung, wenn die App nicht aktiv ist.

Es gibt zwei Arten von Push-Benachrichtigungen, die Sie verwenden können:

• VoIP-Push (PushKit) - die bessere Lösung für Applications, die die Vonage In-App Voice-Funktionalität nutzen. (Zum Abschnitt springen)

• Regelmäßiger Schub (UserNotifications) - die bessere Lösung für Applications, die die Vonage In-App Chat-Funktionalität nutzen. (Zum Abschnitt springen)

Ein Push-Zertifikat erstellen

Der Apple Push Notifications Service (APNs) verwendet eine zertifikatsbasierte Authentifizierung, um die Verbindungen zwischen APNs und Vonage Servern zu sichern. Sie müssen also ein Zertifikat erstellen und es auf die Vonage-Server hochladen.

Hinzufügen einer Push-Benachrichtigungsfunktion

Um Push-Benachrichtigungen verwenden zu können, müssen Sie die Push-Benachrichtigungsfunktion zu Ihrem Xcode-Projekt hinzufügen. Wählen Sie dazu Ihr Ziel aus und wählen Sie Signieren & Fähigkeiten:

Wählen Sie dann Fähigkeit hinzufügen und fügen Sie die Push-Benachrichtigungen Fähigkeit:

Wenn Xcode die Signierung Ihrer Anwendung automatisch verwaltet, wird das mit Ihrem Bundle Identifier verknüpfte Bereitstellungsprofil aktualisiert, um die Fähigkeit einzuschließen.

Erzeugen eines Push-Zertifikats

Um ein Push-Zertifikat zu erstellen, müssen Sie sich in Ihrem Apple Developer Account anmelden und die Seite Zertifikate, Identifikatoren und Profile Seite und fügen Sie ein neues Zertifikat hinzu:

Wählen Sie eine Apple Push-Benachrichtigungsdienst SSL (Sandbox & Produktion) und weiter.

Sie müssen nun die App-ID für die App auswählen, der Sie Push-Benachrichtigungen hinzufügen möchten, und fortfahren. Wenn Ihre App nicht aufgeführt ist, müssen Sie eine App-ID erstellen. Xcode kann dies automatisch für Sie tun, wenn es Ihre Signierung für Sie verwaltet, andernfalls können Sie eine neue App ID auf der Seite Zertifikate, Identifikatoren und Profile Seite unter Identifikatoren. Stellen Sie dabei sicher, dass Sie die Funktion "Push-Benachrichtigungen" auswählen.

Sie werden aufgefordert, eine Certificate Signing Request (CSR) hochzuladen. Sie können die Anweisungen auf Apples Hilfe-Website um eine CSR auf Ihrem Mac zu erstellen. Sobald die CSR hochgeladen ist, können Sie das Zertifikat herunterladen. Doppelklicken Sie auf die .cer Datei, um sie in Keychain Access zu installieren.

Um das Push-Zertifikat in dem Format zu erhalten, das von den Vonage-Servern benötigt wird, müssen Sie es exportieren. Suchen Sie Ihr Apple Push Notification Service-Zertifikat in Keychain Access und exportieren Sie es mit einem Rechtsklick. Benennen Sie den Export applecert und wählen Sie .p12 als Format:

Weitere Einzelheiten zur Verbindung mit APNs finden Sie unter Die offizielle Dokumentation von Apple.

Laden Sie Ihr Zertifikat hoch

Sie laden Ihr Zertifikat auf die Vonage-Server hoch, indem Sie eine POST-Anfrage stellen. Das iOS Push Certificate Uploading Tool, verfügbar auf GitHubtut dies über ein Webinterface. Für jede der folgenden Methoden benötigen Sie Ihre Vonage Application ID. Diese erhalten Sie in der Dashboard.

Verwendung des Upload-Tools

Um das Tool zu verwenden, müssen Sie es lokal ausführen oder bereitstellen. Sie können den Anweisungen in der GitHub-Projektseite folgen README. Sie benötigen außerdem den privaten Schlüssel für Ihre Vonage Application.

Sobald das Tool läuft, geben Sie Ihre Vonage Application ID, die private Schlüsseldatei und die Zertifikatsdatei ein und klicken Sie auf Hochladen. Der Status Ihres Uploads wird auf der Seite angezeigt, sobald er abgeschlossen ist:

Verwendung des Terminals

Zusätzlich zu Ihrer Vonage Application ID benötigen Sie für den Upload über das Terminal auch eine jwt_dev. Das ist ein jwt ohne eine sub Anspruch. Weitere Einzelheiten zur Erstellung eines JWT finden Sie in der Setup-Anleitung.

Führen Sie dann den folgenden Curl-Befehl aus und ersetzen Sie dabei jwt_dev, applecert.p12, app_id mit Ihren Werten:

Integrieren Sie VoIP-Push-Benachrichtigungen in Ihre Anwendung

VoIP-Push-Benachrichtigungen sind für VoIP-Anwendungen geeignet. Neben anderen Vorteilen ermöglicht es Ihnen, Benachrichtigungen zu erhalten, auch wenn die App beendet wird. Nachdem Sie Ihr Zertifikat bei Vonage hochgeladen haben, integrieren Sie VoIP-Push in Ihre App, indem Sie die folgenden Schritte ausführen:

1. Aktivieren Sie den VoIP-Hintergrundmodus für Ihre Anwendung

Ähnlich wie beim Hinzufügen der Push-Benachrichtigungsfunktion in Xcode, unter Ihr Ziel, offen Fähigkeiten und wählen Sie Hintergrund-Modi. Sobald die Fähigkeit hinzugefügt ist, markieren Sie die Option "Voice over IP":

2. Verknüpfen Sie die CallKit Rahmenwerk

Wenn Sie VoIP-Push-Benachrichtigungen verwenden, müssen Sie das CallKit-Framework einsetzen. Verknüpfen Sie es mit Ihrem Projekt, indem Sie es unter Rahmenwerke, Bibliotheken und eingebettete Inhalte unter Allgemeines:

3. importieren. PushKitannehmen. PKPushRegistryDelegateund melden Sie sich für VoIP-Benachrichtigungen an

let voipRegistry = PKPushRegistry(queue: nil)

func registerForVoIPPushes() {
    self.voipRegistry.delegate = self
    self.voipRegistry.desiredPushTypes = [PKPushType.voIP]
}

@property PKPushRegistry* voipRegistry;

- (void) registerForVoIPPushes {
    self.voipRegistry = [[PKPushRegistry alloc] initWithQueue:nil];
    self.voipRegistry.delegate = self;
    
    // Initiate registration.
    self.voipRegistry.desiredPushTypes = [NSSet setWithObject:PKPushTypeVoIP];
}

4. Aktivieren Sie VoIP-Push-Benachrichtigungen über eine angemeldete NXMClient

NXMClient.shared.enablePushNotifications(withPushKitToken: pushKitToken, 
        userNotificationToken: nil, isSandbox: true) { (error) in
    // code
}

[NXMClient.shared enablePushNotificationsWithPushKitToken:pushKitToken 
        userNotificationToken:userNotificationToken isSandbox:YES 
        completionHandler:^(NSError * _Nullable error) {
    // code 
}];

• 'isSandbox' ist YES/true für eine App, die die Apple Sandbox-Push-Server verwendet, und NO/false für eine App, die die Apple Production-Push-Server verwendet.

• 'pushKitToken' ist der Token, der in pushRegistry(_:didUpdate:for:).

5. Implementieren Sie die folgende Delegate-Methode und fügen Sie den Code zur Behandlung einer eingehenden VoIP-Push-Benachrichtigung hinzu

func pushRegistry(_ registry: PKPushRegistry, didReceiveIncomingPushWith 
        payload: PKPushPayload, for type: PKPushType, completion: @escaping () -> Void) {
    if(NXMClient.shared.isNexmoPush(userInfo: payload.dictionaryPayload)) {
        guard let pushPayload = NXMClient.shared.processNexmoPushPayload(payload.dictionaryPayload) else {
            NSLog("Not a Nexmo push notification")
            return
        }
    }
}

- (void)pushRegistry:(PKPushRegistry *)registry didReceiveIncomingPushWithPayload:(PKPushPayload *)payload 
        forType:(PKPushType)type withCompletionHandler:(void (^)(void))completion {
    if ([NXMClient.shared isNexmoPushWithUserInfo:payload.dictionaryPayload]) {
        NXMPushPayload *pushPayload = [NXMClient.shared processNexmoPushPayload:payload.dictionaryPayload];
        if (!pushPayload){
           NSLog(@"Not a nexmo push");
           return;
        };
    }
}

Die pushPayload enthält Informationen über den eingehenden Anruf, die Sie verwenden können, um den Anruf melden mit CallKit. Sie können ein Beispiel für das JSON anzeigen, das in der Push-Nutzlast.

Damit das SDK Push-Benachrichtigungen aktivieren und die Push-Benachrichtigungen ordnungsgemäß verarbeiten kann NXMClient angemeldet sein sollte. Sie können sowohl das Push-Token als auch die Push-Nutzlast speichern und sie verarbeiten, wenn der Client erfolgreich eine Verbindung herstellt. Ein Beispiel hierfür finden Sie in der Blog-Beitrag über die Verwendung von Push-Benachrichtigungen mit CallKit und den dazugehörigen Beispielprojekt.

Integrieren Sie regelmäßige Push-Benachrichtigungen in Ihre Anwendung

Normale Push-Benachrichtigungen sind für Messaging-Apps geeignet. Um sie in Ihre App zu integrieren, gehen Sie folgendermaßen vor:

1. Aktivieren Sie Fernbenachrichtigungen für Ihre App

Ähnlich wie beim Hinzufügen der Push-Benachrichtigungsfunktion in Xcode, unter Ihr Ziel, offen Fähigkeiten und wählen Sie Hintergrund-Modi. Sobald die Funktion hinzugefügt ist, markieren Sie die Option "Fernbenachrichtigung":

2. Importieren Sie UserNotifications und registrieren Sie sich für Push-Benachrichtigungen

import UserNotifications

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
    
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Override point for customization after application launch.
        registerForPushNotificationsIfNeeded()
        return true
    }
    
    func registerForPushNotificationsIfNeeded() {
        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { [weak self] granted, _ in
            print("Permission granted: \(granted)")
            if granted {
                self?.getNotificationSettings()
            }
        }
    }
    
    func getNotificationSettings() {
        UNUserNotificationCenter.current().getNotificationSettings { settings in
            print("Notification settings: \(settings)")
            guard settings.authorizationStatus == .authorized else { return }
            DispatchQueue.main.async {
                UIApplication.shared.registerForRemoteNotifications()
            }
        }
    }
 ...
}

#import <UserNotifications/UserNotifications.h>

@implementation AppDelegate


- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    // Override point for customization after application launch.
    [self registerForPushNotificationsIfNeeded];
    return YES;
    
    
}

- (void)registerForPushNotificationsIfNeeded {
    UNAuthorizationOptions options = UNAuthorizationOptionAlert + UNAuthorizationOptionSound + UNAuthorizationOptionBadge;

    [UNUserNotificationCenter.currentNotificationCenter requestAuthorizationWithOptions:options completionHandler:^(BOOL granted, NSError * _Nullable error) {
        if (granted) {
            [self getNotificationSettings];
        }
    }];
}

- (void)getNotificationSettings {
    [UNUserNotificationCenter.currentNotificationCenter getNotificationSettingsWithCompletionHandler:^(UNNotificationSettings * _Nonnull settings) {
        if (settings.authorizationStatus == UNAuthorizationStatusAuthorized) {
            dispatch_async(dispatch_get_main_queue(), ^{
                [UIApplication.sharedApplication registerForRemoteNotifications];
            });
        }
    }];
}

...

@end

3. Aktivieren Sie Push-Benachrichtigungen durch eine angemeldete NXMClient

func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
    NXMClient.shared.enablePushNotifications(withPushKitToken: nil, userNotificationToken: deviceToken, isSandbox: true, completionHandler: nil)
}

- (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
    [NXMClient.shared enablePushNotificationsWithPushKitToken:nil userNotificationToken:deviceToken isSandbox:true completionHandler:nil];
}

4. Implementieren Sie die folgende Delegate-Methode und fügen Sie den Code für die Behandlung einer eingehenden Push-Benachrichtigung hinzu

func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable : Any], fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
    if NXMClient.shared.isNexmoPush(userInfo: userInfo) {
        if UIApplication.shared.applicationState != .active {
            // create and add notification
        } else {
            // show in app banner etc.
        }
        completionHandler(UIBackgroundFetchResult.newData)
    } else {
        completionHandler(UIBackgroundFetchResult.failed)
    }
}

- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
    if ([NXMClient.shared isNexmoPushWithUserInfo:userInfo]) {
        if (UIApplication.sharedApplication.applicationState != UIApplicationStateActive) {
            // create and add notification
        } else {
            // show in app banner etc.
        }
        completionHandler(UIBackgroundFetchResultNewData);
    } else {
        completionHandler(UIBackgroundFetchResultFailed);
    }
}

Die userInfo enthält Informationen über die eingehende Nachricht, die Sie verwenden können, um eine Meldung erstellen mit UNUserNotificationCenter. Sie können ein Beispiel für das JSON in der Datei Benutzerinfo.

TTL für Push-Benachrichtigung konfigurieren

Sie können die Time-to-Live (TTL) für Push-Benachrichtigungen konfigurieren. Dadurch wird verhindert, dass veraltete Push-Benachrichtigungen an ein Gerät gesendet werden, wenn sie nicht mehr relevant sind. Der Standardwert ist 120 Sekunden. Um die TTL einzustellen, konfigurieren Sie die NXMClient:

let config = NXMClientConfig()
// TTL value is in seconds, TTL ranges from 0 to 300.
config.pushNotificationTTL = 30
NXMClient.setConfiguration(config)

NXMClientConfig *config = [[NXMClientConfig alloc] init];
// TTL value is in seconds, TTL ranges from 0 to 300.
config.pushNotificationTTL = 30;
[NXMClient setConfiguration:config];

Schlussfolgerung

In dieser Anleitung haben Sie gesehen, wie man Push-Benachrichtigungen einrichtet. Sie finden das VoIP-Push-Beispielprojekt auf GitHub und erfahren Sie mehr über CallKit auf entwickler.apple.de. Weitere Informationen zu UserNotifications finden Sie auch unter entwickler.apple.de