Dodawanie powiadomień wypychanych do aplikacji platformy Xamarin.Forms

Artykuł
06/25/2019

Omówienie

W tym samouczku dodasz powiadomienia wypychane do wszystkich projektów, które wynikały z przewodnika Szybki start platformy Xamarin.Forms. Oznacza to, że powiadomienie wypychane jest wysyłane do wszystkich klientów międzyplatformowych przy każdym wstawieniu rekordu.

Jeśli nie używasz pobranego projektu serwera Szybki start, potrzebny będzie pakiet rozszerzenia powiadomień wypychanych. Aby uzyskać więcej informacji, zobacz Praca z zestawem SDK serwera zaplecza platformy .NET dla usługi Azure Mobile Apps.

Wymagania wstępne

W przypadku systemu iOS będziesz potrzebować członkostwa w programie Apple Developer Program i fizycznego urządzenia z systemem iOS. Symulator systemu iOS nie obsługuje powiadomień wypychanych.

Konfigurowanie centrum powiadomień

Funkcja Mobile Apps usługi Azure App Service używa usługi Azure Notification Hubs do wysyłania wypychań, dlatego skonfigurujesz centrum powiadomień dla aplikacji mobilnej.

W Azure Portal przejdź do usługi App Services, a następnie wybierz zaplecze aplikacji. W obszarze Ustawienia wybierz pozycję Wypchnij.
Aby dodać zasób centrum powiadomień do aplikacji, wybierz pozycję Połącz. Możesz utworzyć koncentrator lub połączyć się z istniejącym.

Teraz połączono centrum powiadomień z projektem zaplecza usługi Mobile Apps. Później skonfigurujesz to centrum powiadomień, aby nawiązać połączenie z systemem powiadomień platformy (PNS) w celu wypychania do urządzeń.

Aktualizowanie projektu serwera w celu wysyłania powiadomień wypychanych

W tej sekcji zaktualizujesz kod w istniejącym projekcie zaplecza usługi Mobile Apps, aby wysyłać powiadomienie wypychane za każdym razem, gdy zostanie dodany nowy element. Ten proces jest obsługiwany przez funkcję szablonu usługi Azure Notification Hubs, która umożliwia wypychanie międzyplatformowe. Różni klienci są zarejestrowani na potrzeby powiadomień wypychanych przy użyciu szablonów, a pojedyncze uniwersalne wypychanie może zostać wyświetlone na wszystkich platformach klienckich.

Wybierz jedną z poniższych procedur pasujących do typu projektu zaplecza — zaplecza platformy .NET lub Node.js zaplecza.

Projekt zaplecza platformy .NET

W programie Visual Studio kliknij prawym przyciskiem myszy projekt serwera. Następnie wybierz pozycję Zarządzaj pakietami NuGet. Wyszukaj ciąg Microsoft.Azure.NotificationHubs, a następnie wybierz pozycję Zainstaluj. Ten proces instaluje bibliotekę usługi Notification Hubs na potrzeby wysyłania powiadomień z zaplecza.

W projekcie serwera otwórz plik Controllers>TodoItemController.cs. Następnie dodaj następujące instrukcje using:

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

W metodzie PostTodoItem dodaj następujący kod po wywołaniu metody 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");
}

Ten proces wysyła powiadomienie szablonu zawierające element. Tekst po wstawieniu nowego elementu.

Ponownie opublikuj projekt serwera.

projekt zaplecza Node.js

Skonfiguruj projekt zaplecza.

Zastąp istniejący kod w todoitem.js następującym kodem:

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;

Ten proces wysyła powiadomienie szablonu zawierające element item.text po wstawieniu nowego elementu.

Podczas edytowania pliku na komputerze lokalnym ponownie opublikuj projekt serwera.

Konfigurowanie i uruchamianie projektu systemu Android (opcjonalnie)

Ukończ tę sekcję, aby włączyć powiadomienia wypychane dla projektu Droid platformy Xamarin.Forms dla systemu Android.

Włączanie usługi Firebase Cloud Messaging (FCM)

Zaloguj się do konsoli Firebase. Utwórz nowy projekt Firebase, jeśli jeszcze go nie masz.
Po utworzeniu projektu wybierz pozycję Dodaj Firebase do swojej aplikacji dla systemu Android.
Na stronie Dodawanie aplikacji Firebase do aplikacji systemu Android wykonaj następujące kroki:
1. W polu Nazwa pakietu systemu Android skopiuj wartość applicationId w pliku build.gradle aplikacji. W tym przykładzie jest to com.fabrikam.fcmtutorial1app.
2. Wybierz pozycję Zarejestruj aplikację.
Wybierz pozycję Pobierz plik google-services.json, zapisz plik w folderze aplikacji projektu, a następnie wybierz pozycję Dalej.
Wprowadź następujące zmiany konfiguracji w projekcie w programie Android Studio.
1. W pliku build.gradle na poziomie projektu (<project>/build.gradle) dodaj następującą instrukcję do sekcji zależności .
```
classpath 'com.google.gms:google-services:4.0.1'
```
2. W pliku build.gradle na poziomie aplikacji (<project>/<app-module>/build.gradle) dodaj następujące instrukcje do sekcji zależności.
```
implementation 'com.google.firebase:firebase-core:16.0.8'
implementation 'com.google.firebase:firebase-messaging:17.3.4'
```
3. Dodaj następujący wiersz na końcu pliku build.gradle na poziomie aplikacji po sekcji zależności.
```
apply plugin: 'com.google.gms.google-services'
```
4. Wybierz pozycję Synchronizuj teraz na pasku narzędzi.
Wybierz opcję Dalej.
Wybierz pozycję Pomiń ten krok.
W konsoli usługi Firebase wybierz koło zębate dla projektu. Następnie wybierz pozycję Ustawienia projektu.
Jeśli plik google-services.json nie został pobrany do folderu aplikacji projektu programu Android Studio, możesz to zrobić na tej stronie.
Przejdź do karty Cloud Messaging (Obsługa komunikatów w chmurze ) u góry.
Skopiuj i zapisz klucz serwera do późniejszego użycia. Ta wartość służy do konfigurowania centrum.

Konfigurowanie zaplecza usługi Mobile Apps w celu wysyłania żądań wypychania przy użyciu usługi FCM

W Azure Portal wybierz pozycję Przeglądaj wszystkie>usługi App Services. Następnie wybierz zaplecze usługi Mobile Apps.
W obszarze Ustawienia wybierz pozycję Wypchnij. Następnie wybierz pozycję Konfiguruj usługi powiadomień wypychanych.
Przejdź do usługi Google (GCM). Wprowadź starszy klucz serwera FCM uzyskany z konsoli Firebase, a następnie wybierz pozycję Zapisz.

Twoja usługa jest teraz skonfigurowana do pracy z usługą Firebase Cloud Messaging.

Dodawanie powiadomień wypychanych do projektu systemu Android

Za pomocą zaplecza skonfigurowanego za pomocą usługi FCM można dodawać składniki i kody do klienta w celu zarejestrowania się w usłudze FCM. Możesz również zarejestrować się w celu otrzymywania powiadomień wypychanych w usłudze Azure Notification Hubs za pośrednictwem zaplecza usługi Mobile Apps i otrzymywać powiadomienia.

W projekcie Droid kliknij prawym przyciskiem myszy pozycję Odwołania Zarządzaj pakietami > NuGet ....
W oknie Menedżer pakietów NuGet wyszukaj pakiet Xamarin.Firebase.Messaging i dodaj go do projektu.
We właściwościach projektu Droid ustaw aplikację do kompilowania przy użyciu systemu Android w wersji 7.0 lub nowszej.
Dodaj plik google-services.json pobrany z konsoli Firebase do katalogu głównego projektu Droid i ustaw jego akcję kompilacji na GoogleServicesJson. Aby uzyskać więcej informacji, zobacz Dodawanie pliku JSON usług Google.

Rejestrowanie w usłudze Firebase Cloud Messaging

Otwórz plik AndroidManifest.xml i wstaw następujące elementy <receiver> do elementu <application>:

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

Implementowanie usługi identyfikatora wystąpienia programu Firebase

Dodaj nową klasę do projektu Droid o nazwie FirebaseRegistrationServicei upewnij się, że w górnej części pliku znajdują się następujące using instrukcje:
```
using System.Threading.Tasks;
using Android.App;
using Android.Util;
using Firebase.Iid;
using Microsoft.WindowsAzure.MobileServices;
```
Zastąp pustą FirebaseRegistrationService klasę następującym kodem:
```
[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);
        });
    }
}
```
Klasa FirebaseRegistrationService jest odpowiedzialna za generowanie tokenów zabezpieczających, które autoryzować aplikację do uzyskiwania dostępu do usługi FCM. Metoda OnTokenRefresh jest wywoływana, gdy aplikacja odbiera token rejestracji z usługi FCM. Metoda pobiera token z FirebaseInstanceId.Instance.Token właściwości, która jest asynchronicznie aktualizowana przez usługę FCM. Metoda OnTokenRefresh jest często wywoływana, ponieważ token jest aktualizowany tylko po zainstalowaniu lub odinstalowaniu aplikacji, gdy użytkownik usunie dane aplikacji, gdy aplikacja wymazuje identyfikator wystąpienia lub gdy bezpieczeństwo tokenu zostało naruszone. Ponadto usługa identyfikatora wystąpienia usługi FCM będzie żądać, aby aplikacja okresowo odświeżyła token, zazwyczaj co 6 miesięcy.

Metoda OnTokenRefresh wywołuje również metodę SendRegistrationTokenToAzureNotificationHub , która służy do skojarzenia tokenu rejestracji użytkownika z usługą Azure Notification Hub.

Rejestrowanie w usłudze Azure Notification Hub

Dodaj nową klasę do projektu Droid o nazwie AzureNotificationHubServicei upewnij się, że w górnej części pliku znajdują się następujące using instrukcje:
```
using System;
using System.Threading.Tasks;
using Android.Util;
using Microsoft.WindowsAzure.MobileServices;
using Newtonsoft.Json.Linq;
```

Zastąp pustą AzureNotificationHubService klasę następującym kodem:

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

Metoda RegisterAsync tworzy prosty szablon komunikatu powiadomienia jako kod JSON i rejestruje się w celu odbierania powiadomień szablonu z centrum powiadomień przy użyciu tokenu rejestracji Bazy danych Firebase. Dzięki temu wszystkie powiadomienia wysyłane z usługi Azure Notification Hub będą kierowane do urządzenia reprezentowanego przez token rejestracji.

Wyświetlanie zawartości powiadomienia wypychanego

Dodaj nową klasę do projektu Droid o nazwie FirebaseNotificationServicei upewnij się, że w górnej części pliku znajdują się następujące using instrukcje:
```
using Android.App;
using Android.Content;
using Android.Media;
using Android.Support.V7.App;
using Android.Util;
using Firebase.Messaging;
```

Zastąp pustą FirebaseNotificationService klasę następującym kodem:

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

Metoda OnMessageReceived , która jest wywoływana, gdy aplikacja odbiera powiadomienie z usługi FCM, wyodrębnia zawartość komunikatu i wywołuje metodę SendNotification . Ta metoda konwertuje zawartość komunikatu na lokalne powiadomienie uruchomione podczas działania aplikacji z powiadomieniem wyświetlanym w obszarze powiadomień.

Teraz możesz przystąpić do testowania powiadomień wypychanych w aplikacji uruchomionej na urządzeniu z systemem Android lub emulatorze.

Testowanie powiadomień wypychanych w aplikacji systemu Android

Pierwsze dwa kroki są wymagane tylko w przypadku testowania w emulatorze.

Upewnij się, że wdrażasz program lub debugujesz na urządzeniu lub emulatorze skonfigurowanym z usługami Google Play. Można to zweryfikować, sprawdzając, czy aplikacje play są zainstalowane na urządzeniu lub emulatorze.
Dodaj konto Google na urządzeniu z systemem Android, klikając pozycjęUstawienia>aplikacji>Dodaj konto. Następnie postępuj zgodnie z monitami, aby dodać istniejące konto Google do urządzenia lub utworzyć nowe.
W programie Visual Studio lub Xamarin Studio kliknij prawym przyciskiem myszy projekt Droid i kliknij pozycję Ustaw jako projekt startowy.
Kliknij przycisk Uruchom , aby skompilować projekt i uruchomić aplikację na urządzeniu z systemem Android lub emulatorze.
W aplikacji wpisz zadanie, a następnie kliknij ikonę plus (+).
Sprawdź, czy po dodaniu elementu zostanie odebrane powiadomienie.

Konfigurowanie i uruchamianie projektu systemu iOS (opcjonalnie)

Ta sekcja dotyczy uruchamiania projektu Xamarin iOS dla urządzeń z systemem iOS. Jeśli nie pracujesz z urządzeniami z systemem iOS, możesz pominąć tę sekcję.

Generowanie pliku żądania podpisywania certyfikatu

Usługa Apple Push Notification Service (APNs) używa certyfikatów do uwierzytelniania powiadomień wypychanych. Wykonaj instrukcje, aby utworzyć niezbędny certyfikat powiadomień wypychanych umożliwiający ich wysyłanie i odbieranie. Więcej informacji dotyczących tych pojęć można znaleźć w oficjalnej dokumentacji usługi Apple Push Notification Service.

Wygeneruj plik Żądania podpisania certyfikatu (CSR), którego firma Apple używa do generowania podpisanego certyfikatu wypychania.

Na komputerze Mac uruchom narzędzie Keychain Access. Można go otworzyć z folderu Utilities lub innego folderu na launchpad.
Wybierz pozycję Dostęp pęku kluczy, rozwiń węzeł Asystent certyfikatów, a następnie wybierz pozycję Zażądaj certyfikatu z urzędu certyfikacji.

Uwaga

Domyślnie dostęp do pęku kluczy wybiera pierwszy element na liście. Może to być problem, jeśli jesteś w kategorii Certyfikaty i Apple Worldwide Developer Relations Certification Authority nie jest pierwszym elementem na liście. Przed wygenerowaniem żądania CSR (żądanie podpisania certyfikatu) upewnij się, że masz element inny niż klucz lub klucz Urzędu certyfikacji Relacji z deweloperami firmy Apple .
Wybierz swój adres Email użytkownika, wprowadź wartość Nazwa pospolita, upewnij się, że określono wartość Zapisano na dysku, a następnie wybierz pozycję Kontynuuj. Pozostaw urząd certyfikacji Email Adres pusty, ponieważ nie jest wymagany.
Wprowadź nazwę pliku CSR w obszarze Zapisz jako, wybierz lokalizację w obszarze Gdzie, a następnie wybierz pozycję Zapisz.

Ta akcja zapisuje plik CSR w wybranej lokalizacji. Domyślna lokalizacja to Desktop. Zapamiętaj wybraną lokalizację pliku.

Następnie zarejestruj aplikację za pomocą firmy Apple, włącz powiadomienia wypychane i przekaż wyeksportowane csr, aby utworzyć certyfikat wypychania.

Rejestrowanie aplikacji dla usługi powiadomień wypychanych

Aby wysyłać powiadomienia wypychane do aplikacji systemu iOS, zarejestruj aplikację za pomocą firmy Apple, a także zarejestruj się w celu otrzymywania powiadomień wypychanych.

Jeśli aplikacja nie została jeszcze zarejestrowana, przejdź do portalu aprowizacji systemu iOS w Centrum deweloperów firmy Apple. Zaloguj się do portalu przy użyciu identyfikatora Apple ID i wybierz pozycję Identyfikatory. Następnie wybierz, + aby zarejestrować nową aplikację.
Na ekranie Rejestrowanie nowego identyfikatora wybierz przycisk radiowy Identyfikatory aplikacji . Następnie wybierz pozycję Kontynuuj.
Zaktualizuj następujące trzy wartości dla nowej aplikacji, a następnie wybierz pozycję Kontynuuj:
- Opis: wpisz opisową nazwę aplikacji.
- Identyfikator pakietu: wprowadź identyfikator pakietu formularza Organization Identifier.Product Name , jak wspomniano w przewodniku dystrybucji aplikacji. Wartości Identyfikator organizacji i Nazwa produktu muszą być zgodne z identyfikatorem organizacji i nazwą produktu używaną podczas tworzenia projektu Xcode. Na poniższym zrzucie ekranu wartość NotificationHubs jest używana jako identyfikator organizacji, a wartość GetStarted jest używana jako nazwa produktu. Upewnij się, że wartość Identyfikator pakietu jest zgodna z wartością w projekcie Xcode, aby program Xcode używał poprawnego profilu publikowania.
- Powiadomienia wypychane: sprawdź opcję Powiadomienia wypychane w sekcji Możliwości .
  
  Ta akcja generuje identyfikator aplikacji i żąda potwierdzenia informacji. Wybierz pozycję Kontynuuj, a następnie wybierz pozycję Zarejestruj , aby potwierdzić nowy identyfikator aplikacji.
  
  Po wybraniu pozycji Zarejestruj nowy identyfikator aplikacji zostanie wyświetlony jako element wiersza na stronie Certyfikaty, Identyfikatory & Profile .
Na stronie Certyfikaty identyfikatory & Profile w obszarze Identyfikatory znajdź właśnie utworzony element wiersza identyfikatora aplikacji i wybierz jego wiersz, aby wyświetlić ekran Edytuj konfigurację identyfikatora aplikacji.

Tworzenie certyfikatu dla usługi Notification Hubs

Certyfikat jest wymagany do włączenia centrum powiadomień do pracy z usługą APNS. Można to zrobić na jeden z dwóch sposobów:

Utwórz plik p12 , który można przekazać bezpośrednio do centrum powiadomień.
Utwórz plik p8 , który może służyć do uwierzytelniania opartego na tokenach (nowsze podejście).

Nowsze podejście ma wiele korzyści (w porównaniu z używaniem certyfikatów), jak opisano w artykule Uwierzytelnianie oparte na tokenach (HTTP/2) dla usługi APNS. Jednak dla obu metod podano kroki.

OPCJA 1. Tworzenie certyfikatu wypychania p12, który można przekazać bezpośrednio do centrum powiadomień

Przewiń w dół do zaznaczonej opcji Powiadomienia wypychane , a następnie wybierz pozycję Konfiguruj , aby utworzyć certyfikat.
Zostanie wyświetlone okno Certyfikaty SSL usługi Apple Push Notification Service . Wybierz przycisk Utwórz certyfikat w sekcji Tworzenie certyfikatu SSL .

Zostanie wyświetlony ekran Tworzenie nowego certyfikatu .

Uwaga

Instrukcje w tym samouczku obejmują użycie certyfikatu deweloperskiego. Ten sam proces jest używany podczas rejestrowania certyfikatu produkcyjnego. Należy po prostu pamiętać, aby używać tego samego typu certyfikatu podczas wysyłania powiadomień.
Wybierz pozycję Wybierz plik, przejdź do lokalizacji, w której zapisano plik CSR z pierwszego zadania, a następnie kliknij dwukrotnie nazwę certyfikatu, aby go załadować. Następnie wybierz pozycję Kontynuuj.
Po utworzeniu certyfikatu przez portal wybierz przycisk Pobierz . Zapisz certyfikat i zapamiętaj lokalizację, do której został zapisany.

Certyfikat jest pobierany i zapisywany na komputerze w folderze Pobrane .

Uwaga

Domyślnie pobrany certyfikat dewelopera ma nazwę aps_development.cer.
Kliknij dwukrotnie pobrany certyfikat powiadomień wypychanych aps_development.cer. Ta akcja powoduje zainstalowanie nowego certyfikatu w narzędziu Keychain, jak przedstawiono na poniższym rysunku:

Uwaga

Chociaż nazwa w certyfikacie może być inna, nazwa będzie poprzedzona usługami Apple Development iOS Push Services.
W narzędziu Keychain Access kliknij prawym przyciskiem myszy nowy certyfikat powiadomień wypychanych utworzony w kategorii Certyfikaty. Wybierz pozycję Eksportuj, nadaj plikowi nazwę, wybierz format p12 , a następnie wybierz pozycję Zapisz.

Możesz wybrać ochronę certyfikatu przy użyciu hasła, ale jest to opcjonalne. Kliknij przycisk OK , jeśli chcesz pominąć tworzenie haseł. Zanotuj nazwę pliku i lokalizację wyeksportowanego certyfikatu .p12. Są one używane do włączania uwierzytelniania za pomocą sieci APNs.

Uwaga

Nazwa i lokalizacja pliku p12 mogą być inne niż to, co zostało na zdjęciu w tym samouczku.

OPCJA 2. Tworzenie certyfikatu p8, który może służyć do uwierzytelniania opartego na tokenach

Zanotuj następujące szczegóły:
- Prefiks identyfikatora aplikacji (jest to identyfikator zespołu)
- Identyfikator pakietu
Po powrocie do pozycji Certyfikaty, identyfikatory & profile, kliknij pozycję Klucze.

Uwaga

Jeśli masz już klucz skonfigurowany dla usługi APNS, możesz ponownie użyć certyfikatu p8 pobranego bezpośrednio po jego utworzeniu. Jeśli tak, możesz zignorować kroki od 3 do 5.
+ Kliknij przycisk (lub przycisk Utwórz klucz), aby utworzyć nowy klucz.
Podaj odpowiednią wartość nazwy klucza , a następnie zaznacz opcję Apple Push Notifications Service (APNs), a następnie kliknij przycisk Kontynuuj, a następnie zarejestruj się na następnym ekranie.
Kliknij przycisk Pobierz , a następnie przenieś plik p8 (poprzedzony AuthKey_) do bezpiecznego katalogu lokalnego, a następnie kliknij przycisk Gotowe.

Uwaga

Pamiętaj, aby zachować plik p8 w bezpiecznym miejscu (i zapisz kopię zapasową). Po pobraniu klucza nie można go ponownie pobrać, ponieważ kopia serwera zostanie usunięta.
W obszarze Klucze kliknij właśnie utworzony klucz (lub istniejący klucz, jeśli został wybrany do użycia).
Zanotuj wartość Identyfikator klucza .
Otwórz certyfikat p8 w odpowiedniej aplikacji, takiej jak Visual Studio Code, a następnie zanotuj wartość klucza. Jest to wartość -----BEGIN PRIVATE KEY----- i -----END PRIVATE KEY----- .
```
-----BEGIN PRIVATE KEY-----
<key_value>
-----END PRIVATE KEY-----
```
Uwaga

Jest to wartość tokenu , która zostanie później użyta do skonfigurowania centrum powiadomień.

Na końcu tych kroków powinny być dostępne następujące informacje do późniejszego użycia w temacie Konfigurowanie centrum powiadomień z informacjami o usłudze APNs:

Identyfikator zespołu (zobacz krok 1)
Identyfikator pakietu (zobacz krok 1)
Identyfikator klucza (zobacz krok 7)
Wartość tokenu , tj. wartość klucza p8 (zobacz krok 8)

Tworzenie profilu inicjowania obsługi dla aplikacji

Wróć do portalu aprowizacji systemu iOS, wybierz pozycję Certyfikaty, Identyfikatory & Profile, wybierz pozycję Profile z menu po lewej stronie, a następnie wybierz, + aby utworzyć nowy profil. Zostanie wyświetlony ekran Rejestrowanie nowego profilu aprowizacji .
Wybierz pozycję Programowanie aplikacji dla systemu iOS w obszarze Programowanie jako typ profilu aprowizacji, a następnie wybierz pozycję Kontynuuj.
Następnie wybierz identyfikator aplikacji utworzony z listy rozwijanej Identyfikator aplikacji , a następnie wybierz pozycję Kontynuuj.
W oknie Wybieranie certyfikatów wybierz certyfikat dewelopera używany do podpisywania kodu, a następnie wybierz pozycję Kontynuuj. Ten certyfikat nie jest utworzonym certyfikatem wypychania. Jeśli taki nie istnieje, musisz go utworzyć. Jeśli certyfikat istnieje, przejdź do następnego kroku. Aby utworzyć certyfikat dewelopera, jeśli nie istnieje:
1. Jeśli widzisz komunikat Brak certyfikatów, wybierz pozycję Utwórz certyfikat.
2. W sekcji Software (Oprogramowanie) wybierz pozycję Apple Development (Programowanie firmy Apple). Następnie wybierz pozycję Kontynuuj.
3. Na ekranie Tworzenie nowego certyfikatu wybierz pozycję Wybierz plik.
4. Przejdź do utworzonego wcześniej certyfikatu żądania podpisania certyfikatu , wybierz go, a następnie wybierz pozycję Otwórz.
5. Wybierz opcję Kontynuuj.
6. Pobierz certyfikat dewelopera i zapamiętaj lokalizację, do której został zapisany.
Wróć do strony Certyfikaty, Identyfikatory & Profile , wybierz pozycję Profile z menu po lewej stronie, a następnie wybierz, + aby utworzyć nowy profil. Zostanie wyświetlony ekran Rejestrowanie nowego profilu aprowizacji .
W oknie Wybieranie certyfikatów wybierz właśnie utworzony certyfikat dewelopera. Następnie wybierz pozycję Kontynuuj.
Następnie wybierz urządzenia do użycia do testowania, a następnie wybierz pozycję Kontynuuj.
Na koniec wybierz nazwę profilu w polu Nazwa profilu aprowizacji, a następnie wybierz pozycję Generuj.
Po utworzeniu nowego profilu aprowizacji wybierz pozycję Pobierz. Zapamiętaj lokalizację, do której jest zapisywana.
Przejdź do lokalizacji profilu aprowizacji, a następnie kliknij go dwukrotnie, aby zainstalować go na maszynie dewelopera Xcode.

Tworzenie centrum powiadomień

W tej sekcji utworzysz centrum powiadomień i skonfigurujesz uwierzytelnianie za pomocą usługi APNs przy użyciu certyfikatu wypychania p12 lub uwierzytelniania opartego na tokenach. Jeśli chcesz użyć już utworzonego centrum powiadomień, możesz przejść do kroku 5.

Zaloguj się w witrynie Azure Portal.
Wybierz pozycję Wszystkie usługi w menu po lewej stronie, a następnie wybierz pozycję Notification Hubs w sekcji Mobile . Wybierz ikonę star obok nazwy usługi, aby dodać usługę do sekcji ULUBIONE w menu po lewej stronie. Po dodaniu usługi Notification Hubs do pozycji ULUBIONE wybierz je w menu po lewej stronie.
Na stronie Notification Hubs wybierz pozycję Dodaj na pasku narzędzi.
Na stronie Centrum powiadomień wykonaj następujące kroki:
1. Wprowadź nazwę w centrum powiadomień.
2. Wprowadź nazwę w obszarze Utwórz nową przestrzeń nazw. Przestrzeń nazw zawiera co najmniej jedno centrum.
3. Wybierz wartość z listy rozwijanej Lokalizacja . Ta wartość określa lokalizację, w której chcesz utworzyć centrum.
4. Wybierz istniejącą grupę zasobów w grupie zasobów lub utwórz nazwę nowej grupy zasobów.
5. Wybierz przycisk Utwórz.
Wybierz pozycję Powiadomienia (ikona dzwonka), a następnie wybierz pozycję Przejdź do zasobu. Możesz również odświeżyć listę na stronie Usługi Notification Hubs i wybrać centrum.
Wybierz z listy pozycję Zasady dostępu. Należy pamiętać, że dostępne są dwa parametry połączenia. Będą one potrzebne później do obsługi powiadomień wypychanych.

Ważne

Nie używaj zasad DefaultFullSharedAccessSignature w aplikacji. Jest to przeznaczone tylko do użycia w zapleczu.

Konfigurowanie centrum powiadomień przy użyciu informacji o usłudze APNs

W obszarze Usługi powiadomień wybierz pozycję Apple (APNS), a następnie wykonaj odpowiednie kroki na podstawie podejścia wybranego wcześniej w sekcji Tworzenie certyfikatu dla usługi Notification Hubs .

Uwaga

Użyj trybu produkcyjnego dla aplikacji tylko wtedy, gdy chcesz wysyłać powiadomienia wypychane do użytkowników, którzy kupili aplikację ze sklepu.

OPCJA 1: Używanie certyfikatu wypychania p12

Wybierz pozycję Certyfikat.
Wybierz ikonę pliku.
Wybierz wyeksportowany wcześniej plik p12, a następnie wybierz pozycję Otwórz.
W razie potrzeby określ poprawne hasło.
Wybierz tryb Piaskownica.
Wybierz pozycję Zapisz.

OPCJA 2. Korzystanie z uwierzytelniania opartego na tokenach

Wybierz pozycję Token.
Wprowadź następujące wartości, które uzyskano wcześniej:
- Identyfikator klucza
- Identyfikator pakietu
- Identyfikator zespołu
- Token
Wybieranie piaskownicy
Wybierz pozycję Zapisz.

Centrum powiadomień skonfigurowano teraz za pomocą usługi APNs. Istnieją również parametry połączenia do zarejestrowania aplikacji i wysyłania powiadomień wypychanych.

Konfigurowanie centrum powiadomień dla usługi APNS

Na komputerze Mac uruchom program Keychain Access. Na lewym pasku nawigacyjnym w obszarze Kategoria otwórz pozycję Moje certyfikaty. Znajdź certyfikat SSL pobrany w poprzedniej sekcji, a następnie ujawnij jego zawartość. Wybierz tylko certyfikat (nie wybieraj klucza prywatnego). Następnie wyeksportuj go.
W Azure Portal wybierz pozycję Przeglądaj wszystkie>usługi App Services. Następnie wybierz zaplecze usługi Mobile Apps.
W obszarze Ustawienia wybierz pozycję App Service Wypychanie. Następnie wybierz nazwę centrum powiadomień.
Przejdź do pozycji Apple Push Notification ServicesUpload Certificate (Przekazywanie certyfikatuusług> powiadomień wypychanych firmy Apple). Przekaż plik .p12, wybierając prawidłowy tryb (w zależności od tego, czy certyfikat SSL klienta z wcześniejszej wersji jest produkcyjny, czy piaskownica). Zapisz wszelkie zmiany.

Twoja usługa jest teraz skonfigurowana do pracy z powiadomieniami wypychanymi w systemie iOS.

Następnie skonfigurujesz ustawienie projektu systemu iOS w programie Xamarin Studio lub Visual Studio.

Konfigurowanie projektu systemu iOS w programie Xamarin Studio

W programie Xamarin.Studio otwórz plik Info.plist i zaktualizuj identyfikator pakietu przy użyciu identyfikatora pakietu utworzonego wcześniej przy użyciu nowego identyfikatora aplikacji.
Przewiń w dół do pozycji Tryby tła. Zaznacz pole Włącz tryby tła i pole Powiadomienia zdalne .
Kliknij dwukrotnie projekt w panelu rozwiązania, aby otworzyć opcje projektu.
W obszarze Kompilacja wybierz pozycję Podpisywanie pakietu systemu iOS i wybierz odpowiedni profil tożsamości i aprowizacji, który właśnie skonfigurowaliśmy dla tego projektu.

Gwarantuje to, że projekt używa nowego profilu do podpisywania kodu. Oficjalna dokumentacja aprowizacji urządzeń platformy Xamarin można znaleźć w artykule Xamarin Device Provisioning (Aprowizowanie urządzeń platformy Xamarin).

Konfigurowanie projektu systemu iOS w programie Visual Studio

W programie Visual Studio kliknij prawym przyciskiem myszy projekt, a następnie kliknij polecenie Właściwości.
Na stronach właściwości kliknij kartę Aplikacja systemu iOS i zaktualizuj identyfikator przy użyciu utworzonego wcześniej identyfikatora.
Na karcie Podpisywanie pakietu systemu iOS wybierz odpowiedni profil tożsamości i aprowizacji, który właśnie skonfigurowaliśmy dla tego projektu.

Gwarantuje to, że projekt używa nowego profilu do podpisywania kodu. Oficjalna dokumentacja aprowizacji urządzeń platformy Xamarin można znaleźć w artykule Xamarin Device Provisioning (Aprowizowanie urządzeń platformy Xamarin).
Kliknij dwukrotnie plik Info.plist, aby go otworzyć, a następnie włącz opcje RemoteNotifications w obszarze Tryby tła.

Dodawanie powiadomień wypychanych do aplikacji systemu iOS

W projekcie systemu iOS otwórz plik AppDelegate.cs i dodaj następującą instrukcję na początku pliku kodu.
```
using Newtonsoft.Json.Linq;
```

W klasie AppDelegate dodaj przesłonięcia dla zdarzenia RegisteredForRemoteNotifications , aby zarejestrować się w celu otrzymywania powiadomień:

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

W usłudze AppDelegate dodaj również następujące zastąpienie programu obsługi zdarzeń DidReceiveRemoteNotification :

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

Ta metoda obsługuje powiadomienia przychodzące, gdy aplikacja jest uruchomiona.

W klasie AppDelegate dodaj następujący kod do metody FinishedLaunching :

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

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

Umożliwia to obsługę powiadomień zdalnych i żądań rejestracji wypychanych.

Aplikacja jest teraz aktualizowana w celu obsługi powiadomień wypychanych.

Testowanie powiadomień wypychanych w aplikacji systemu iOS

Kliknij prawym przyciskiem myszy projekt systemu iOS, a następnie kliknij polecenie Ustaw jako projekt startowy.
Naciśnij przycisk Uruchom lub klawisz F5 w programie Visual Studio, aby skompilować projekt i uruchomić aplikację na urządzeniu z systemem iOS. Następnie kliknij przycisk OK , aby zaakceptować powiadomienia wypychane.

Uwaga

Musisz jawnie zaakceptować powiadomienia wypychane z aplikacji. To żądanie występuje tylko przy pierwszym uruchomieniu aplikacji.
W aplikacji wpisz zadanie, a następnie kliknij ikonę znaku plus (+).
Sprawdź, czy odebrano powiadomienie, a następnie kliknij przycisk OK , aby odrzucić powiadomienie.

Konfigurowanie i uruchamianie projektów systemu Windows (opcjonalnie)

Ta sekcja dotyczy uruchamiania projektów Xamarin.Forms WinApp i WinPhone81 dla urządzeń z systemem Windows. Te kroki obsługują również projekty platforma uniwersalna systemu Windows (UWP). Jeśli nie pracujesz z urządzeniami z systemem Windows, możesz pominąć tę sekcję.

Rejestrowanie aplikacji systemu Windows na potrzeby powiadomień wypychanych za pomocą usługi powiadomień systemu Windows (WNS)

W programie Visual Studio Eksplorator rozwiązań kliknij prawym przyciskiem myszy projekt aplikacji Ze Sklepu Windows. Następnie wybierz pozycjęStore Associate App with the Store (Skojarz aplikację ze sklepem>) ze sklepem.
W kreatorze wybierz pozycję Dalej. Następnie zaloguj się przy użyciu konta Microsoft. W obszarze Zarezerwuj nową nazwę aplikacji wpisz nazwę aplikacji, a następnie wybierz pozycję Zarezerwuj.
Po pomyślnym utworzeniu rejestracji aplikacji wybierz nową nazwę aplikacji. Wybierz przycisk Dalej, a następnie wybierz pozycję Skojarz. Ten proces dodaje wymagane informacje o rejestracji w Sklepie Windows do manifestu aplikacji.
Powtórz kroki 1 i 3 dla projektu aplikacji ze sklepu Windows Phone Store przy użyciu tej samej rejestracji, która została wcześniej utworzona dla aplikacji Ze Sklepu Windows.
Przejdź do Centrum deweloperów systemu Windows, a następnie zaloguj się przy użyciu konta Microsoft. W obszarze Moje aplikacje wybierz nową rejestrację aplikacji. Następnie rozwiń węzeł Powiadomieniawypychaneusług>.
Na stronie Powiadomienia wypychane w obszarze Windows Push Notification Services (WNS) i Microsoft Azure Mobile Apps wybierz pozycję Witryna usług live. Zanotuj wartości identyfikatora SID pakietu i bieżącą wartość w kluczu tajnym aplikacji.

Ważne

Klucz tajny aplikacji i identyfikator SID pakietu są ważnymi poświadczeniami zabezpieczeń. Nie udostępniaj tych wartości nikomu ani nie rozpowszechniaj ich w aplikacji.

Konfigurowanie centrum powiadomień dla usługi WNS

W Azure Portal wybierz pozycję Przeglądaj wszystkie>usługi App Services. Następnie wybierz zaplecze usługi Mobile Apps. W obszarze Ustawienia wybierz pozycję App Service Wypychanie. Następnie wybierz nazwę centrum powiadomień.
Przejdź do systemu Windows (WNS). Następnie wprowadź klucz zabezpieczeń (klucz tajny klienta) i identyfikator SID pakietu uzyskany z lokacji usług live. Następnie wybierz pozycję Zapisz.

Zaplecze jest teraz skonfigurowane do wysyłania powiadomień wypychanych przy użyciu usługi WNS.

Dodawanie powiadomień wypychanych do aplikacji systemu Windows

W programie Visual Studio otwórz plik App.xaml.cs w projekcie systemu Windows i dodaj następujące instrukcje.
```
using Newtonsoft.Json.Linq;
using Microsoft.WindowsAzure.MobileServices;
using System.Threading.Tasks;
using Windows.Networking.PushNotifications;
using <your_TodoItemManager_portable_class_namespace>;
```
Zastąp <your_TodoItemManager_portable_class_namespace> element przestrzenią nazw przenośnego projektu, który zawiera klasę TodoItemManager .

W pliku App.xaml.cs dodaj następującą metodę InitNotificationsAsync :

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

Ta metoda pobiera kanał powiadomień wypychanych i rejestruje szablon w celu odbierania powiadomień szablonu z centrum powiadomień. Powiadomienie o szablonie obsługujące funkcję messageParam zostanie dostarczone do tego klienta.

W pliku App.xaml.cs zaktualizuj definicję metody obsługi zdarzeń OnLaunched , dodając async modyfikator. Następnie dodaj następujący wiersz kodu na końcu metody :
```
await InitNotificationsAsync();
```
Dzięki temu rejestracja powiadomień wypychanych jest tworzona lub odświeżana za każdym razem, gdy aplikacja zostanie uruchomiona. Należy to zrobić, aby zagwarantować, że kanał wypychania WNS jest zawsze aktywny.
W Eksplorator rozwiązań dla programu Visual Studio otwórz plik Package.appxmanifest i ustaw opcję Obsługa wyskakowania na wartość Tak w obszarze Powiadomienia.
Skompiluj aplikację i sprawdź, czy nie występują błędy. Aplikacja kliencka powinna teraz rejestrować się w celu otrzymywania powiadomień szablonu z zaplecza usługi Mobile Apps. Powtórz tę sekcję dla każdego projektu systemu Windows w rozwiązaniu.

Testowanie powiadomień wypychanych w aplikacji systemu Windows

W programie Visual Studio kliknij prawym przyciskiem myszy projekt systemu Windows, a następnie kliknij polecenie Ustaw jako projekt startowy.
Kliknij przycisk Uruchom, aby skompilować projekt i uruchomić aplikację.
W aplikacji wpisz nazwę nowego dokumentu, a następnie kliknij ikonę plusa (+), aby ją dodać.
Sprawdź, czy po dodaniu elementu otrzymano powiadomienie.

Następne kroki

Możesz dowiedzieć się więcej o powiadomieniach wypychanych:

Wysyłanie powiadomień wypychanych z usługi Azure Mobile Apps
Firebase Cloud Messaging
Powiadomienia zdalne z usługą Firebase Cloud Messaging
Diagnozowanie problemów z powiadomieniami wypychanych
Istnieją różne przyczyny, dla których powiadomienia mogą zostać porzucone lub nie są wyświetlane na urządzeniach. W tym temacie pokazano, jak analizować i ustalić główną przyczynę niepowodzeń powiadomień wypychanych.

Możesz również przejść do jednego z następujących samouczków:

Dodawanie uwierzytelniania do aplikacji
Dowiedz się, jak uwierzytelniać użytkowników aplikacji przy użyciu dostawcy tożsamości.
Włączanie synchronizacji w trybie offline dla aplikacji
Dowiedz się, jak dodać obsługę aplikacji w trybie offline przy użyciu zaplecza funkcji Mobile Apps. Dzięki synchronizacji w trybie offline użytkownicy mogą wchodzić w interakcje z aplikacją mobilną — wyświetlać, dodawać lub modyfikować dane — nawet wtedy, gdy nie ma połączenia sieciowego.