Pushmeldingen toevoegen aan uw Xamarin.Forms-app

Artikel
2019-06-25

Overzicht

In deze zelfstudie voegt u pushmeldingen toe aan alle projecten die het resultaat zijn van de snelstartgids Xamarin.Forms. Dit betekent dat een pushmelding wordt verzonden naar alle platformoverschrijdende clients telkens wanneer een record wordt ingevoegd.

Als u het gedownloade snelstartserverproject niet gebruikt, hebt u het pakket met pushmeldingen nodig. Zie Werken met de SDK voor de .NET-back-endserver voor Azure Mobile Appsvoor meer informatie.

Vereiste voorwaarden

Voor iOS hebt u een Apple Developer Program-lidmaatschap en een fysiek iOS-apparaat nodig. De iOS-simulator biedt geen ondersteuning voor pushmeldingen.

Een Notification Hub configureren

De functie Mobile Apps van Azure App Service maakt gebruik van Azure Notification Hubs om pushes te verzenden, zodat u een Notification Hub configureert voor uw mobiele app.

Ga in de Azure Portalnaar App Services-en selecteer vervolgens de back-end van uw app. Selecteer onder Instellingende optie Push.
Om een meldingshubbron aan de app toe te voegen, selecteert u Verbinding maken. U kunt een hub maken of verbinding maken met een bestaande hub.

U hebt nu een Notification Hub verbonden met uw back-endproject voor Mobiele apps. Later configureert u deze Notification Hub om verbinding te maken met een platformmeldingssysteem (PNS) om naar apparaten te pushen.

Het serverproject bijwerken om pushmeldingen te verzenden

In deze sectie werkt u code bij in uw bestaande back-endproject voor mobiele apps om telkens wanneer een nieuw item wordt toegevoegd, een pushmelding te verzenden. Dit proces wordt mogelijk gemaakt door de sjabloon functie van Azure Notification Hubs, waardoor platformoverschrijdende pushes mogelijk zijn. De verschillende clients worden geregistreerd voor pushmeldingen met behulp van sjablonen en één universele push kan naar alle clientplatforms worden verzonden.

Kies een van de volgende procedures die overeenkomen met het type back-endproject: .NET-back-end of Node.js back-end.

.NET back-end project

Klik in Visual Studio met de rechtermuisknop op het serverproject. Selecteer vervolgens NuGet-pakketten beheren. Zoek naar Microsoft.Azure.NotificationHubs, en selecteer vervolgens Installeren. Met dit proces wordt de Notification Hubs-bibliotheek geïnstalleerd voor het verzenden van meldingen vanaf de back-end.
In het serverproject, open Controllers>TodoItemController.cs. Voeg vervolgens het volgende toe met behulp van instructies:
```
using System.Collections.Generic;
using Microsoft.Azure.NotificationHubs;
using Microsoft.Azure.Mobile.Server.Config;
```

Voeg in de methode PostTodoItem de volgende code toe na de aanroep naar InsertAsync-:

// Get the settings for the server project.
HttpConfiguration config = this.Configuration;
MobileAppSettingsDictionary settings =
    this.Configuration.GetMobileAppSettingsProvider().GetMobileAppSettings();

// Get the Notification Hubs credentials for the mobile app.
string notificationHubName = settings.NotificationHubName;
string notificationHubConnection = settings
    .Connections[MobileAppSettingsKeys.NotificationHubConnectionString].ConnectionString;

// Create a new Notification Hub client.
NotificationHubClient hub = NotificationHubClient
.CreateClientFromConnectionString(notificationHubConnection, notificationHubName);

// Send the message so that all template registrations that contain "messageParam"
// receive the notifications. This includes APNS, GCM, WNS, and MPNS template registrations.
Dictionary<string,string> templateParams = new Dictionary<string,string>();
templateParams["messageParam"] = item.Text + " was added to the list.";

try
{
    // Send the push notification and log the results.
    var result = await hub.SendTemplateNotificationAsync(templateParams);

    // Write the success result to the logs.
    config.Services.GetTraceWriter().Info(result.State.ToString());
}
catch (System.Exception ex)
{
    // Write the failure result to the logs.
    config.Services.GetTraceWriter()
        .Error(ex.Message, null, "Push.SendAsync Error");
}

Met dit proces wordt een sjabloonmelding met het item verzonden. Tekst wanneer een nieuw item wordt ingevoegd.

Publiceer het serverproject opnieuw.

Node.js back-end project

Stel uw back-endproject in.

Vervang de bestaande code in todoitem.js door de volgende code:

var azureMobileApps = require('azure-mobile-apps'),
promises = require('azure-mobile-apps/src/utilities/promises'),
logger = require('azure-mobile-apps/src/logger');

var table = azureMobileApps.table();

table.insert(function (context) {
// For more information about the Notification Hubs JavaScript SDK,
// see https://aka.ms/nodejshubs.
logger.info('Running TodoItem.insert');

// Define the template payload.
var payload = '{"messageParam": "' + context.item.text + '" }';  

// Execute the insert. The insert returns the results as a promise.
// Do the push as a post-execute action within the promise flow.
return context.execute()
    .then(function (results) {
        // Only do the push if configured.
        if (context.push) {
            // Send a template notification.
            context.push.send(null, payload, function (error) {
                if (error) {
                    logger.error('Error while sending push notification: ', error);
                } else {
                    logger.info('Push notification sent successfully!');
                }
            });
        }
        // Don't forget to return the results from the context.execute().
        return results;
    })
    .catch(function (error) {
        logger.error('Error while running context.execute: ', error);
    });
});

module.exports = table;

Met dit proces wordt een sjabloonmelding met de item.text verzonden wanneer een nieuw item wordt ingevoegd.

Wanneer u het bestand op uw lokale computer bewerkt, publiceert u het serverproject opnieuw.

Het Android-project configureren en uitvoeren (optioneel)

Voltooi deze sectie om pushmeldingen in te schakelen voor het Xamarin.Forms Droid-project voor Android.

Firebase Cloud Messaging (FCM) inschakelen

Meld u aan bij de Firebase-console. Maak een nieuw Firebase-project als u er nog geen hebt.
Nadat u uw project hebt gemaakt, selecteert u Firebase toevoegen aan uw Android-app.
Voer de volgende stappen uit op de pagina Firebase toevoegen aan uw Android-app:
1. Voor Android-pakketnaam kopieert u de waarde van uw applicationId in het bestand build.gradle van uw toepassing. In dit voorbeeld is het com.fabrikam.fcmtutorial1app.
2. Selecteer App registreren.
Selecteer google-services.json downloaden, sla het bestand op in de map app van uw project, en selecteer Volgende.
Breng de volgende configuratiewijzigingen aan in uw project in Android Studio.
1. Voeg in het bestand build.gradle op projectniveau (<project>/build.gradle) de volgende instructie toe aan de sectie dependencies (afhankelijkheden).
```
classpath 'com.google.gms:google-services:4.0.1'
```
2. Voeg in het build.gradle-bestand op app-niveau (<project>/<app-module>/build.gradle) de volgende instructies toe aan de sectie afhankelijkheden .
```
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'
```
3. Voeg de volgende regel toe aan het einde van het build.gradle-bestand op app-niveau na de sectie met afhankelijkheden.
```
apply plugin: 'com.google.gms.google-services'
```
4. Selecteer Nu synchroniseren op de werkbalk.
Kies Volgende.
Selecteer Deze stap overslaan.
Selecteer in de Firebase-console het tandwiel van uw project. Selecteer vervolgens Projectinstellingen.
Als u het bestand google-services.json niet hebt gedownload in de map app van uw Android Studio-project, kunt u dat op deze pagina doen.
Ga naar Cloud Messaging bovenaan op het tabblad.
Kopieer de Serversleutel en sla deze op voor later gebruik. U gebruikt deze waarde om uw hub te configureren.

De back-end van Mobile Apps configureren voor het verzenden van pushaanvragen met FCM

Selecteer in de Azure portal, Alles weergeven>App Services. Selecteer vervolgens de back-end van uw Mobile Apps.
Selecteer onder Instellingende optie Push. Selecteer Vervolgens Push Notification Services configureren.
Ga naar Google (GCM). Voer de verouderde FCM-serversleutel in die u hebt verkregen via de Firebase-console en selecteer Opslaan.

Uw service is nu geconfigureerd voor gebruik met Firebase Cloud Messaging.

Pushmeldingen toevoegen aan het Android-project

Als de back-end is geconfigureerd met FCM, kunt u onderdelen en codes toevoegen aan de client om u te registreren bij FCM. U kunt zich ook registreren voor pushmeldingen met Azure Notification Hubs via de back-end van Mobile Apps en meldingen ontvangen.

Klik in het Droid-project met de rechtermuisknop op Verwijzingen > beheren NuGet-pakketten ....
Zoek in het venster NuGet Package Manager naar het Xamarin.Firebase.Messaging-pakket en voeg het toe aan het project.
Stel in de projecteigenschappen voor het Droid-project de app in om te compileren met Android-versie 7.0 of hoger.
Voeg het google-services.json-bestand toe, gedownload van de Firebase-console, aan de hoofdmap van het Droid-project en stel de build-actie in op GoogleServicesJson. Zie Het JSON-bestand van Google Services toevoegen voor meer informatie.

Registreren bij Firebase Cloud Messaging

Open het bestandAndroidManifest.xml en voeg de volgende <receiver> elementen in het <application> element in:

<receiver android:name="com.google.firebase.iid.FirebaseInstanceIdInternalReceiver" android:exported="false" />
<receiver android:name="com.google.firebase.iid.FirebaseInstanceIdReceiver" android:exported="true" android:permission="com.google.android.c2dm.permission.SEND">
    <intent-filter>
    <action android:name="com.google.android.c2dm.intent.RECEIVE" />
    <action android:name="com.google.android.c2dm.intent.REGISTRATION" />
    <category android:name="${applicationId}" />
    </intent-filter>
</receiver>

De Firebase Instance ID-service implementeren

Voeg een nieuwe klasse toe aan het Droid-project met de naam FirebaseRegistrationServiceen zorg ervoor dat de volgende using instructies boven aan het bestand aanwezig zijn:
```
using System.Threading.Tasks;
using Android.App;
using Android.Util;
using Firebase.Iid;
using Microsoft.WindowsAzure.MobileServices;
```
Vervang de lege FirebaseRegistrationService klasse door de volgende code:
```
[Service]
[IntentFilter(new[] { "com.google.firebase.INSTANCE_ID_EVENT" })]
public class FirebaseRegistrationService : FirebaseInstanceIdService
{
    const string TAG = "FirebaseRegistrationService";

    public override void OnTokenRefresh()
    {
        var refreshedToken = FirebaseInstanceId.Instance.Token;
        Log.Debug(TAG, "Refreshed token: " + refreshedToken);
        SendRegistrationTokenToAzureNotificationHub(refreshedToken);
    }

    void SendRegistrationTokenToAzureNotificationHub(string token)
    {
        // Update notification hub registration
        Task.Run(async () =>
        {
            await AzureNotificationHubService.RegisterAsync(TodoItemManager.DefaultManager.CurrentClient.GetPush(), token);
        });
    }
}
```
De FirebaseRegistrationService klasse is verantwoordelijk voor het genereren van beveiligingstokens waarmee de toepassing toegang krijgt tot FCM. De OnTokenRefresh methode wordt aangeroepen wanneer de toepassing een registratietoken van FCM ontvangt. De methode haalt het token op uit de FirebaseInstanceId.Instance.Token eigenschap, die asynchroon wordt bijgewerkt door FCM. De OnTokenRefresh-methode wordt niet vaak aangeroepen, omdat het token alleen wordt bijgewerkt wanneer de toepassing wordt geïnstalleerd of verwijderd, wanneer de gebruiker toepassingsgegevens verwijdert, wanneer de toepassing de Instance-ID wist of wanneer de beveiliging van het token is gecompromitteerd. Bovendien vraagt de FCM Instance ID-service om periodiek het token van de toepassing te vernieuwen, meestal om de 6 maanden.

De OnTokenRefresh methode roept ook de SendRegistrationTokenToAzureNotificationHub methode aan, die wordt gebruikt om het registratietoken van de gebruiker te koppelen aan de Azure Notification Hub.

Registreren bij Azure Notification Hub

Voeg een nieuwe klasse toe aan het Droid-project met de naam AzureNotificationHubServiceen zorg ervoor dat de volgende using instructies boven aan het bestand aanwezig zijn:
```
using System;
using System.Threading.Tasks;
using Android.Util;
using Microsoft.WindowsAzure.MobileServices;
using Newtonsoft.Json.Linq;
```

Vervang de lege AzureNotificationHubService klasse door de volgende code:

public class AzureNotificationHubService
{
    const string TAG = "AzureNotificationHubService";

    public static async Task RegisterAsync(Push push, string token)
    {
        try
        {
            const string templateBody = "{\"data\":{\"message\":\"$(messageParam)\"}}";
            JObject templates = new JObject();
            templates["genericMessage"] = new JObject
            {
                {"body", templateBody}
            };

            await push.RegisterAsync(token, templates);
            Log.Info("Push Installation Id: ", push.InstallationId.ToString());
        }
        catch (Exception ex)
        {
            Log.Error(TAG, "Could not register with Notification Hub: " + ex.Message);
        }
    }
}

Met RegisterAsync de methode maakt u een eenvoudige sjabloon voor meldingsberichten als JSON en registreert u zich voor het ontvangen van sjabloonmeldingen van de Notification Hub met behulp van het Firebase-registratietoken. Dit zorgt ervoor dat alle meldingen die vanuit de Azure Notification Hub worden verzonden, het apparaat targeten dat wordt vertegenwoordigd door het registratietoken.

De inhoud van een pushmelding weergeven

Voeg een nieuwe klasse toe aan het Droid-project met de naam FirebaseNotificationServiceen zorg ervoor dat de volgende using instructies boven aan het bestand aanwezig zijn:
```
using Android.App;
using Android.Content;
using Android.Media;
using Android.Support.V7.App;
using Android.Util;
using Firebase.Messaging;
```

Vervang de lege FirebaseNotificationService klasse door de volgende code:

[Service]
[IntentFilter(new[] { "com.google.firebase.MESSAGING_EVENT" })]
public class FirebaseNotificationService : FirebaseMessagingService
{
    const string TAG = "FirebaseNotificationService";

    public override void OnMessageReceived(RemoteMessage message)
    {
        Log.Debug(TAG, "From: " + message.From);

        // Pull message body out of the template
        var messageBody = message.Data["message"];
        if (string.IsNullOrWhiteSpace(messageBody))
            return;

        Log.Debug(TAG, "Notification message body: " + messageBody);
        SendNotification(messageBody);
    }

    void SendNotification(string messageBody)
    {
        var intent = new Intent(this, typeof(MainActivity));
        intent.AddFlags(ActivityFlags.ClearTop);
        //Unique request code to avoid PendingIntent collision.
        var requestCode = new Random().Next();
        var pendingIntent = PendingIntent.GetActivity(this, requestCode, intent, PendingIntentFlags.OneShot);
        var notificationBuilder = new NotificationCompat.Builder(this)
            .SetSmallIcon(Resource.Drawable.ic_stat_ic_notification)
            .SetContentTitle("New Todo Item")
            .SetContentText(messageBody)
            .SetContentIntent(pendingIntent)
            .SetSound(RingtoneManager.GetDefaultUri(RingtoneType.Notification))
            .SetAutoCancel(true);

        var notificationManager = NotificationManager.FromContext(this);
        notificationManager.Notify(0, notificationBuilder.Build());
    }
}

De OnMessageReceived methode, die wordt aangeroepen wanneer een toepassing een melding ontvangt van FCM, extraheert de inhoud van het bericht en roept de methode aan SendNotification . Met deze methode wordt de berichtinhoud geconverteerd naar een lokale melding die wordt gestart terwijl de toepassing wordt uitgevoerd, waarbij de melding wordt weergegeven in het systeemvak.

Nu bent u klaar om pushmeldingen te testen in de app die wordt uitgevoerd op een Android-apparaat of de emulator.

Pushmeldingen testen in uw Android-app

De eerste twee stappen zijn alleen vereist wanneer u test op een emulator.

Zorg ervoor dat u implementeert of foutopsporing uitvoert op een apparaat of emulator die is geconfigureerd met Google Play Services. Dit kan worden gecontroleerd door te controleren of de Play-apps zijn geïnstalleerd op het apparaat of de emulator.
Voeg een Google-account toe aan het Android-apparaat door opApps-instellingen>>account toevoegen te klikken. Volg vervolgens de aanwijzingen om een bestaand Google-account toe te voegen aan het apparaat of om een nieuw account te maken.
Klik in Visual Studio of Xamarin Studio met de rechtermuisknop op het Droid-project en klik op Instellen als opstartproject.
Klik op Uitvoeren om het project te bouwen en de app te starten op uw Android-apparaat of emulator.
Typ een taak in de app en klik vervolgens op het plusteken (+).
Controleer of er een melding wordt ontvangen wanneer een item wordt toegevoegd.

Het iOS-project configureren en uitvoeren (optioneel)

Deze sectie is bedoeld voor het uitvoeren van het Xamarin iOS-project voor iOS-apparaten. U kunt deze sectie overslaan als u niet met iOS-apparaten werkt.

Het bestand met de aanvraag voor certificaatondertekening genereren

De Apple Push Notification Service (APNs) gebruikt certificaten om uw pushmeldingen te verifiëren. Volg deze instructies om het pushcertificaat te maken dat vereist is om meldingen te verzenden en te ontvangen. Zie de officiële documentatie van de Apple Push Notification Service voor meer informatie over deze concepten.

Genereer het CSR-bestand (Certificate Signing Request), dat Apple gebruikt om een ondertekend pushcertificaat te genereren.

Voer op uw Mac het hulpprogramma Sleutelhangertoegang uit. Dit kan worden gestart vanuit de map Hulpprogramma's of de map Overige in Launchpad.
Selecteer Toegang tot sleutelhanger, vouw Certificaatassistent uit en selecteer vervolgens Een certificaat bij een certificaatautoriteit aanvragen.

Opmerking

Sleutelhangertoegang selecteert standaard het eerste item in de lijst. Dit kan een probleem zijn als u zich in de categorie Certificaten bevindt en Apple Worldwide Developer Relations Certification Authority niet het eerste item in de lijst is. Zorg ervoor dat u een item hebt dat geen sleutel is of dat de sleutel Apple Worldwide Developer Relations Certification Authority is geselecteerd, voordat u de CSR (Certificate Signing Request) genereert.
Selecteer uw E-mailadres van de gebruiker, voer uw waarde voor Algemene naam in, zorg ervoor dat u Opgeslagen op schijf hebt opgegeven en selecteer Doorgaan. Laat E-mailadres van CA leeg omdat dit niet vereist is.
Voer een naam in voor het CSR-bestand in Opslaan als, selecteer de locatie in Waar en selecteer vervolgens Opslaan.

Met deze actie wordt het CSR-bestand opgeslagen op de geselecteerde locatie. De standaardlocatie is Desktop. Onthoud de locatie die u voor het bestand hebt gekozen.

Vervolgens gaat u uw app registreren bij Apple, pushmeldingen inschakelen en het geëxporteerde bestand met de aanvraag voor certificaatondertekening uploaden om een pushcertificaat te maken.

Uw app voor pushmeldingen registreren

Registreer uw app bij Apple en registreer u voor pushmeldingen om pushmeldingen te verzenden naar een iOS-app.

Als u uw app nog niet hebt geregistreerd, bladert u naar de iOS Provisioning Portal in het Apple Developer Center. Meld u aan bij het portaal met uw Apple ID en selecteer ID's. Selecteer vervolgens + om een nieuwe app te registreren.
Selecteer op het scherm Een nieuwe identifier registreren de keuzeradioknop App-ID's. Selecteer vervolgens Doorgaan.
Werk de volgende drie waarden voor uw nieuwe app bij en selecteer vervolgens Doorgaan:
- Beschrijving: Typ een beschrijvende naam voor uw app.
- Bundel-id: Voer een bundel-id in van de formulier organisatie-id.Productnaam zoals vermeld in de app-distributiehandleiding. De waarden voor Organization Identifier en Product Name moeten overeenkomen met de organisatie-id en productnaam die u gebruikt wanneer u een Xcode-project gaat maken. In de volgende schermopname wordt de waarde voor NotificationHubs als de organisatie-id gebruikt en de waarde voor GetStarted als de productnaam. Zorg ervoor dat de waarde voor Bundel-id overeenkomt met de waarde in uw Xcode-project, zodat Xcode het juiste publicatieprofiel gebruikt.
- Pushmeldingen: controleer de optie Pushmeldingen in de sectie Mogelijkheden .
  
  Met deze actie wordt uw app-id gegenereerd en wordt u gevraagd om de gegevens te bevestigen. Selecteer Doorgaan en selecteer vervolgens Registreren om de nieuwe app-id te bevestigen.
  
  Nadat u Registreren hebt geselecteerd, ziet u de nieuwe app-id als regelitem op de pagina Certificaten, Id's en profielen .
Ga op de pagina Certificaten, id's en profielen onder Id's naar het regelitem App-id dat u zojuist hebt gemaakt, en selecteer de bijbehorende rij om het scherm De configuratie van uw app-id bewerken weer te geven.

Een certificaat voor Notification Hubs maken

Er is een certificaat vereist om de Notification Hub te kunnen laten werken met APNs. U kunt dit op twee manieren doen:

Maak een .p12 die rechtstreeks naar Notification Hub kan worden geüpload.
Maak een .p8 die kan worden gebruikt voor verificatie op basis van tokens (de nieuwere benadering).

De nieuwere benadering heeft een aantal voordelen (vergeleken met het gebruik van certificaten) zoals beschreven in HTTP/2-verificatie (op tokens gebaseerde) voor APNS. Er zijn echter stappen gegeven voor beide benaderingen.

OPTIE 1: Een .p12-pushcertificaat maken dat rechtstreeks naar Notification Hub kan worden geüpload

Scrol omlaag naar de ingeschakelde optie Pushmeldingen en selecteer vervolgens Configureren om het certificaat te maken.
Het venster Apple Push Notification service SSL-certificaten wordt weergegeven. Selecteer de knop Certificaat maken in de sectie SSL-certificaat voor ontwikkeling .

Het scherm Een nieuw certificaat maken wordt weergegeven.

Opmerking

In deze zelfstudie wordt een ontwikkelingscertificaat gebruikt. Hetzelfde proces wordt gebruikt bij het registreren van een productiecertificaat. Zorg ervoor dat u hetzelfde certificaattype gebruikt bij het verzenden van meldingen.
Selecteer Bestand kiezen, blader naar de locatie waar u het CSR-bestand hebt opgeslagen uit de eerste taak en dubbelklik vervolgens op de certificaatnaam om het te laden. Selecteer vervolgens Doorgaan.
Nadat de portal het certificaat heeft gemaakt, selecteert u de knop Downloaden. Sla het certificaat op en onthoud de locatie waar het wordt opgeslagen.

Het certificaat wordt gedownload en opgeslagen op uw computer in de map Downloads .

Opmerking

Standaard krijgt het gedownloade ontwikkelingscertificaat de naam aps_development.cer.
Dubbelklik op het gedownloade pushcertificaat aps_development.cer. Met deze actie wordt het nieuwe certificaat in de sleutelhanger geïnstalleerd, zoals wordt weergegeven in de volgende afbeelding:

Opmerking

Hoewel de naam in uw certificaat mogelijk anders is, wordt de naam voorafgegaan door Apple Development iOS Push Services.
In Sleutelhangertoegang klikt u met de rechtermuisknop op het nieuwe pushcertificaat dat u hebt gemaakt in de categorie Certificaten. Selecteer Exporteren, geef het bestand een naam, selecteer de indeling .p12 en klik vervolgens op Opslaan.

U kunt ervoor kiezen om het certificaat met een wachtwoord te beveiligen, maar dit is optioneel. Klik op OK als u het maken van wachtwoorden wilt overslaan. Noteer de bestandsnaam en locatie van het geëxporteerde .p12-certificaat. Ze worden gebruikt om verificatie met APNs in te schakelen.

Opmerking

Uw .p12-bestandsnaam en-locatie kunnen afwijken van wat er in deze zelfstudie wordt afgebeeld.

OPTIE 2: Een .p8-certificaat maken dat kan worden gebruikt voor verificatie op basis van tokens

Noteer de volgende details:
- App-id-voorvoegsel (dit is een Team-id)
- Bundel-ID
Als u teruggaat naar Certificaten, id's en profielen, klikt u op Sleutels.

Opmerking

Als u al een sleutel voor APNS hebt geconfigureerd, kunt u het .p8-certificaat dat u hebt gedownload opnieuw gebruiken nadat het is gemaakt. Als dat zo is, kunt u stappen 3 tot en met 5 negeren.
Klik op de knop + (of de knop Een sleutel maken) om een nieuwe sleutel te maken.
Geef een geschikte sleutelnaamwaarde op, schakel vervolgens de optie APNs (Apple Push Notifications Service) in en klik vervolgens op Doorgaan, gevolgd door Registreren op het volgende scherm.
Klik op Downloaden en verplaats het .p8-bestand (voorafgegaan door AuthKey_) naar een beveiligde lokale map en klik vervolgens op Gereed.

Opmerking

Zorg ervoor dat uw .p8-bestand op een veilige plaats is opgeslagen (en sla een back-up op). Nadat u de sleutel hebt gedownload, kan deze niet opnieuw worden gedownload omdat de serverkopie wordt verwijderd.
Klik in Sleutels op de sleutel die u zojuist hebt gemaakt (of een bestaande sleutel als u ervoor hebt gekozen om deze te gebruiken).
Noteer de waarde van Sleutel-id.
Open uw .p8-certificaat in een geschikte toepassing van uw keuze, zoals Visual Studio Code , en noteer de sleutelwaarde. Dit is de waarde tussen -----BEGIN PRIVATE KEY----- en -----END PRIVATE KEY-----.
```
-----BEGIN PRIVATE KEY-----
<key_value>
-----END PRIVATE KEY-----
```
Opmerking

Dit is de tokenwaarde die later wordt gebruikt om Notification Hub te configureren.

Aan het einde van deze stappen moet u de volgende informatie hebben voor later gebruik in Uw Notification Hub configureren met APNs-informatie:

Team-id (zie stap 1)
Bundel-id (zie stap 1)
Sleutel-id (zie stap 7)
Tokenwaarde , d.w.w.v. de sleutelwaarde .p8 (zie stap 8)

Een inrichtingsprofiel voor de app maken

Ga terug naar de iOS Provisioning Portal, selecteer Certificaten, id's en profielen, selecteer Profielen in het linkermenu en selecteer vervolgens + om een nieuw profiel te maken. Het scherm Een nieuw inrichtingsprofiel registreren wordt weergegeven.
Selecteer Ontwikkeling iOS-app onder Ontwikkeling als het inrichtingsprofieltype en selecteer vervolgens Doorgaan.
Selecteer vervolgens de app-id die u hebt gemaakt in de vervolgkeuzelijst App-id en selecteer Doorgaan.
Selecteer in het venster Certificaten selecteren het ontwikkelingscertificaat dat u gebruikt voor het ondertekenen bij programmacode en selecteer Doorgaan. Dit certificaat is niet het pushcertificaat dat u hebt gemaakt. Als er nog geen bestaat, moet u er een maken. Als er wel een certificaat bestaat, gaat u verder met de volgende stap. Een ontwikkelingscertificaat maken als er geen bestaat:
1. Als u Geen certificaten beschikbaar ziet, selecteert u Certificaat maken.
2. In de sectie Software selecteert u Apple Development. Selecteer vervolgens Doorgaan.
3. In het scherm Een nieuw certificaat maken selecteert u Bestand kiezen.
4. Blader naar het certificaat Aanvraag certificaatondertekening dat u eerder hebt gemaakt, selecteer het en selecteer Openen.
5. Klik op Doorgaan.
6. Download het ontwikkelingscertificaat en onthoud de locatie waarop het is opgeslagen.
Ga terug naar de pagina Certificaten, id's en profielen, selecteer Profielen in het linkermenu en selecteer vervolgens + om een nieuw profiel te maken. Het scherm Een nieuw inrichtingsprofiel registreren wordt weergegeven.
Selecteer in het venster Certificaten selecteren het ontwikkelingscertificaat dat u zojuist hebt gemaakt. Selecteer vervolgens Doorgaan.
Selecteer vervolgens de apparaten die u voor de tests wilt gebruiken en selecteer Doorgaan.
Kies ten slotte een naam voor het profiel in De naam van het inrichtingsprofiel en selecteer Genereren.
Wanneer het nieuwe inrichtingsprofiel is gemaakt, selecteert u Downloaden. Onthoud de locatie waarop deze is opgeslagen.
Blader naar de locatie van het inrichtingsprofiel en dubbelklik erop om het te installeren op uw Xcode-ontwikkelingscomputer.

Een Notification Hub maken

In deze sectie maakt u een Notification Hub en configureert u verificatie met APNs met behulp van het .p12-pushcertificaat of verificatie op basis van tokens. Als u een Notification Hub wilt gebruiken die u al hebt gemaakt, kunt u doorgaan naar stap 5.

Meld u aan bij het Azure-portaal.
Selecteer Alle services in het menu aan de linkerkant en selecteer Notification Hubs in de sectie Mobiel. Selecteer het sterpictogram naast de servicenaam om de service toe te voegen aan de sectie FAVORIETEN in het menu aan de linkerkant. Nadat u Notification Hubs aan FAVORIETEN hebt toegevoegd, selecteert u deze in het linkermenu.
Op de Notification Hubs-pagina selecteert u Toevoegen op de werkbalk.
Voer op de pagina Notification Hub de volgende stappen uit:
1. Voer een naam in Notification Hub in.
2. Voer een naam in Een nieuwe naamruimte maken in. Een naamruimte bevat een of meer hubs.
3. Selecteer een waarde in de vervolgkeuzelijst Locatie. Deze waarde specificeert de locatie waar u de hub wilt maken.
4. Selecteer een bestaande resourcegroep in de resourcegroep of maak een naam voor een nieuwe resourcegroep.
5. Klik op Creëren.
Selecteer Meldingen (het belpictogram) en selecteer vervolgens Ga naar resource. U kunt ook de lijst op de pagina Notification Hubs vernieuwen en uw hub selecteren.
Selecteer Toegangsbeleid in de lijst. U ziet dat de twee verbindingsreeksen voor u beschikbaar zijn. Later moet u er pushmeldingen mee afhandelen.

Belangrijk

Gebruik hetdefaultFullSharedAccessSignature-beleid niet in uw toepassing. Deze mag alleen in uw back-end systeem worden gebruikt.

Uw Notification Hub configureren met APNs-informatie

Selecteer onder Notification Servicesde optie Apple (APNS) en volg vervolgens de juiste stappen op basis van de methode die u eerder hebt gekozen in de sectie Een certificaat voor Notification Hubs maken .

Opmerking

Gebruik de productiemodus alleen als u pushmeldingen wilt verzenden naar gebruikers die uw app in de Store hebben gekocht.

OPTIE 1: Een .p12-pushcertificaat gebruiken

Selecteer Certificaat.
Selecteer het bestandspictogram.
Selecteer het .p12-bestand dat u eerder hebt geëxporteerd en selecteer vervolgens Openen.
Geef indien nodig het juiste wachtwoord op.
Selecteer de modus Sandbox.
Selecteer Opslaan.

OPTIE 2: Verificatie op basis van tokens gebruiken

Selecteer Token.
Voer de volgende waarden in die u eerder hebt verkregen:
- sleutel-id
- Bundel-ID
- Team-id
- Token
Kies Sandbox.
Selecteer Opslaan.

U hebt nu uw Notification Hub geconfigureerd met APNs. U hebt ook de verbindingsreeksen om uw app te registreren en pushmeldingen te verzenden.

De Notification Hub configureren voor APNS

Open op uw Mac Sleutelhangertoegang. Open in de linkernavigatiebalk, onder Categorie, Mijn certificaten. Zoek het SSL-certificaat dat u in de vorige sectie hebt gedownload en geef de inhoud ervan weer. Selecteer alleen het certificaat (selecteer niet de persoonlijke sleutel). Vervolgens hetexporteren.
Selecteer in de Azure portal, Alles weergeven>App Services. Selecteer vervolgens de back-end van uw Mobile Apps.
Selecteer onder Instellingen, App Service Push. Selecteer vervolgens de naam van de Notification Hub.
Ga naar Apple Push Notification Services>Certificaat uploaden. Upload het .p12-bestand en selecteer de juiste modus (afhankelijk van of uw ssl-clientcertificaat van eerder productie of sandbox is). Sla eventuele wijzigingen op.

Uw service is nu geconfigureerd voor gebruik met pushmeldingen op iOS.

Vervolgens configureert u de iOS-projectinstelling in Xamarin Studio of Visual Studio.

Het iOS-project configureren in Xamarin Studio

Open in Xamarin.Studio Info.plisten werk de bundel-id bij met de bundel-id die u eerder hebt gemaakt met uw nieuwe app-id.
Schuif omlaag naar achtergrondmodi. Selecteer het vak Achtergrondmodi inschakelen en het vak Externe meldingen.
Dubbelklik op uw project in het deelvenster Oplossing om projectopties te openen.
Kies onder Buildde optie iOS Bundle Signingen selecteer de bijbehorende identiteit en voorzieningsprofiel die u zojuist hebt ingesteld voor dit project.

Dit zorgt ervoor dat het project gebruikmaakt van het nieuwe profiel voor het ondertekenen van programmacode. Zie Xamarin Device Provisioningvoor de officiële documentatie voor het inrichten van Xamarin-apparaten.

Het iOS-project configureren in Visual Studio

Klik in Visual Studio met de rechtermuisknop op het project en klik vervolgens op Eigenschappen.
Klik op de eigenschappenpagina's op het tabblad iOS-toepassing en werk de Identificatie bij met de ID die u eerder hebt aangemaakt.
Selecteer in het tabblad iOS-bundelsignering de bijbehorende identiteit en het provisioning-profiel dat u zojuist voor dit project hebt ingesteld.

Dit zorgt ervoor dat het project gebruikmaakt van het nieuwe profiel voor het ondertekenen van programmacode. Zie Xamarin Device Provisioningvoor de officiële documentatie voor het inrichten van Xamarin-apparaten.
Dubbelklik op Info.plist om deze te openen en schakel RemoteNotifications in onder achtergrondmodi.

Pushmeldingen toevoegen aan uw iOS-app

Open in het iOS-project AppDelegate.cs en voeg de volgende instructie toe aan het begin van het codebestand.
```
using Newtonsoft.Json.Linq;
```

Voeg in de AppDelegate-klasse een overschrijving toe voor de gebeurtenis RegisteredForRemoteNotifications om meldingen te registreren:

public override void RegisteredForRemoteNotifications(UIApplication application,
    NSData deviceToken)
{
    const string templateBodyAPNS = "{\"aps\":{\"alert\":\"$(messageParam)\"}}";

    JObject templates = new JObject();
    templates["genericMessage"] = new JObject
        {
            {"body", templateBodyAPNS}
        };

    // Register for push with your mobile app
    Push push = TodoItemManager.DefaultManager.CurrentClient.GetPush();
    push.RegisterAsync(deviceToken, templates);
}

Voeg in AppDelegate ook de volgende overschrijving toe voor de DidReceiveRemoteNotification gebeurtenis-handler:

public override void DidReceiveRemoteNotification(UIApplication application,
    NSDictionary userInfo, Action<UIBackgroundFetchResult> completionHandler)
{
    NSDictionary aps = userInfo.ObjectForKey(new NSString("aps")) as NSDictionary;

    string alert = string.Empty;
    if (aps.ContainsKey(new NSString("alert")))
        alert = (aps[new NSString("alert")] as NSString).ToString();

    //show alert
    if (!string.IsNullOrEmpty(alert))
    {
        UIAlertView avAlert = new UIAlertView("Notification", alert, null, "OK", null);
        avAlert.Show();
    }
}

Met deze methode worden binnenkomende meldingen verwerkt terwijl de app wordt uitgevoerd.

Voeg in de Klasse AppDelegate de volgende code toe aan de methode FinishedLaunching :

// Register for push notifications.
var settings = UIUserNotificationSettings.GetSettingsForTypes(
    UIUserNotificationType.Alert
    | UIUserNotificationType.Badge
    | UIUserNotificationType.Sound,
    new NSSet());

UIApplication.SharedApplication.RegisterUserNotificationSettings(settings);
UIApplication.SharedApplication.RegisterForRemoteNotifications();

Dit maakt ondersteuning mogelijk voor externe meldingen en aanvragen voor pushregistratie.

Uw app is nu bijgewerkt ter ondersteuning van pushmeldingen.

Pushmeldingen testen in uw iOS-app

Klik met de rechtermuisknop op het iOS-project en klik op Instellen als opstartproject.
Druk op de knop Uitvoeren of F5 in Visual Studio om het project te bouwen en de app op een iOS-apparaat te starten. Klik vervolgens op OK om pushmeldingen te accepteren.

Opmerking

U moet expliciet pushmeldingen van uw app accepteren. Deze aanvraag vindt alleen plaats wanneer de app voor het eerst wordt uitgevoerd.
Typ een taak in de app en klik vervolgens op het plusteken (+).
Controleer of er een melding is ontvangen en klik vervolgens op OK om de melding te sluiten.

Windows-projecten configureren en uitvoeren (optioneel)

Deze sectie is bedoeld voor het uitvoeren van de Xamarin.Forms WinApp- en WinPhone81-projecten voor Windows-apparaten. Deze stappen ondersteunen ook UWP-projecten (Universal Windows Platform). U kunt deze sectie overslaan als u niet met Windows-apparaten werkt.

Uw Windows-app registreren voor pushmeldingen met Windows Notification Service (WNS)

Klik in Visual Studio Solution Explorer met de rechtermuisknop op het Windows Store-app-project. Selecteer vervolgens Store>App koppelen aan de Store.
In de wizard selecteer je Volgende. Meld u vervolgens aan met uw Microsoft-account. Typ in Een nieuwe app-naam reserveren de naam van uw app en selecteer Reserveren.
Nadat de app-registratie is gemaakt, selecteert u de nieuwe app-naam. Selecteer Volgende en selecteer vervolgens Koppelen. Met dit proces worden de vereiste windows Store-registratiegegevens toegevoegd aan het toepassingsmanifest.
Herhaal stap 1 en 3 voor het Windows Phone Store-app-project met behulp van dezelfde registratie die u eerder hebt gemaakt voor de Windows Store-app.
Ga naar het Windows-ontwikkelaarscentrum en meld u aan met uw Microsoft-account. Selecteer in Mijn apps de nieuwe app-registratie. Vouw vervolgens Services>Pushmeldingen uit.
Selecteer op de pagina Pushmeldingen onder Windows Push Notification Services (WNS) en Microsoft Azure Mobile Apps de optie Live Services-site. Noteer de waarden van de pakket-SID en de huidige waarde in Het toepassingsgeheim.

Belangrijk

Het toepassingsgeheim en de pakket-SID zijn belangrijke beveiligingsreferenties. Deel deze waarden niet met iemand of distribueer deze met uw app.

De Notification Hub configureren voor WNS

Selecteer in de Azure portal, Alles weergeven>App Services. Selecteer vervolgens de back-end van uw Mobile Apps. Selecteer onder Instellingen, App Service Push. Selecteer vervolgens de naam van de Notification Hub.
Ga naar Windows (WNS). Voer vervolgens de Beveiligingssleutel (clientgeheim) in en Pakket-SID die u hebt verkregen van de Live Services-site. Selecteer vervolgens Opslaan.

Uw back-end is nu geconfigureerd voor het gebruik van WNS om pushmeldingen te verzenden.

Pushmeldingen toevoegen aan uw Windows-app

Open in Visual Studio App.xaml.cs in een Windows-project en voeg de volgende instructies toe.
```
using Newtonsoft.Json.Linq;
using Microsoft.WindowsAzure.MobileServices;
using System.Threading.Tasks;
using Windows.Networking.PushNotifications;
using <your_TodoItemManager_portable_class_namespace>;
```
Vervang <your_TodoItemManager_portable_class_namespace> door de naamruimte van uw draagbare project dat de TodoItemManager klasse bevat.

Voeg in App.xaml.cs de volgende InitNotificationsAsync-methode toe:

private async Task InitNotificationsAsync()
{
    var channel = await PushNotificationChannelManager
        .CreatePushNotificationChannelForApplicationAsync();

    const string templateBodyWNS =
        "<toast><visual><binding template=\"ToastText01\"><text id=\"1\">$(messageParam)</text></binding></visual></toast>";

    JObject headers = new JObject();
    headers["X-WNS-Type"] = "wns/toast";

    JObject templates = new JObject();
    templates["genericMessage"] = new JObject
    {
        {"body", templateBodyWNS},
        {"headers", headers} // Needed for WNS.
    };

    await TodoItemManager.DefaultManager.CurrentClient.GetPush()
        .RegisterAsync(channel.Uri, templates);
}

Met deze methode wordt het pushmeldingskanaal opgehaald en wordt een sjabloon geregistreerd voor het ontvangen van sjabloonmeldingen van uw Notification Hub. Een sjabloonmelding die messageParam ondersteunt, wordt aan deze client geleverd.

Werk in App.xaml.cs de definitie van de event handler OnLaunched bij door de async modifier toe te voegen. Voeg vervolgens de volgende coderegel toe aan het einde van de methode:
```
await InitNotificationsAsync();
```
Dit zorgt ervoor dat de registratie van pushmeldingen telkens wanneer de app wordt gestart, wordt gemaakt of vernieuwd. Het is belangrijk om dit te doen om ervoor te zorgen dat het WNS-pushkanaal altijd actief is.
Open in Solution Explorer voor Visual Studio het bestand Package.appxmanifest en stel Toast Capable in op Ja onder Meldingen.
Bouw de app en controleer of er geen fouten zijn. Uw client-app moet zich nu registreren voor de sjabloonmeldingen van de back-end van Mobile Apps. Herhaal deze sectie voor elk Windows-project in uw oplossing.

Pushmeldingen testen in uw Windows-app

Klik in Visual Studio met de rechtermuisknop op een Windows-project en klik op Instellen als opstartproject.
Druk op de knop Uitvoeren om het project te bouwen en de app te starten.
Typ in de app een naam voor een nieuw todoitem en klik vervolgens op het pluspictogram (+) om deze toe te voegen.
Controleer of er een melding wordt ontvangen wanneer het item wordt toegevoegd.

Volgende stappen

Meer informatie over pushmeldingen vindt u:

Pushmeldingen verzenden vanuit Azure Mobile Apps
Firebase Cloud Messaging
Externe meldingen met Firebase Cloud Messaging
Problemen met pushmeldingen vaststellen
Er zijn verschillende redenen waarom meldingen mogelijk worden verwijderd of niet terechtkomen op apparaten. In dit onderwerp wordt uitgelegd hoe u pushmeldingen kunt analyseren en de hoofdoorzaak ervan kunt achterhalen.

U kunt ook doorgaan met een van de volgende zelfstudies:

Verificatie toevoegen aan uw app
Meer informatie over het verifiëren van gebruikers van uw app met een id-provider.
Offlinesynchronisatie inschakelen voor uw app
Meer informatie over het toevoegen van offlineondersteuning voor uw app met behulp van een back-end van Mobile Apps. Met offlinesynchronisatie kunnen gebruikers communiceren met een mobiele app( gegevens weergeven, toevoegen of wijzigen), zelfs als er geen netwerkverbinding is.

Delen via