Zelfstudie: Pushmeldingen verzenden naar specifieke gebruikers met behulp van Azure Notification HubsTutorial: Push notifications to specific users using Azure Notification Hubs

In deze zelfstudie wordt uitgelegd hoe u met Azure Notification Hubs pushmeldingen kunt verzenden naar een specifieke app-gebruiker op een specifiek apparaat.This tutorial shows you how to use Azure Notification Hubs to send push notifications to a specific app user on a specific device. Een ASP.NET WebAPI-back-end wordt gebruikt om clients te verifiëren en voor het genereren van meldingen, zoals wordt weergegeven in het onderwerp richtlijnen registreren vanuit uw back-end.An ASP.NET WebAPI backend is used to authenticate clients and to generate notifications, as shown in the guidance topic Registering from your app backend.

In deze zelfstudie voert u de volgende stappen uit:In this tutorial, you take the following steps:

  • Het WebAPI-project makenCreate the WebAPI project
  • Clients verifiëren bij de WebAPI-back-endAuthenticate clients to the WebAPI backend
  • Registreren voor meldingen met behulp van de WebAPI-back-endRegister for notifications by using the WebAPI backend
  • Meldingen verzenden vanuit de WebAPI-back-endSend notifications from the WebAPI backend
  • De nieuwe WebAPI-back-end publicerenPublish the new WebAPI backend
  • Uw iOS-app wijzigenModify your iOS app
  • De toepassing testenTest the application

VereistenPrerequisites

Deze zelfstudie wordt ervan uitgegaan dat u hebt gemaakt en uw notification hub geconfigureerd zoals beschreven in aan de slag met Notification Hubs (iOS).This tutorial assumes that you have created and configured your notification hub as described in Getting Started with Notification Hubs (iOS). In deze zelfstudie is ook de vereiste voor de (iOS) beveiligde Push zelfstudie.This tutorial is also the prerequisite to the Secure Push (iOS) tutorial. Als u gebruiken van Mobile Apps als uw back-endservice wilt, raadpleegt u de Mobile Apps aan de slag met Pushmeldingen.If you want to use Mobile Apps as your backend service, see the Mobile Apps Get Started with Push.

Het WebAPI-project makenCreate the WebAPI project

In de volgende secties wordt het maken van een nieuwe ASP.NET WebAPI-back-end besproken.The following sections discuss the creation of a new ASP.NET WebAPI backend. Dit proces heeft drie hoofddoelen:This process has three main purposes:

  • Clients verifiëren: U voegt een bericht-handler toe voor het verifiëren van client aanvragen en het koppelen van de gebruiker aan de aanvraag.Authenticate clients: You add a message handler to authenticate client requests and associate the user with the request.
  • Registreer u voor meldingen met behulp van de WebAPI-back-end: U voegt een controller toe voor het afhandelen van nieuwe registraties voor een client apparaat om meldingen te ontvangen.Register for notifications by using the WebAPI backend: You add a controller to handle new registrations for a client device to receive notifications. De naam van de geverifieerde gebruiker wordt automatisch aan de registratie toegevoegd als een tag.The authenticated username is automatically added to the registration as a tag.
  • Meldingen verzenden naar clients: U voegt een controller toe om gebruikers in staat te stellen een beveiligde push naar apparaten en clients te activeren die zijn gekoppeld aan het label.Send notifications to clients: You add a controller to provide a way for users to trigger a secure push to devices and clients associated with the tag.

Maak de nieuwe ASP.NET WebAPI-back-end door de volgende acties uit te voeren:Create the new ASP.NET WebAPI backend by doing the following actions:

Belangrijk

Als u Visual Studio 2015 of eerder gebruikt, moet u voordat u deze zelfstudie begint controleren of u de meest recente versie van NuGet Package Manager voor Visual Studio hebt geïnstalleerd.If you are using Visual Studio 2015 or earlier, before starting this tutorial, ensure that you have installed the latest version of NuGet Package Manager for Visual Studio.

Start Visual Studio om dit te controleren.To check, start Visual Studio. Selecteer Extensies en updates in het menu Extra.On the Tools menu, select Extensions and Updates. Zoek naar NuGet Package Manager in uw versie van Visual Studio en controleer of u de meest recente versie hebt.Search for NuGet Package Manager in your version of Visual Studio, and make sure you have the latest version. Als uw versie niet de nieuwste versie is, verwijdert u deze en installeert u NuGet Package Manager.If your version is not the latest version, uninstall it, and then reinstall the NuGet Package Manager.

Notitie

Controleer of u de Visual Studio Azure SDK voor website-implementatie hebt geïnstalleerd.Make sure you have installed the Visual Studio Azure SDK for website deployment.

  1. Start Visual Studio of Visual Studio Express.Start Visual Studio or Visual Studio Express.

  2. Selecteer Server Explorer en meld u aan bij uw Azure-account.Select Server Explorer, and sign in to your Azure account. U moet zijn aangemeld om de websiteresources voor uw account te maken.To create the web site resources on your account, you must be signed in.

  3. Klik in Visual Studio met de rechtermuisknop op de Visual Studio-oplossing, houd de muisaanwijzer op Toevoegen en klik op Nieuw item.In Visual Studio, right-click Visual Studio solution, point to Add, and click New Project.

  4. Vouw Visual C# uit, selecteer Web, en klik op SP.NET-webtoepassing.Expand Visual C#, select Web, and click ASP.NET Web Application.

  5. Typ AppBackend in het vak Naam en selecteer OK.In the Name box, type AppBackend, and then select OK.

    Het venster Nieuw project

  6. Selecteer in het venster Nieuw ASP.NET-project het selectievakje Web-API en selecteer vervolgens OK.In the New ASP.NET Project window, select the Web API check box, and then select OK.

    Het venster Nieuw ASP.NET-project

  7. Selecteer een abonnement in het venster Microsoft Azure Web App configureren en voer in de lijst App Service-plan een van de volgende acties uit:In the Configure Microsoft Azure Web App window, select a subscription and then, in the App Service plan list, do either of the following actions:

    • Selecteer een App Service-plan dat u al hebt gemaakt.Select an app service plan that you've already created.
    • Selecteer Een nieuw App Service-plan maken, en maak er vervolgens een.Select Create a new app service plan, and then create one.

    U hebt geen database nodig voor deze zelfstudie.You do not need a database for this tutorial. Nadat u uw App Service-plan hebt geselecteerd, selecteert u OK om het project te maken.After you have selected your app service plan, select OK to create the project.

    Het venster Microsoft Azure Web App configureren

    Als u deze pagina voor het configureren van het app service-abonnement niet ziet, gaat u verder met de zelf studie.If you don't see this page for configure app service plan, continue with the tutorial. U kunt deze configureren terwijl u de app later publiceert.You can configure it while publishing the app later.

Clients verifiëren bij de WebAPI-back-endAuthenticate clients to the WebAPI backend

In deze sectie maakt u een nieuwe berichtenhandlerklasse met de naam AuthenticationTestHandler voor de nieuwe back-end.In this section, you create a new message-handler class named AuthenticationTestHandler for the new backend. Deze klasse wordt afgeleid van DelegatingHandler en toegevoegd als een berichtenhandler zodat deze alle aanvragen die de back-end ontvangt, kan verwerken.This class is derived from DelegatingHandler and added as a message handler so that it can process all requests that come into the backend.

  1. Klik in Solution Explorer met de rechtermuisknop op het project AppBackend, selecteer Toevoegen en selecteer vervolgens Klasse.In Solution Explorer, right-click the AppBackend project, select Add, and then select Class.

  2. Geef de nieuwe klasse de naam AuthenticationTestHandler.cs en selecteer Toevoegen om de klasse te genereren.Name the new class AuthenticationTestHandler.cs, and then select Add to generate the class. Deze klasse verifieert gebruikers met behulp van Basisverificatie om het eenvoudig te houden.This class authenticates users by using Basic Authentication for simplicity. Uw app kan een willekeurig verificatieschema gebruiken.Your app can use any authentication scheme.

  3. Voeg in AuthenticationTestHandler.cs de volgende using-instructies toe:In AuthenticationTestHandler.cs, add the following using statements:

    using System.Net.Http;
    using System.Threading;
    using System.Security.Principal;
    using System.Net;
    using System.Text;
    using System.Threading.Tasks;
    
  4. Vervang in AuthenticationTestHandler.cs de AuthenticationTestHandler-klassedefinitie door de volgende code:In AuthenticationTestHandler.cs, replace the AuthenticationTestHandler class definition with the following code:

    Deze handler verifieert de aanvraag wanneer de volgende drie voorwaarden waar zijn:The handler authorizes the request when the following three conditions are true:

    • De aanvraag bevat een autorisatieheader.The request includes an Authorization header.
    • De aanvraag maakt gebruik van basisverificatie.The request uses basic authentication.
    • De gebruikersnaamtekenreeks en de wachtwoordtekenreeks zijn dezelfde tekenreeks.The user name string and the password string are the same string.

    Anders wordt de aanvraag geweigerd.Otherwise, the request is rejected. Deze verificatie is geen bestaande benadering op verificatie en autorisatie.This authentication is not a true authentication and authorization approach. Dit is slechts een eenvoudig voorbeeld voor deze zelfstudie.It is only a simple example for this tutorial.

    Als het aanvraagbericht is geverifieerd en geautoriseerd door AuthenticationTestHandler, wordt de basisverificatiegebruiker toegevoegd aan de huidige aanvraag in HttpContext.If the request message is authenticated and authorized by AuthenticationTestHandler, the basic authentication user is attached to the current request on HttpContext. Gebruikersgegevens in HttpContext worden later gebruikt door een andere controller (RegisterController) om een tag toe te voegen aan de aanvraag voor meldingen van registraties.User information in HttpContext will be used by another controller (RegisterController) later to add a tag to the notification registration request.

    public class AuthenticationTestHandler : DelegatingHandler
    {
        protected override Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
        {
            var authorizationHeader = request.Headers.GetValues("Authorization").First();
    
            if (authorizationHeader != null && authorizationHeader
                .StartsWith("Basic ", StringComparison.InvariantCultureIgnoreCase))
            {
                string authorizationUserAndPwdBase64 =
                    authorizationHeader.Substring("Basic ".Length);
                string authorizationUserAndPwd = Encoding.Default
                    .GetString(Convert.FromBase64String(authorizationUserAndPwdBase64));
                string user = authorizationUserAndPwd.Split(':')[0];
                string password = authorizationUserAndPwd.Split(':')[1];
    
                if (verifyUserAndPwd(user, password))
                {
                    // Attach the new principal object to the current HttpContext object
                    HttpContext.Current.User =
                        new GenericPrincipal(new GenericIdentity(user), new string[0]);
                    System.Threading.Thread.CurrentPrincipal =
                        System.Web.HttpContext.Current.User;
                }
                else return Unauthorized();
            }
            else return Unauthorized();
    
            return base.SendAsync(request, cancellationToken);
        }
    
        private bool verifyUserAndPwd(string user, string password)
        {
            // This is not a real authentication scheme.
            return user == password;
        }
    
        private Task<HttpResponseMessage> Unauthorized()
        {
            var response = new HttpResponseMessage(HttpStatusCode.Forbidden);
            var tsc = new TaskCompletionSource<HttpResponseMessage>();
            tsc.SetResult(response);
            return tsc.Task;
        }
    }
    

    Notitie

    Opmerking over beveiliging: De AuthenticationTestHandler klasse biedt geen echte authenticatie.Security note: The AuthenticationTestHandler class does not provide true authentication. Het wordt alleen gebruikt om basisverificatie na te bootsen en is niet beveiligd.It is used only to mimic basic authentication and is not secure. U moet een veilig verificatiemechanisme implementeren in uw productietoepassingen en -services.You must implement a secure authentication mechanism in your production applications and services.

  5. Voeg de volgende code toe aan het einde van de Register-methode in de klasse App_Start/WebApiConfig.cs om de berichtenhandler te registreren:To register the message handler, add the following code at the end of the Register method in the App_Start/WebApiConfig.cs class:

    config.MessageHandlers.Add(new AuthenticationTestHandler());
    
  6. Sla uw wijzigingen op.Save your changes.

Registreren voor meldingen met behulp van de WebAPI-back-endRegister for notifications by using the WebAPI backend

In deze sectie voegen we een nieuwe controller toe aan de WebAPI-back-end om aanvragen voor het registreren van een gebruiker en een apparaat voor meldingen af te handelen met behulp van de clientbibliotheek voor notification hubs.In this section, you add a new controller to the WebAPI backend to handle requests to register a user and a device for notifications by using the client library for notification hubs. De controller voegt een gebruikerstag toe voor de gebruiker die door AuthenticationTestHandler is geverifieerd en gekoppeld aan HttpContext.The controller adds a user tag for the user that was authenticated and attached to HttpContext by AuthenticationTestHandler. De tag heeft de indeling van de tekenreeks, "username:<actual username>".The tag has the string format, "username:<actual username>".

  1. Klik in Solution Explorer met de rechtermuisknop op het project AppBackend en selecteer vervolgens NuGet-pakketten beheren.In Solution Explorer, right-click the AppBackend project and then select Manage NuGet Packages.

  2. Selecteer in het linkerdeelvenster Online en typ Microsoft.Azure.NotificationHubs in het vak Zoeken.In the left pane, select Online and then, in the Search box, type Microsoft.Azure.NotificationHubs.

  3. Selecteer Microsoft Azure Notification Hubs in de lijst met resultaten en selecteer vervolgens Installeren.In the results list, select Microsoft Azure Notification Hubs, and then select Install. Voltooi de installatie en sluit vervolgens het venster Nuget Package Manager.Complete the installation, and then close the NuGet Package Manager window.

    Met deze actie wordt een verwijzing toegevoegd aan de Azure Notification Hubs-SDK met het Microsoft.Azure.Notification Hubs NuGet-pakket.This action adds a reference to the Azure Notification Hubs SDK by using the Microsoft.Azure.Notification Hubs NuGet package.

  4. Maak een nieuw klassebestand waarmee de verbinding met de notification hub die wordt gebruikt voor het verzenden van meldingen.Create a new class file that represents the connection with the notification hub that's used to send notifications. Klik in Solution Explorer met de rechtermuisknop op de map Modellen en selecteer achtereenvolgens Toevoegen en Klasse.In Solution Explorer, right-click the Models folder, select Add, and then select Class. Noem de nieuwe klasse Notifications.cs en selecteer vervolgens Toevoegen om de klasse te genereren.Name the new class Notifications.cs, and then select Add to generate the class.

    Het venster Nieuw Item toevoegen

  5. Voeg in Notifications.cs de volgende using-instructie toe aan het begin van het bestand:In Notifications.cs, add the following using statement at the top of the file:

    using Microsoft.Azure.NotificationHubs;
    
  6. Vervang de Notifications-klassedefinitie door de volgende code en vervang de twee tijdelijke aanduidingen door de verbindingsreeks (met volledige toegang) voor uw notification hub en de naam van de hub (beschikbaar in Azure Portal):Replace the Notifications class definition with the following code, and replace the two placeholders with the connection string (with full access) for your notification hub and the hub name (available at Azure portal):

    public class Notifications
    {
        public static Notifications Instance = new Notifications();
    
        public NotificationHubClient Hub { get; set; }
    
        private Notifications() {
            Hub = NotificationHubClient.CreateClientFromConnectionString("<your hub's DefaultFullSharedAccessSignature>",
                                                                            "<hub name>");
        }
    }
    

    Belangrijk

    Voer de naam en het DefaultFullSharedAccessSignature van uw hub in voordat u verder gaat.Enter the name and the DefaultFullSharedAccessSignature of your hub before proceeding further.

  7. Maak vervolgens een nieuwe controller met de naam RegisterController.Next, create a new controller named RegisterController. Klik in Solution Explorer met de rechtermuisknop op de map Controllers en selecteer achtereenvolgens Toevoegen en Controller.In Solution Explorer, right-click the Controllers folder, select Add, and then select Controller.

  8. Selecteer Web API 2 Controller - leeg en selecteer vervolgens Toevoegen.Select Web API 2 Controller - Empty, and then select Add.

    Het venster Scaffold toevoegen

  9. Typ in het vak Controllernaam RegisterController als naam voor de nieuwe klasse en selecteer vervolgens Toevoegen.In the Controller name box, type RegisterController to name the new class, and then select Add.

    Het venster Controller toevoegen

  10. Voeg in RegisterController.cs de volgende using-instructies toe:In RegisterController.cs, add the following using statements:

    using Microsoft.Azure.NotificationHubs;
    using Microsoft.Azure.NotificationHubs.Messaging;
    using AppBackend.Models;
    using System.Threading.Tasks;
    using System.Web;
    
  11. Voeg de volgende code in de RegisterController-klassedefinitie.Add the following code inside the RegisterController class definition. In deze code voegt u een gebruikerstag toe voor de gebruiker die is gekoppeld aan HttpContext.In this code, you add a user tag for the user that's attached to HttpContext. De gebruiker is geverifieerd en gekoppeld aan HttpContext door het berichtenfilter dat u hebt toegevoegd, AuthenticationTestHandler.The user was authenticated and attached to HttpContext by the message filter that you added, AuthenticationTestHandler. U kunt ook optionele controles toevoegen om te controleren of de gebruiker rechten heeft voor het registreren voor de aangevraagde tags.You can also add optional checks to verify that the user has rights to register for the requested tags.

    private NotificationHubClient hub;
    
    public RegisterController()
    {
        hub = Notifications.Instance.Hub;
    }
    
    public class DeviceRegistration
    {
        public string Platform { get; set; }
        public string Handle { get; set; }
        public string[] Tags { get; set; }
    }
    
    // POST api/register
    // This creates a registration id
    public async Task<string> Post(string handle = null)
    {
        string newRegistrationId = null;
    
        // make sure there are no existing registrations for this push handle (used for iOS and Android)
        if (handle != null)
        {
            var registrations = await hub.GetRegistrationsByChannelAsync(handle, 100);
    
            foreach (RegistrationDescription registration in registrations)
            {
                if (newRegistrationId == null)
                {
                    newRegistrationId = registration.RegistrationId;
                }
                else
                {
                    await hub.DeleteRegistrationAsync(registration);
                }
            }
        }
    
        if (newRegistrationId == null) 
            newRegistrationId = await hub.CreateRegistrationIdAsync();
    
        return newRegistrationId;
    }
    
    // PUT api/register/5
    // This creates or updates a registration (with provided channelURI) at the specified id
    public async Task<HttpResponseMessage> Put(string id, DeviceRegistration deviceUpdate)
    {
        RegistrationDescription registration = null;
        switch (deviceUpdate.Platform)
        {
            case "mpns":
                registration = new MpnsRegistrationDescription(deviceUpdate.Handle);
                break;
            case "wns":
                registration = new WindowsRegistrationDescription(deviceUpdate.Handle);
                break;
            case "apns":
                registration = new AppleRegistrationDescription(deviceUpdate.Handle);
                break;
            case "fcm":
                registration = new FcmRegistrationDescription(deviceUpdate.Handle);
                break;
            default:
                throw new HttpResponseException(HttpStatusCode.BadRequest);
        }
    
        registration.RegistrationId = id;
        var username = HttpContext.Current.User.Identity.Name;
    
        // add check if user is allowed to add these tags
        registration.Tags = new HashSet<string>(deviceUpdate.Tags);
        registration.Tags.Add("username:" + username);
    
        try
        {
            await hub.CreateOrUpdateRegistrationAsync(registration);
        }
        catch (MessagingException e)
        {
            ReturnGoneIfHubResponseIsGone(e);
        }
    
        return Request.CreateResponse(HttpStatusCode.OK);
    }
    
    // DELETE api/register/5
    public async Task<HttpResponseMessage> Delete(string id)
    {
        await hub.DeleteRegistrationAsync(id);
        return Request.CreateResponse(HttpStatusCode.OK);
    }
    
    private static void ReturnGoneIfHubResponseIsGone(MessagingException e)
    {
        var webex = e.InnerException as WebException;
        if (webex.Status == WebExceptionStatus.ProtocolError)
        {
            var response = (HttpWebResponse)webex.Response;
            if (response.StatusCode == HttpStatusCode.Gone)
                throw new HttpRequestException(HttpStatusCode.Gone.ToString());
        }
    }
    
  12. Sla uw wijzigingen op.Save your changes.

Meldingen verzenden vanuit de WebAPI-back-endSend notifications from the WebAPI backend

In deze sectie voegt u een nieuwe domeincontroller toe die clientapparaten een manier biedt om een melding te verzenden.In this section, you add a new controller that exposes a way for client devices to send a notification. De melding is gebaseerd op de gebruikersnaamtag die gebruikmaakt van de Azure Notification Hubs .NET-bibliotheek in de ASP.NET WebAPI-back-end.The notification is based on the username tag that uses Azure Notification Hubs .NET Library in the ASP.NET WebAPI backend.

  1. Maak nog een nieuwe controller met de naam NotificationsController op dezelfde manier als u RegisterController in de vorige sectie hebt gemaakt.Create another new controller named NotificationsController the same way you created RegisterController in the previous section.

  2. Voeg in NotificationsController.cs de volgende using-instructies toe:In NotificationsController.cs, add the following using statements:

    using AppBackend.Models;
    using System.Threading.Tasks;
    using System.Web;
    
  3. Voeg de volgende methode toe aan de klasse NotificationsController:Add the following method to the NotificationsController class:

    Met deze code wordt een meldingstype verzonden die is gebaseerd op de pns-parameter (Platform Notification Service, PNS).This code sends a notification type that's based on the Platform Notification Service (PNS) pns parameter. De waarde van to_tag wordt gebruikt om de tag gebruikersnaam in te stellen in het bericht.The value of to_tag is used to set the username tag on the message. Deze tag moet overeenkomen met een gebruikersnaamtag van een actieve notification hub-registratie.This tag must match a username tag of an active notification hub registration. Het meldingsbericht wordt opgehaald uit de hoofdtekst van de POST-aanvraag en geformatteerd voor de doel-PNS.The notification message is pulled from the body of the POST request and formatted for the target PNS.

    Afhankelijk van de PNS die uw ondersteunde apparaten gebruiken om meldingen te ontvangen, worden de meldingen met verschillende indelingen ondersteund.Depending on the PNS that your supported devices use to receive notifications, the notifications are supported by a variety of formats. Bijvoorbeeld op Windows-apparaten kunt u een pop-upmelding met WNS gebruiken die niet rechtstreeks wordt ondersteund door een andere PNS.For example, on Windows devices, you might use a toast notification with WNS that isn't directly supported by another PNS. In een dergelijk geval moet uw back-end de melding in een ondersteunde melding indelen voor de PNS van apparaten die u wilt ondersteunen.In such an instance, your backend needs to format the notification into a supported notification for the PNS of devices you plan to support. Gebruik vervolgens de juiste API voor verzending in de NotificationHubClient-klasse.Then use the appropriate send API on the NotificationHubClient class.

    public async Task<HttpResponseMessage> Post(string pns, [FromBody]string message, string to_tag)
    {
        var user = HttpContext.Current.User.Identity.Name;
        string[] userTag = new string[2];
        userTag[0] = "username:" + to_tag;
        userTag[1] = "from:" + user;
    
        Microsoft.Azure.NotificationHubs.NotificationOutcome outcome = null;
        HttpStatusCode ret = HttpStatusCode.InternalServerError;
    
        switch (pns.ToLower())
        {
            case "wns":
                // Windows 8.1 / Windows Phone 8.1
                var toast = @"<toast><visual><binding template=""ToastText01""><text id=""1"">" + 
                            "From " + user + ": " + message + "</text></binding></visual></toast>";
                outcome = await Notifications.Instance.Hub.SendWindowsNativeNotificationAsync(toast, userTag);
                break;
            case "apns":
                // iOS
                var alert = "{\"aps\":{\"alert\":\"" + "From " + user + ": " + message + "\"}}";
                outcome = await Notifications.Instance.Hub.SendAppleNativeNotificationAsync(alert, userTag);
                break;
            case "fcm":
                // Android
                var notif = "{ \"data\" : {\"message\":\"" + "From " + user + ": " + message + "\"}}";
                outcome = await Notifications.Instance.Hub.SendFcmNativeNotificationAsync(notif, userTag);
                break;
        }
    
        if (outcome != null)
        {
            if (!((outcome.State == Microsoft.Azure.NotificationHubs.NotificationOutcomeState.Abandoned) ||
                (outcome.State == Microsoft.Azure.NotificationHubs.NotificationOutcomeState.Unknown)))
            {
                ret = HttpStatusCode.OK;
            }
        }
    
        return Request.CreateResponse(ret);
    }
    
  4. Selecteer de toets F5 om de toepassing uit te voeren en om de juistheid van uw werk tot nu toe te controleren.To run the application and ensure the accuracy of your work so far, select the F5 key. De app opent een webbrowser en deze wordt weergegeven met de startpagina van ASP.NET.The app opens a web browser, and it is displayed on the ASP.NET home page.

De nieuwe WebAPI-back-end publicerenPublish the new WebAPI backend

U gaat de app nu implementeren op een Azure-website zodat deze toegankelijk is vanaf alle apparaten.Next, you deploy the app to an Azure website to make it accessible from all devices.

  1. Klik met de rechtermuisknop op het project AppBackend en selecteer Publiceren.Right-click the AppBackend project, and then select Publish.

  2. Selecteer Microsoft Azure App Service als publicatiedoel en selecteer vervolgens **Publiceren.Select Microsoft Azure App Service as your publish target, and then select **Publish. Het venster App Service maken wordt geopend.The Create App Service window opens. Hier kunt u alle benodigde Azure-resources maken die nodig zijn om de ASP.NET-web-app in Azure uit te voeren.Here you can create all the necessary Azure resources to run the ASP.NET web app in Azure.

    De tegel Microsoft Azure App Service

  3. Selecteer uw Azure-account in het venster App Service maken.In the Create App Service window, select your Azure account. Selecteer Type wijzigen > Web App.Select Change Type > Web App. Houd de standaard Web App-naam en selecteer het Abonnement, de Resourcegroep en het App Service-plan.Keep the default Web App Name, and then select the Subscription, Resource Group, and App Service Plan.

  4. Selecteer Maken.Select Create.

  5. Noteer de Site-URL-eigenschap in de sectie Samenvatting.Make a note of the Site URL property in the Summary section. Deze URL is het eindpunt van uw back-end verderop in de zelfstudie.This URL is your back-end endpoint later in the tutorial.

  6. Selecteer Publiceren.Select Publish.

Nadat u de wizard hebt voltooid, wordt de ASP.NET-web-app naar Azure gepubliceerd. Daarna wordt de app geopend in de standaardbrowser.After you've completed the wizard, it publishes the ASP.NET web app to Azure and then opens the app in the default browser. Uw toepassing is zichtbaar in Azure App Services.Your application is viewable in Azure App Services.

De URL maakt gebruik van de web-appnaam die u eerder hebt opgegeven, met de notatie http://<app_naam>.azurewebsites.net.The URL uses the web app name that you specified earlier, with the format http://<app_name>.azurewebsites.net.

Uw iOS-app wijzigenModify your iOS app

  1. Open de app met één pagina weergave die u hebt gemaakt in de aan de slag met Notification Hubs (iOS) zelfstudie.Open the Single Page view app you created in the Getting Started with Notification Hubs (iOS) tutorial.

    Notitie

    In deze sectie wordt ervan uitgegaan dat uw project is geconfigureerd met de naam van een lege organisatie.This section assumes that your project is configured with an empty organization name. Als dat niet het geval is, moet u de naam van uw organisatie aan alle klassenamen van de toevoegen aan het begin.If not, you need to prepend your organization name to all class names.

  2. In de Main.storyboard bestand, de onderdelen weergegeven in de schermafbeelding van de objectbibliotheek toe te voegen.In the Main.storyboard file, add the components shown in the screenshot from the object library.

    Hoofd-storyboard in Xcode interface builder bewerken

    • Gebruikersnaam: Een UITextField met tijdelijke aanduiding voor tekst, gebruikersnaam invoeren, direct onder de verzenden resultaten worden gelabeld en beperkt tot de linker- en rechtermarge en onder het label van de resultaten verzenden.Username: A UITextField with placeholder text, Enter Username, immediately beneath the send results label and constrained to the left and right margins and beneath the send results label.

    • Wachtwoord: Een UITextField met tijdelijke aanduiding voor tekst, wachtwoord invoeren, direct onder de gebruikersnaam tekst veld en gebonden aan de linker- en rechtermarge en onder het tekstveld gebruikersnaam.Password: A UITextField with placeholder text, Enter Password, immediately beneath the username text field and constrained to the left and right margins and beneath the username text field. Controleer de tekstinvoer Secure onder de optie in de Inspector kenmerk retourneren sleutel.Check the Secure Text Entry option in the Attribute Inspector, under Return Key.

    • Meld u: Een UIButton onmiddellijk met het label onder het wachtwoordtekstveld en schakel de ingeschakeld onder de optie in de Inspector kenmerken -inhoudLog in: A UIButton labeled immediately beneath the password text field and uncheck the Enabled option in the Attributes Inspector, under Control-Content

    • WNS: Een label en switch om in te schakelen met het verzenden van de melding Windows Notification Service als deze is ingesteld op de hub.WNS: Label and switch to enable sending the notification Windows Notification Service if it has been set up on the hub. Zie de Windows aan de slag zelfstudie.See the Windows Getting Started tutorial.

    • GCM: Label en schakel over naar de melding verzenden naar Google Cloud Messaging, als deze is ingesteld op de hub.GCM: Label and switch to enable sending the notification to Google Cloud Messaging if it has been set up on the hub. Zie Android aan de slag zelfstudie.See Android Getting Started tutorial.

    • APNS: Label en de switch waarmee de melding verzenden naar de Apple-Platform Notification-Service.APNS: Label and switch to enable sending the notification to the Apple Platform Notification Service.

    • Ontvanger Username:A UITextField met tijdelijke aanduiding voor tekst, ontvanger gebruikersnaamtag, direct onder de GCM labelen en gebonden aan de linker- en rechtermarge en onder het label GCM.Recipient Username:A UITextField with placeholder text, Recipient username tag, immediately beneath the GCM label and constrained to the left and right margins and beneath the GCM label.

      Sommige onderdelen zijn toegevoegd de aan de slag met Notification Hubs (iOS) zelfstudie.Some components were added in the Getting Started with Notification Hubs (iOS) tutorial.

  3. CTRL van de onderdelen in de weergave te slepen ViewController.h en deze nieuwe uitgangen toe te voegen.Ctrl drag from the components in the view to ViewController.h and add these new outlets.

    @property (weak, nonatomic) IBOutlet UITextField *UsernameField;
    @property (weak, nonatomic) IBOutlet UITextField *PasswordField;
    @property (weak, nonatomic) IBOutlet UITextField *RecipientField;
    @property (weak, nonatomic) IBOutlet UITextField *NotificationField;
    
    // Used to enable the buttons on the UI
    @property (weak, nonatomic) IBOutlet UIButton *LogInButton;
    @property (weak, nonatomic) IBOutlet UIButton *SendNotificationButton;
    
    // Used to enabled sending notifications across platforms
    @property (weak, nonatomic) IBOutlet UISwitch *WNSSwitch;
    @property (weak, nonatomic) IBOutlet UISwitch *GCMSwitch;
    @property (weak, nonatomic) IBOutlet UISwitch *APNSSwitch;
    
    - (IBAction)LogInAction:(id)sender;
    
  4. In ViewController.h, voeg de volgende #define na uw importinstructies.In ViewController.h, add the following #define after your import statements. Vervang de <Enter Your Backend Endpoint> tijdelijke aanduiding met de doel-URL die u gebruikt voor het implementeren van uw app back-end in de vorige sectie.Substitute the <Enter Your Backend Endpoint> placeholder with the Destination URL you used to deploy your app backend in the previous section. Bijvoorbeeld http://your_backend.azurewebsites.net.For example, http://your_backend.azurewebsites.net.

    #define BACKEND_ENDPOINT @"<Enter Your Backend Endpoint>"
    
  5. In uw project, maakt u een nieuwe klasse Cocoa Touch met de naam RegisterClient voor interactie met de ASP.NET back-end u hebt gemaakt.In your project, create a new Cocoa Touch class named RegisterClient to interface with the ASP.NET back-end you created. Maken van de klasse is overgenomen van NSObject.Create the class inheriting from NSObject. Voeg de volgende code in de RegisterClient.h.Then add the following code in the RegisterClient.h.

    @interface RegisterClient : NSObject
    
    @property (strong, nonatomic) NSString* authenticationHeader;
    
    -(void) registerWithDeviceToken:(NSData*)token tags:(NSSet*)tags
        andCompletion:(void(^)(NSError*))completion;
    
    -(instancetype) initWithEndpoint:(NSString*)Endpoint;
    
    @end
    
  6. In de RegisterClient.m, werken de @interface sectie:In the RegisterClient.m, update the @interface section:

    @interface RegisterClient ()
    
    @property (strong, nonatomic) NSURLSession* session;
    @property (strong, nonatomic) NSURLSession* endpoint;
    
    -(void) tryToRegisterWithDeviceToken:(NSData*)token tags:(NSSet*)tags retry:(BOOL)retry
                andCompletion:(void(^)(NSError*))completion;
    -(void) retrieveOrRequestRegistrationIdWithDeviceToken:(NSString*)token
                completion:(void(^)(NSString*, NSError*))completion;
    -(void) upsertRegistrationWithRegistrationId:(NSString*)registrationId deviceToken:(NSString*)token
                tags:(NSSet*)tags andCompletion:(void(^)(NSURLResponse*, NSError*))completion;
    
    @end
    
  7. Vervang de @implementation sectie in de RegisterClient.m door de volgende code:Replace the @implementation section in the RegisterClient.m with the following code:

    @implementation RegisterClient
    
    // Globals used by RegisterClient
    NSString *const RegistrationIdLocalStorageKey = @"RegistrationId";
    
    -(instancetype) initWithEndpoint:(NSString*)Endpoint
    {
        self = [super init];
        if (self) {
            NSURLSessionConfiguration* config = [NSURLSessionConfiguration defaultSessionConfiguration];
            _session = [NSURLSession sessionWithConfiguration:config delegate:nil delegateQueue:nil];
            _endpoint = Endpoint;
        }
        return self;
    }
    
    -(void) registerWithDeviceToken:(NSData*)token tags:(NSSet*)tags
                andCompletion:(void(^)(NSError*))completion
    {
        [self tryToRegisterWithDeviceToken:token tags:tags retry:YES andCompletion:completion];
    }
    
    -(void) tryToRegisterWithDeviceToken:(NSData*)token tags:(NSSet*)tags retry:(BOOL)retry
                andCompletion:(void(^)(NSError*))completion
    {
        NSSet* tagsSet = tags?tags:[[NSSet alloc] init];
    
        NSString *deviceTokenString = [[token description]
            stringByTrimmingCharactersInSet:[NSCharacterSet characterSetWithCharactersInString:@"<>"]];
        deviceTokenString = [[deviceTokenString stringByReplacingOccurrencesOfString:@" " withString:@""]
                                uppercaseString];
    
        [self retrieveOrRequestRegistrationIdWithDeviceToken: deviceTokenString
            completion:^(NSString* registrationId, NSError *error) {
            NSLog(@"regId: %@", registrationId);
            if (error) {
                completion(error);
                return;
            }
    
            [self upsertRegistrationWithRegistrationId:registrationId deviceToken:deviceTokenString
                tags:tagsSet andCompletion:^(NSURLResponse * response, NSError *error) {
                if (error) {
                    completion(error);
                    return;
                }
    
                NSHTTPURLResponse* httpResponse = (NSHTTPURLResponse*)response;
                if (httpResponse.statusCode == 200) {
                    completion(nil);
                } else if (httpResponse.statusCode == 410 && retry) {
                    [self tryToRegisterWithDeviceToken:token tags:tags retry:NO andCompletion:completion];
                } else {
                    NSLog(@"Registration error with response status: %ld", (long)httpResponse.statusCode);
    
                    completion([NSError errorWithDomain:@"Registration" code:httpResponse.statusCode
                                userInfo:nil]);
                }
    
            }];
        }];
    }
    
    -(void) upsertRegistrationWithRegistrationId:(NSString*)registrationId deviceToken:(NSData*)token
                tags:(NSSet*)tags andCompletion:(void(^)(NSURLResponse*, NSError*))completion
    {
        NSDictionary* deviceRegistration = @{@"Platform" : @"apns", @"Handle": token,
                                                @"Tags": [tags allObjects]};
        NSData* jsonData = [NSJSONSerialization dataWithJSONObject:deviceRegistration
                            options:NSJSONWritingPrettyPrinted error:nil];
    
        NSLog(@"JSON registration: %@", [[NSString alloc] initWithData:jsonData
                                            encoding:NSUTF8StringEncoding]);
    
        NSString* endpoint = [NSString stringWithFormat:@"%@/api/register/%@", _endpoint,
                                registrationId];
        NSURL* requestURL = [NSURL URLWithString:endpoint];
        NSMutableURLRequest* request = [NSMutableURLRequest requestWithURL:requestURL];
        [request setHTTPMethod:@"PUT"];
        [request setHTTPBody:jsonData];
        NSString* authorizationHeaderValue = [NSString stringWithFormat:@"Basic %@",
                                                self.authenticationHeader];
        [request setValue:authorizationHeaderValue forHTTPHeaderField:@"Authorization"];
        [request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
    
        NSURLSessionDataTask* dataTask = [self.session dataTaskWithRequest:request
            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error)
        {
            if (!error)
            {
                completion(response, error);
            }
            else
            {
                NSLog(@"Error request: %@", error);
                completion(nil, error);
            }
        }];
        [dataTask resume];
    }
    
    -(void) retrieveOrRequestRegistrationIdWithDeviceToken:(NSString*)token
                completion:(void(^)(NSString*, NSError*))completion
    {
        NSString* registrationId = [[NSUserDefaults standardUserDefaults]
                                    objectForKey:RegistrationIdLocalStorageKey];
    
        if (registrationId)
        {
            completion(registrationId, nil);
            return;
        }
    
        // request new one & save
        NSURL* requestURL = [NSURL URLWithString:[NSString stringWithFormat:@"%@/api/register?handle=%@",
                                _endpoint, token]];
        NSMutableURLRequest* request = [NSMutableURLRequest requestWithURL:requestURL];
        [request setHTTPMethod:@"POST"];
        NSString* authorizationHeaderValue = [NSString stringWithFormat:@"Basic %@",
                                                self.authenticationHeader];
        [request setValue:authorizationHeaderValue forHTTPHeaderField:@"Authorization"];
    
        NSURLSessionDataTask* dataTask = [self.session dataTaskWithRequest:request
            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error)
        {
            NSHTTPURLResponse* httpResponse = (NSHTTPURLResponse*) response;
            if (!error && httpResponse.statusCode == 200)
            {
                NSString* registrationId = [[NSString alloc] initWithData:data
                    encoding:NSUTF8StringEncoding];
    
                // remove quotes
                registrationId = [registrationId substringWithRange:NSMakeRange(1,
                                    [registrationId length]-2)];
    
                [[NSUserDefaults standardUserDefaults] setObject:registrationId
                    forKey:RegistrationIdLocalStorageKey];
                [[NSUserDefaults standardUserDefaults] synchronize];
    
                completion(registrationId, nil);
            }
            else
            {
                NSLog(@"Error status: %ld, request: %@", (long)httpResponse.statusCode, error);
                if (error)
                    completion(nil, error);
                else {
                    completion(nil, [NSError errorWithDomain:@"Registration" code:httpResponse.statusCode
                                userInfo:nil]);
                }
            }
        }];
        [dataTask resume];
    }
    
    @end
    

    Deze code implementeert de logica die wordt beschreven in het artikel richtlijnen registreren vanuit uw back-end met NSURLSession voor het uitvoeren van REST-aanroepen naar de back-end van uw app en NSUserDefaults voor het lokaal opslaan van de registratie-id die wordt geretourneerd door de Notification hub.This code implements the logic explained in the guidance article Registering from your app backend using NSURLSession to perform REST calls to your app backend, and NSUserDefaults to locally store the registrationId returned by the notification hub.

    Deze klasse moet de eigenschap authorizationHeader moet worden ingesteld om te kunnen goed werken.This class requires its property authorizationHeader to be set in order to work properly. Deze eigenschap is ingesteld door de ViewController klasse na de aanmelding.This property is set by the ViewController class after the login.

  8. In ViewController.h, Voeg een #import -instructie voor RegisterClient.h.In ViewController.h, add a #import statement for RegisterClient.h. Voeg vervolgens een verklaring voor het apparaattoken toe en de verwijzing naar een RegisterClient exemplaar de @interface sectie:Then add a declaration for the device token and reference to a RegisterClient instance in the @interface section:

    #import "RegisterClient.h"
    
    @property (strong, nonatomic) NSData* deviceToken;
    @property (strong, nonatomic) RegisterClient* registerClient;
    
  9. ViewController.m, Voeg een verklaring persoonlijke methode in de @interface sectie:In ViewController.m, add a private method declaration in the @interface section:

    @interface ViewController () <UITextFieldDelegate, NSURLConnectionDataDelegate, NSXMLParserDelegate>
    
    // create the Authorization header to perform Basic authentication with your app back-end
    -(void) createAndSetAuthenticationHeaderWithUsername:(NSString*)username
                    AndPassword:(NSString*)password;
    
    @end
    

    Notitie

    Het volgende codefragment is niet het schema voor een veilige verificatie, vervangt u de implementatie van de createAndSetAuthenticationHeaderWithUsername:AndPassword: met uw specifieke verificatiemechanisme die genereert een verificatietoken om te worden verbruikt door de register-client-klasse, bijvoorbeeld OAuth, Active Directory.The following snippet is not a secure authentication scheme, you should substitute the implementation of the createAndSetAuthenticationHeaderWithUsername:AndPassword: with your specific authentication mechanism that generates an authentication token to be consumed by the register client class, e.g. OAuth, Active Directory.

  10. Klik in de @implementation sectie van ViewController.m, voeg de volgende code, waarmee de implementatie voor het instellen van de apparaat-token en verificatie-header worden toegevoegd.Then in the @implementation section of ViewController.m, add the following code, which adds the implementation for setting the device token and authentication header.

    -(void) setDeviceToken: (NSData*) deviceToken
    {
        _deviceToken = deviceToken;
        self.LogInButton.enabled = YES;
    }
    
    -(void) createAndSetAuthenticationHeaderWithUsername:(NSString*)username
                    AndPassword:(NSString*)password;
    {
        NSString* headerValue = [NSString stringWithFormat:@"%@:%@", username, password];
    
        NSData* encodedData = [[headerValue dataUsingEncoding:NSUTF8StringEncoding] base64EncodedDataWithOptions:NSDataBase64EncodingEndLineWithCarriageReturn];
    
        self.registerClient.authenticationHeader = [[NSString alloc] initWithData:encodedData
                                                    encoding:NSUTF8StringEncoding];
    }
    
    -(BOOL)textFieldShouldReturn:(UITextField *)textField
    {
        [textField resignFirstResponder];
        return YES;
    }
    

    U ziet hoe het apparaattoken stellen, stelt u het logboek in knop.Notice how setting the device token enables the log in button. Het is omdat de view-controller wordt als onderdeel van de actie aanmelding wordt geregistreerd voor pushmeldingen kunt verzenden met de back-end.It's because as a part of the login action, the view controller registers for push notifications with the app backend. Daarom kan niet wilt dat Log In actie toegankelijk totdat het token device juist is ingesteld.Hence, do not want Log In action to be accessible until the device token has been properly set up. U kunt de aanmelding van de push-registratie loskoppelen, zolang de voormalige voordat de laatste gebeurt.You can decouple the login from the push registration as long as the former happens before the latter.

  11. In ViewController.m, gebruikt u de volgende codefragmenten voor het implementeren van de actiemethode voor uw aanmelden knop en een methode voor het verzenden van het meldingsbericht met behulp van de ASP.NET-back-end.In ViewController.m, use the following snippets to implement the action method for your Log In button and a method to send the notification message using the ASP.NET backend.

    - (IBAction)LogInAction:(id)sender {
        // create authentication header and set it in register client
        NSString* username = self.UsernameField.text;
        NSString* password = self.PasswordField.text;
    
        [self createAndSetAuthenticationHeaderWithUsername:username AndPassword:password];
    
        __weak ViewController* selfie = self;
        [self.registerClient registerWithDeviceToken:self.deviceToken tags:nil
            andCompletion:^(NSError* error) {
            if (!error) {
                dispatch_async(dispatch_get_main_queue(),
                ^{
                    selfie.SendNotificationButton.enabled = YES;
                    [self MessageBox:@"Success" message:@"Registered successfully!"];
                });
            }
        }];
    }
    
    - (void)SendNotificationASPNETBackend:(NSString*)pns UsernameTag:(NSString*)usernameTag
                Message:(NSString*)message
    {
        NSURLSession* session = [NSURLSession
            sessionWithConfiguration:[NSURLSessionConfiguration defaultSessionConfiguration] delegate:nil
            delegateQueue:nil];
    
        // Pass the pns and username tag as parameters with the REST URL to the ASP.NET backend
        NSURL* requestURL = [NSURL URLWithString:[NSString
            stringWithFormat:@"%@/api/notifications?pns=%@&to_tag=%@", BACKEND_ENDPOINT, pns,
            usernameTag]];
    
        NSMutableURLRequest* request = [NSMutableURLRequest requestWithURL:requestURL];
        [request setHTTPMethod:@"POST"];
    
        // Get the mock authenticationheader from the register client
        NSString* authorizationHeaderValue = [NSString stringWithFormat:@"Basic %@",
            self.registerClient.authenticationHeader];
        [request setValue:authorizationHeaderValue forHTTPHeaderField:@"Authorization"];
    
        //Add the notification message body
        [request setValue:@"application/json;charset=utf-8" forHTTPHeaderField:@"Content-Type"];
        [request setHTTPBody:[message dataUsingEncoding:NSUTF8StringEncoding]];
    
        // Execute the send notification REST API on the ASP.NET Backend
        NSURLSessionDataTask* dataTask = [session dataTaskWithRequest:request
            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error)
        {
            NSHTTPURLResponse* httpResponse = (NSHTTPURLResponse*) response;
            if (error || httpResponse.statusCode != 200)
            {
                NSString* status = [NSString stringWithFormat:@"Error Status for %@: %d\nError: %@\n",
                                    pns, httpResponse.statusCode, error];
                dispatch_async(dispatch_get_main_queue(),
                ^{
                    // Append text because all 3 PNS calls may also have information to view
                    [self.sendResults setText:[self.sendResults.text stringByAppendingString:status]];
                });
                NSLog(status);
            }
    
            if (data != NULL)
            {
                xmlParser = [[NSXMLParser alloc] initWithData:data];
                [xmlParser setDelegate:self];
                [xmlParser parse];
            }
        }];
        [dataTask resume];
    }
    
  12. Bijwerken van de actie voor de melding verzenden knop gebruikt u de back-end van ASP.NET en verzenden naar een PNS ingeschakeld door een switch.Update the action for the Send Notification button to use the ASP.NET backend and send to any PNS enabled by a switch.

    - (IBAction)SendNotificationMessage:(id)sender
    {
        //[self SendNotificationRESTAPI];
        [self SendToEnabledPlatforms];
    }
    
    -(void)SendToEnabledPlatforms
    {
        NSString* json = [NSString stringWithFormat:@"\"%@\"",self.notificationMessage.text];
    
        [self.sendResults setText:@""];
    
        if ([self.WNSSwitch isOn])
            [self SendNotificationASPNETBackend:@"wns" UsernameTag:self.RecipientField.text Message:json];
    
        if ([self.GCMSwitch isOn])
            [self SendNotificationASPNETBackend:@"gcm" UsernameTag:self.RecipientField.text Message:json];
    
        if ([self.APNSSwitch isOn])
            [self SendNotificationASPNETBackend:@"apns" UsernameTag:self.RecipientField.text Message:json];
    }
    
  13. In de ViewDidLoad functie, het volgende toevoegen aan een exemplaar maken van de RegisterClient instantie en stel de gemachtigde voor uw tekstvelden.In the ViewDidLoad function, add the following to instantiate the RegisterClient instance and set the delegate for your text fields.

    self.UsernameField.delegate = self;
    self.PasswordField.delegate = self;
    self.RecipientField.delegate = self;
    self.registerClient = [[RegisterClient alloc] initWithEndpoint:BACKEND_ENDPOINT];
    
  14. Nu beschikbaar in de AppDelegate.m, verwijdert u alle inhoud van de methode application:didRegisterForPushNotificationWithDeviceToken: en vervang deze door de volgende (Zorg ervoor dat de weergavecontroller de meest recente apparaattoken opgehaald uit de APNs bevat):Now in AppDelegate.m, remove all the content of the method application:didRegisterForPushNotificationWithDeviceToken: and replace it with the following (to make sure that the view controller contains the latest device token retrieved from APNs):

    // Add import to the top of the file
    #import "ViewController.h"
    
    - (void)application:(UIApplication *)application
                didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken
    {
        ViewController* rvc = (ViewController*) self.window.rootViewController;
        rvc.deviceToken = deviceToken;
    }
    
  15. Ten slotte in AppDelegate.m, zorg ervoor dat u hebt de volgende methode:Finally in AppDelegate.m, make sure you have the following method:

    - (void)application:(UIApplication *)application didReceiveRemoteNotification: (NSDictionary *)userInfo {
        NSLog(@"%@", userInfo);
        [self MessageBox:@"Notification" message:[[userInfo objectForKey:@"aps"] valueForKey:@"alert"]];
    }
    

De toepassing testenTest the application

  1. In XCode, moet u de app uitvoeren op een fysiek iOS-apparaat (push-meldingen niet in de simulator werken).In XCode, run the app on a physical iOS device (push notifications do not work in the simulator).

  2. In de iOS-app UI, voert u dezelfde waarde voor zowel gebruikersnaam en wachtwoord.In the iOS app UI, enter same value for both username and password. Klik vervolgens op aanmelden.Then click Log In.

    iOS testen toepassing

  3. U ziet een melding van de registratie van geslaagde pop-upvenster.You should see a pop-up informing you of registration success. Klik op OK.Click OK.

    iOS testen melding weergegeven

  4. In de *ontvanger gebruikersnaamtag tekst en voer de naam label gebruikt in combinatie met de registratie van een ander apparaat.In the *Recipient username tag text field, enter the user name tag used with the registration from another device.

  5. Geef een bericht en klikt u op melding verzenden.Enter a notification message and click Send Notification. Alleen de apparaten waarvoor een registratie met de naam van geadresseerde gebruikerstag ontvangen de melding.Only the devices that have a registration with the recipient user name tag receive the notification message. Het is alleen naar gebruikers verzonden.It is only sent to those users.

    iOS Testmelding gelabelde

Volgende stappenNext steps

In deze zelfstudie hebt u geleerd hoe u pushmeldingen kunt verzenden naar specifieke gebruikers door een tag te koppelen aan hun registraties.In this tutorial, you learned how to push notifications to specific users that have tags associated with their registrations. Als u wilt weten hoe u locatiegebaseerde pushmeldingen kunt verzenden, gaat u verder met de volgende zelfstudie:To learn how to push location-based notifications, advance to the following tutorial: