Hinzufügen von Pushbenachrichtigungen zu Ihrer Xamarin.iOS-App

Überblick

In diesem Lernprogramm fügen Sie dem Schnellstartprojekt Xamarin.iOS Pushbenachrichtigungen hinzu, sodass jedes Mal, wenn ein Datensatz eingefügt wird, eine Pushbenachrichtigung an das Gerät gesendet wird.

Wenn Sie das heruntergeladene Schnellstartserverprojekt nicht verwenden, benötigen Sie das Paket für die Pushbenachrichtigungserweiterung. Weitere Informationen finden Sie unter Arbeiten mit dem .NET-Back-End-Server-SDK für Azure Mobile Apps .

Voraussetzungen

Führen Sie das Schnellstart-Lernprogramm für Xamarin.iOS aus.
Ein physisches iOS-Gerät. Pushbenachrichtigungen werden vom iOS-Simulator nicht unterstützt.

Registrieren der App für Pushbenachrichtigungen im Apple-Entwicklerportal

Registrieren Sie eine App-ID für Ihre App. Erstellen Sie eine explizite App-ID (keine Wildcard-App-ID), und verwenden Sie für Bundle-IDdie genaue Bündel-ID, die sich in Ihrem Xcode-Schnellstartprojekt befindet. Es ist auch wichtig, dass Sie die Option Push-Benachrichtigungen auswählen.
Als Nächstes, zur Vorbereitung auf die Konfiguration von Push-Benachrichtigungen, erstellen Sie entweder ein SSL-Zertifikat für "Entwicklung" oder "Verteilung".

Konfigurieren Ihrer mobilen App zum Senden von Pushbenachrichtigungen

Starten Sie auf Ihrem Mac Keychain Access. Öffnen Sie auf der linken Navigationsleiste unter KategorieMeine Zertifikate. Suchen Sie das SSL-Zertifikat, das Sie im vorherigen Abschnitt heruntergeladen haben, und geben Sie dann deren Inhalte offen. Wählen Sie nur das Zertifikat aus (nicht den privaten Schlüssel auswählen). dannexportieren.
Wählen Sie im Azure-PortalAlle durchsuchen>App Services aus. Wählen Sie dann Ihr Mobile Apps-Back-End aus.
Unter Einstellungenwählen Sie App Service Push-aus. Wählen Sie dann Ihren Benachrichtigungshubnamen aus.
Wechseln Sie zu Apple Push Notification Services>Hochladen des Zertifikats. Laden Sie die .p12-Datei hoch, und wählen Sie den richtigen Modus aus (je nachdem, ob Ihr Client-SSL-Zertifikat zuvor für die Produktion oder die Sandbox verwendet wurde). Speichern Sie alle Änderungen.

Ihr Dienst ist jetzt für die Arbeit mit Pushbenachrichtigungen unter iOS konfiguriert.

Aktualisieren des Serverprojekts zum Senden von Pushbenachrichtigungen

In diesem Abschnitt aktualisieren Sie Code in Ihrem vorhandenen Back-End-Projekt für mobile Apps so, dass jedes Mal, wenn ein neues Element hinzugefügt wird, eine Pushbenachrichtigung gesendet wird. Der Prozess wird von der Vorlagenfunktion von Azure Notification Hubs unterstützt, die plattformübergreifende Push-Benachrichtigungen ermöglicht. Die verschiedenen Clients werden mithilfe von Vorlagen für Pushbenachrichtigungen registriert, und ein einzelner universeller Push kann auf alle Clientplattformen übertragen werden.

Wählen Sie eine der folgenden Verfahren aus, die Ihrem Back-End-Projekttyp entsprechen – entweder .NET Back-End oder Node.js Back-End.

.NET-Back-End-Projekt

Klicken Sie in Visual Studio mit der rechten Maustaste auf das Serverprojekt. Wählen Sie dann "NuGet-Pakete verwalten" aus. Suchen Sie nach Microsoft.Azure.NotificationHubs, und wählen Sie dann Installieren aus. Dieser Vorgang installiert die Benachrichtigungshubs-Bibliothek zum Senden von Benachrichtigungen vom Back-End.

Öffnen Sie im Serverprojekt Controller>TodoItemController.cs. Fügen Sie dann die folgenden "using"-Anweisungen hinzu:

using System.Collections.Generic;
using Microsoft.Azure.NotificationHubs;
using Microsoft.Azure.Mobile.Server.Config;

Fügen Sie in der PostTodoItem-Methode den folgenden Code nach dem Aufruf von InsertAsync hinzu:

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

Dieser Vorgang sendet eine Vorlagenbenachrichtigung, die das Element.Text enthält, wenn ein neues Element eingefügt wird.

Veröffentlichen Sie das Serverprojekt erneut.

Node.js Backend-Projekt

Richten Sie Ihr Back-End-Projekt ein.

Ersetzen Sie den vorhandenen Code in todoitem.js durch den folgenden 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;

Dieser Vorgang sendet eine Vorlagenbenachrichtigung, die den Element.text enthält, wenn ein neues Element eingefügt wird.

Wenn Sie die Datei auf Ihrem lokalen Computer bearbeiten, veröffentlichen Sie das Serverprojekt erneut.

Konfigurieren Ihres Xamarin.iOS-Projekts

Konfigurieren des iOS-Projekts in Xamarin Studio

Öffnen Sie in Xamarin.Studio Info.plist, und aktualisieren Sie den Bündelbezeichner mit der Bündel-ID, die Sie zuvor mit Ihrer neuen App-ID erstellt haben.
Scrollen Sie nach unten zu Hintergrundmodi. Aktivieren Sie das Feld "Hintergrundmodi aktivieren " und das Feld "Remotebenachrichtigungen ".
Doppelklicken Sie im Projektmappenbereich auf Ihr Projekt, um Projektoptionen zu öffnen.
Wählen Sie unter "Build" die Option "iOS Bundle Signing" aus, und wählen Sie das entsprechende Identitäts- und Bereitstellungsprofil aus, das Sie soeben für dieses Projekt eingerichtet haben.

Dadurch wird sichergestellt, dass das Projekt das neue Profil für die Code-Signierung verwendet. Die offizielle Xamarin-Gerätebereitstellungsdokumentation finden Sie unter Xamarin Device Provisioning.

Konfigurieren des iOS-Projekts in Visual Studio

Klicken Sie in Visual Studio mit der rechten Maustaste auf das Projekt, und klicken Sie dann auf "Eigenschaften".
Klicken Sie auf den Eigenschaftenseiten auf die Registerkarte "iOS-Anwendung ", und aktualisieren Sie den Bezeichner mit der ID, die Sie zuvor erstellt haben.
Wählen Sie auf der Registerkarte "iOS Bundle Signing " das entsprechende Identitäts- und Bereitstellungsprofil aus, das Sie soeben für dieses Projekt eingerichtet haben.

Dadurch wird sichergestellt, dass das Projekt das neue Profil für die Code-Signierung verwendet. Die offizielle Xamarin-Gerätebereitstellungsdokumentation finden Sie unter Xamarin Device Provisioning.
Doppelklicken Sie auf "Info.plist", um sie zu öffnen, und aktivieren Sie remoteNotifications unter "Hintergrundmodi".

Hinzufügen von Pushbenachrichtigungen zu Ihrer App

Fügen Sie in QSTodoService die folgende Eigenschaft hinzu, damit AppDelegate den mobilen Client abrufen kann:

public MobileServiceClient GetClient {
    get
    {
        return client;
    }
    private set
    {
        client = value;
    }
}

Fügen Sie die folgende using Anweisung am Anfang der AppDelegate.cs Datei hinzu.
```
using Microsoft.WindowsAzure.MobileServices;
using Newtonsoft.Json.Linq;
```

Überschreiben Sie in AppDelegate das FinishedLaunching-Ereignis :

 public override bool FinishedLaunching(UIApplication application, NSDictionary launchOptions)
 {
     // registers for push for iOS8
     var settings = UIUserNotificationSettings.GetSettingsForTypes(
         UIUserNotificationType.Alert
         | UIUserNotificationType.Badge
         | UIUserNotificationType.Sound,
         new NSSet());

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

     return true;
 }

Überschreiben Sie in derselben Datei das RegisteredForRemoteNotifications Ereignis. In diesem Code registrieren Sie sich für eine einfache Vorlagenbenachrichtigung, die über alle unterstützten Plattformen vom Server gesendet wird.

Weitere Informationen zu Vorlagen mit Benachrichtigungshubs finden Sie unter Vorlagen.

public override void RegisteredForRemoteNotifications(UIApplication application, NSData deviceToken)
{
    MobileServiceClient client = QSTodoService.DefaultService.GetClient;

    const string templateBodyAPNS = "{\"aps\":{\"alert\":\"$(messageParam)\"}}";

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

    // Register for push with your mobile app
    var push = client.GetPush();
    push.RegisterAsync(deviceToken, templates);
}

Dann überschreiben Sie das didReceiveRemoteNotification-Ereignis:

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

Ihre App wird jetzt aktualisiert, um Pushbenachrichtigungen zu unterstützen.

Testen von Pushbenachrichtigungen in Ihrer App

Drücken Sie die Schaltfläche "Ausführen ", um das Projekt zu erstellen und die App auf einem iOS-fähigen Gerät zu starten, und klicken Sie dann auf "OK ", um Pushbenachrichtigungen zu akzeptieren.

Hinweis

Sie müssen Pushbenachrichtigungen explizit von Ihrer App akzeptieren. Diese Anforderung tritt nur bei der ersten Ausführung der App auf.
Geben Sie in der App eine Aufgabe ein, und klicken Sie dann auf das Plussymbol (+).
Stellen Sie sicher, dass eine Benachrichtigung empfangen wird, und klicken Sie dann auf OK, um die Benachrichtigung zu schließen.
Wiederholen Sie Schritt 2, und schließen Sie die App sofort, und stellen Sie sicher, dass eine Benachrichtigung angezeigt wird.

Sie haben dieses Tutorial erfolgreich abgeschlossen.

Last updated on 2019-06-25

Freigeben über