Visión general

Al recibir un nuevo mensaje o una llamada, el usuario suele esperar recibir una notificación push si la aplicación no está activa.

Hay dos tipos de notificaciones push que puedes utilizar:

• VoIP push (PushKit) - la mejor opción para las aplicaciones que utilizan la funcionalidad In-App Voice de Vonage. (Saltar a la sección)

• Empuje regular (Notificaciones de usuario) - la mejor opción para las aplicaciones que utilizan la función de chat dentro de la aplicación de Vonage. (Saltar a la sección)

Crear un certificado push

El servicio Apple Push Notifications (APNs) utiliza autenticación basada en certificados para asegurar las conexiones entre APNs y los servidores de Vonage. Por lo tanto, deberás crear un certificado y cargarlo en los servidores de Vonage.

Añadir una función de notificaciones push

Para utilizar las notificaciones push es necesario añadir la función de notificaciones push al proyecto Xcode. Para ello, seleccione su objetivo y seleccione Firma y capacidades:

A continuación, seleccione añadir capacidad y añada el Notificaciones Push capacidad:

Si Xcode gestiona automáticamente la firma de su aplicación, actualizará el perfil de aprovisionamiento vinculado a su identificador de paquete para incluir la capacidad.

Generar un certificado push

Para generar un certificado push, deberá acceder a su cuenta de desarrollador de Apple y dirigirse a la sección Certificados, identificadores y perfiles y añada un nuevo certificado:

Elija una Servicio Apple Push Notification SSL (Sandbox y producción) y continuar.

Ahora tendrá que elegir el ID de la aplicación a la que desea añadir notificaciones push y continuar. Si su aplicación no aparece en la lista, tendrá que crear un App ID. Xcode puede hacer esto por usted si automáticamente si gestiona su firma para usted, de lo contrario puede crear un nuevo App ID en el Certificados, identificadores y perfiles página bajo Identificadores. Al hacerlo, asegúrate de seleccionar la función de notificaciones push.

Se le pedirá que cargue una solicitud de firma de certificado (CSR). Puede seguir las instrucciones en Sitio web de ayuda de Apple para crear una CSR en su Mac. Una vez cargado el CSR, podrá descargar el certificado. Haga doble clic en el .cer para instalarlo en Keychain Access.

Para obtener el certificado push en el formato que necesitan los servidores de Vonage, deberás exportarlo. Localiza tu certificado del servicio de notificaciones push de Apple en Acceso a llaveros y haz clic con el botón derecho para exportarlo. Asigna un nombre a la exportación applecert y seleccione .p12 como formato:

Encontrará más información sobre la conexión a APN en Documentación oficial de Apple.

Cargue su certificado

Sube tu certificado a los servidores de Vonage mediante una solicitud POST. La herramienta de carga de certificados Push de iOS, disponible en GitHublo hace con una interfaz web. Cualquiera de los siguientes métodos necesita tu ID de aplicación de Vonage. Puede obtenerse de la salpicadero.

Uso de la herramienta de carga

Para utilizar la herramienta tendrás que ejecutarla localmente o desplegarla. Puede seguir las instrucciones de la página del proyecto en GitHub LÉAME. También necesitarás la clave privada de tu aplicación de Vonage.

Una vez que hayas ejecutado la herramienta, ingresa tu ID de aplicación de Vonage, el archivo de clave privada y el archivo de certificado y haz clic en cargar. El estado de tu carga se mostrará en la página una vez que esté completa:

Uso del terminal

Además de tu ID de aplicación de Vonage para cargar usando el terminal, también necesitarás un jwt_dev. Que es un jwt sin sub reclamación. Encontrará más información sobre cómo generar un JWT en la sección guía de configuración.

A continuación, ejecute el siguiente comando Curl, sustituyendo jwt_dev, applecert.p12, app_id con sus valores:

Integre las notificaciones push de VoIP en su aplicación

Las notificaciones push VoIP son adecuadas para aplicaciones VoIP. Entre otras ventajas, te permiten recibir notificaciones incluso cuando la aplicación está terminada. Una vez que hayas cargado tu certificado en Vonage, integra VoIP push en tu aplicación siguiendo estos pasos:

1. Habilite el modo VoIP en segundo plano para su aplicación

De forma similar al proceso anterior para añadir la función de notificaciones push, en Xcode, en su objetivoabierto Capacidades y seleccione Modos de fondo. Una vez añadida la capacidad, marque la opción "Voz sobre IP":

2. Enlazar el CallKit Marco

Cuando utilices notificaciones push de VoIP, tendrás que usar el framework CallKit. Enlázalo a tu proyecto añadiéndolo en Marcos, bibliotecas y contenidos integrados en General:

3. Importar PushKitadopte PKPushRegistryDelegatey suscríbete a las notificaciones VoIP

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. Habilitar las notificaciones push de VoIP a través de un inicio de sesión 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' es YES/true para una aplicación que utilice los servidores push de sandbox de Apple y NO/false para una aplicación que utilice los servidores push de producción de Apple.

• 'pushKitToken' es la ficha recibida en pushRegistry(_:didUpdate:for:).

5. Implementa el siguiente método delegado y añade el código para gestionar una notificación push VoIP entrante

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;
        };
    }
}

En pushPayload contiene información sobre la llamada entrante que puede utilizar para informar de la llamada con CallKit. Puede ver una muestra del JSON contenido en el archivo empujar carga útil.

Para que el SDK habilite las notificaciones push y las procese correctamente NXMClient debe conectarse. Puede almacenar tanto el token push como la carga útil push y gestionarlos cuando el cliente se conecte correctamente. Para ver un ejemplo de esto, consulte la página entrada del blog sobre el uso de las notificaciones push con CallKit y su acompañamiento proyecto de muestra.

Integre notificaciones push periódicas en su aplicación

Las notificaciones push normales son adecuadas para las aplicaciones de mensajería. Para integrarlas en tu aplicación, sigue estos pasos:

1. Habilite las notificaciones remotas para su aplicación

De forma similar al proceso anterior para añadir la función de notificaciones push, en Xcode, en su objetivoabierto Capacidades y seleccione Modos de fondo. Una vez añadida la capacidad, marque la opción "Notificaciones remotas":

2. Importar UserNotifications y regístrate para recibir notificaciones push

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. Activar las notificaciones push a través de una sesión iniciada 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. Implementa el siguiente método delegado y añade el código para gestionar una notificación push entrante

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);
    }
}

En userInfo contiene información sobre el mensaje entrante que puede utilizar para crear una notificación con UNUserNotificationCenter. Puede ver una muestra del JSON contenido en el archivo información de usuario.

Configurar el TTL de las notificaciones push

Puede configurar el tiempo de vida (TTL) de las notificaciones push, lo que impedirá que se envíen notificaciones push obsoletas a un dispositivo cuando ya no sean relevantes. El valor por defecto es de 120 segundos. Para establecer el TTL, configure el parámetro 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];

Conclusión

En esta guía has visto cómo configurar las notificaciones push. Puede encontrar el proyecto de ejemplo VoIP push en GitHub y obtenga más información sobre CallKit en desarrollador.apple.com. Más información sobre UserNotifications en desarrollador.apple.com