Samouczek: wysyłanie powiadomień wypychanych do aplikacji platformy Xamarin.Forms przy użyciu usługi Azure Notification Hubs za pośrednictwem usługi zaplecza

Artykuł
07/27/2020

W tym samouczku użyjesz usługi Azure Notification Hubs do wypychania powiadomień do aplikacji platformy Xamarin.Forms przeznaczonej dla systemów Android i iOS.

Zaplecze internetowego interfejsu API ASP.NET Core służy do obsługi rejestracji urządzeń dla klienta przy użyciu najnowszego i najlepszego podejścia do instalacji. Usługa będzie również wysyłać powiadomienia wypychane w sposób międzyplatformowy.

Te operacje są obsługiwane przy użyciu zestawu SDK usługi Notification Hubs na potrzeby operacji zaplecza. Więcej szczegółowych informacji na temat ogólnego podejścia znajduje się w dokumentacji rejestrowania z zaplecza aplikacji .

Ten samouczek przeprowadzi Cię przez następujące kroki:

Konfigurowanie usług powiadomień wypychanych i usługi Azure Notification Hubs.
Utwórz aplikację zaplecza internetowego interfejsu API ASP.NET Core.
Utwórz międzyplatformową aplikację platformy Xamarin.Forms.
Skonfiguruj natywny projekt systemu Android pod kątem powiadomień wypychanych.
Skonfiguruj natywny projekt systemu iOS pod kątem powiadomień wypychanych.
Przetestuj rozwiązanie.

Wymagania wstępne

Aby postępować zgodnie z instrukcjami, wymagane są następujące elementy:

Subskrypcja platformy Azure, w której można tworzyć zasoby i zarządzać nimi.
Komputer Mac z zainstalowanym Visual Studio dla komputerów Mac lub komputerem z programem Visual Studio 2019.
Użytkownicy programu Visual Studio 2019 muszą również mieć zainstalowane aplikacje mobilne za pomocą platformy .NETi ASP.NET oraz obciążeń tworzenia aplikacji internetowych.
Możliwość uruchamiania aplikacji na urządzeniach z systemem Android (fizycznym lub emulatorze) lub iOS (tylko urządzenia fizyczne).

W przypadku systemu Android musisz mieć następujące elementy:

Deweloper odblokowane urządzenie fizyczne lub emulator (z zainstalowanym interfejsem API 26 lub nowszym z zainstalowanymi usługami Google Play).

W przypadku systemu iOS musisz mieć następujące elementy:

Aktywne konto dewelopera firmy Apple.
Fizyczne urządzenie z systemem iOS zarejestrowane na koncie dewelopera(z systemem iOS 13.0 lub nowszym).
Certyfikat dewelopera.p12 zainstalowany w pęku kluczy umożliwiający uruchamianie aplikacji na urządzeniu fizycznym.

Uwaga

Symulator systemu iOS nie obsługuje powiadomień zdalnych, dlatego urządzenie fizyczne jest wymagane podczas eksplorowania tego przykładu w systemie iOS. Jednak nie musisz uruchamiać aplikacji zarówno w systemach Android , jak i iOS , aby ukończyć ten samouczek.

Możesz wykonać kroki opisane w tym przykładzie pierwszej zasady bez wcześniejszego doświadczenia. Jednak skorzystasz z znajomości następujących aspektów.

Ważne

Podane kroki są specyficzne dla Visual Studio dla komputerów Mac. Istnieje możliwość skorzystania z programu Visual Studio 2019 , ale może istnieć pewne różnice, które należy uzgodnić. Na przykład opisy interfejsu użytkownika i przepływów pracy, nazwy szablonów, konfiguracja środowiska itd.

Konfigurowanie usług powiadomień wypychanych i usługi Azure Notification Hub

W tej sekcji skonfigurujesz usługę Firebase Cloud Messaging (FCM) i Apple Push Notification Services (APNS). Następnie utworzysz i skonfigurujesz centrum powiadomień do pracy z tymi usługami.

Tworzenie projektu Firebase i włączanie usługi Firebase Cloud Messaging dla systemu Android

Zaloguj się do konsoli Firebase. Utwórz nowy projekt Firebase wprowadzający wartość PushDemo jako nazwę projektu.

Uwaga

Zostanie wygenerowana unikatowa nazwa. Domyślnie składa się z małego wariantu podanej nazwy oraz wygenerowanej liczby rozdzielonej kreską. Możesz to zmienić, jeśli chcesz podać, że jest ona nadal globalnie unikatowa.
Po utworzeniu projektu wybierz pozycję Dodaj aplikację Firebase do 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 wprowadź nazwę pakietu. Na przykład: com.<organization_identifier>.<package_name>.
2. Wybierz pozycję Zarejestruj aplikację.
3. Wybierz pozycję Pobierz google-services.json. Następnie zapisz plik w folderze lokalnym do późniejszego użycia i wybierz przycisk Dalej.
4. Wybierz pozycję Dalej.
5. Wybierz pozycję Kontynuuj do konsoli
  
  Uwaga
  
  Jeśli przycisk Kontynuuj do konsoli nie jest włączony, ze względu na sprawdzanie poprawności instalacji wybierz pozycję Pomiń ten krok.
W konsoli Firebase wybierz koła zębatego dla projektu. Następnie wybierz pozycję Ustawienia projektu.

Uwaga

Jeśli nie pobrano pliku google-services.json , możesz go pobrać 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 powiadomień.

Rejestrowanie aplikacji dla systemu iOS na potrzeby 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, przejdź do pozycji Certyfikaty, Identyfikatory & Profile, a następnie wybierz pozycję Identyfikatory. Kliknij + , 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 com.organization_identifier<>.<>product_name, jak wspomniano w przewodniku dystrybucji aplikacji. Na poniższym zrzucie ekranu mobcat wartość jest używana jako identyfikator organizacji, a wartość PushDemo jest używana jako nazwa produktu.
- 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ź utworzony element wiersza identyfikatora aplikacji. Następnie wybierz jego wiersz, aby wyświetlić ekran Edytuj konfigurację identyfikatora aplikacji .

Tworzenie certyfikatu dla usługi Notification Hubs

Certyfikat jest wymagany, aby umożliwić centrum powiadomień pracę z usługami Apple Push Notification Services (APNS) i może być udostępniany na jeden z dwóch sposobów:

Tworzenie certyfikatu wypychania p12, który można przekazać bezpośrednio do usługi Notification Hub (oryginalne podejście)
Tworzenie certyfikatu p8, który może być używany do uwierzytelniania opartego na tokenach (nowsze i zalecane podejście)

Nowsze podejście ma wiele korzyści opisanych w artykule Uwierzytelnianie oparte na tokenach (HTTP/2) dla usługi APNS. Wymagana jest mniejsza liczba kroków, ale jest również wymagana w przypadku określonych scenariuszy. Jednak dla obu metod podano kroki, ponieważ oba te metody będą działać na potrzeby tego samouczka.

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

Na komputerze Mac uruchom narzędzie Keychain Access. Można go otworzyć z folderu Utilities lub innego folderu na launchpad.
Wybierz pozycję Dostęp do pęku kluczy, rozwiń węzeł Asystent certyfikatu, 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 , a urząd certyfikacji Apple Worldwide Developer Relations 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 deweloperów firmy Apple .
Wybierz swój adres Email użytkownika, wprowadź wartość nazwy pospolitej, 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 żądania podpisania certyfikatu (CSR) w obszarze Zapisz jako, wybierz lokalizację w obszarze Gdzie, a następnie wybierz pozycję Zapisz.

Ta akcja powoduje zapisanie pliku CSR w wybranej lokalizacji. Domyślną lokalizacją jest Desktop. Zapamiętaj lokalizację wybraną dla pliku.
Wróć do strony Certyfikaty, Identyfikatory & Profile w portalu aprowizacji systemu iOS, przewiń w dół do zaznaczonej opcji Powiadomienia wypychane , a następnie wybierz pozycję Konfiguruj , aby utworzyć certyfikat.
Zostanie wyświetlone okno Certyfikaty TLS/SSL usługi Apple Push Notification Service . Wybierz przycisk Utwórz certyfikat w sekcji Tworzenie certyfikatu TLS/SSL .

Zostanie wyświetlony ekran Tworzenie nowego certyfikatu .

Uwaga

W tym samouczku jest używany certyfikat dewelopera. Ten sam proces jest używany podczas rejestrowania certyfikatu produkcyjnego. Podczas wysyłania powiadomień upewnij się, że używasz tego samego typu certyfikatu.
Wybierz pozycję Wybierz plik, przejdź do lokalizacji, w której zapisano plik CSR, a następnie kliknij dwukrotnie nazwę certyfikatu, aby go załadować. Następnie wybierz pozycję Kontynuuj.
Po utworzeniu certyfikatu w portalu 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 wypychania aps_development.cer. Ta akcja powoduje zainstalowanie nowego certyfikatu w łańcucha kluczy, jak pokazano na poniższej ilustracji:

Uwaga

Mimo że nazwa w certyfikacie może być inna, nazwa będzie poprzedzona usługami Apple Development iOS Push Services i ma skojarzony z nim odpowiedni identyfikator pakietu.
W obszarze Dostęp do pęku kluczy kliknij + nowy certyfikat wypychania 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 hasło jest 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ą usługi 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 (identyfikator zespołu)
- Identyfikator pakietu
Po powrocie do pozycji Certyfikaty identyfikatory & profilów 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ść nazwa 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 utworzony klucz (lub istniejący klucz, jeśli chcesz go użyć).
Zanotuj wartość identyfikatora klucza .
Otwórz certyfikat p8 w wybranej aplikacji, takiej jak Visual Studio Code. Zanotuj wartość klucza (między kluczem prywatnym -----BEGIN----- a -----END PRIVATE KEY-----).

-----BEGIN KLUCZ PRYWATNY-----
<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 usługi APNS:

Identyfikator zespołu (zobacz krok 1)
Identyfikator pakietu (zobacz krok 1)
Identyfikator klucza (zobacz krok 7)
Wartość tokenu (wartość klucza p8 uzyskana w kroku 8)

Tworzenie profilu aprowizacji 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 pozycję + , aby utworzyć nowy profil. Zostanie wyświetlony ekran Rejestrowanie nowego profilu aprowizacji .
Wybierz pozycję Tworzenie aplikacji 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.

Uwaga

Ten certyfikat nie jest certyfikatem wypychania utworzonym w poprzednim kroku. Jest to certyfikat dewelopera. Jeśli nie istnieje, musisz go utworzyć, ponieważ jest to wymaganie wstępne dla tego samouczka. Certyfikaty dla deweloperów można tworzyć w portalu dla deweloperów firmy Apple za pośrednictwem programu Xcode lub w programie Visual Studio.
Wróć do strony Certyfikaty, Identyfikatory & Profile , wybierz pozycję Profile z menu po lewej stronie, a następnie wybierz pozycję + , aby utworzyć nowy profil. Zostanie wyświetlony ekran Rejestrowanie nowego profilu aprowizacji .
W oknie Wybieranie certyfikatów wybierz 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 komputerze deweloperskim.

Tworzenie centrum powiadomień

W tej sekcji utworzysz centrum powiadomień i skonfigurujesz uwierzytelnianie za pomocą usługi APNS. Można użyć certyfikatu wypychania p12 lub uwierzytelniania opartego na tokenach. Jeśli chcesz użyć centrum powiadomień, które zostało już utworzone, możesz przejść do kroku 5.

Zaloguj się do platformy Azure.
Kliknij pozycję Utwórz zasób, a następnie wyszukaj i wybierz pozycję Centrum powiadomień, a następnie kliknij pozycję Utwórz.
Zaktualizuj następujące pola, a następnie kliknij pozycję Utwórz:

PODSTAWOWE SZCZEGÓŁY

Subskrypcji: Wybierz docelową subskrypcję z listy rozwijanej
Grupa zasobów: Utwórz nową grupę zasobów (lub wybierz istniejącą)

SZCZEGÓŁY PRZESTRZENI NAZW

Przestrzeń nazw centrum powiadomień: Wprowadź globalnie unikatową nazwę przestrzeni nazw centrum powiadomień

Uwaga

Upewnij się, że dla tego pola wybrano opcję Utwórz nową .

SZCZEGÓŁY CENTRUM POWIADOMIEŃ

Centrum powiadomień: Wprowadź nazwę centrum powiadomień
Lokalizacji: Wybierz odpowiednią lokalizację z listy rozwijanej
Warstwa cenowa: Zachowaj domyślną opcję Bezpłatna

Uwaga

Jeśli nie osiągnięto maksymalnej liczby centrów w warstwie Bezpłatna.
Po aprowizacji centrum powiadomień przejdź do tego zasobu.
Przejdź do nowego centrum powiadomień.
Wybierz pozycję Zasady dostępu z listy (w obszarze ZARZĄDZAJ).
Zanotuj wartości Nazwa zasad wraz z odpowiadającymi im wartościami parametrów połączenia .

Konfigurowanie centrum powiadomień przy użyciu informacji usługi APNS

W obszarze Usługi powiadomień wybierz pozycję Apple , 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 pozycję Tryb piaskownicy .
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
- Tokenu
Wybierz pozycję Piaskownica.
Wybierz pozycję Zapisz.

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

Wybierz pozycję Google (GCM/FCM) w sekcji Ustawienia w menu po lewej stronie.
Wprowadź klucz serwera zanotowany w konsoli Google Firebase Console.
Wybierz pozycję Zapisz na pasku narzędzi.

Tworzenie aplikacji zaplecza internetowego interfejsu API ASP.NET Core

W tej sekcji utworzysz zaplecze internetowego interfejsu API ASP.NET Core do obsługi rejestracji urządzeń i wysyłania powiadomień do aplikacji mobilnej platformy Xamarin.Forms.

Tworzenie projektu internetowego

W programie Visual Studio wybierz pozycję Plik>nowe rozwiązanie.
Wybierz pozycjęAplikacja>platformy .NET Core>ASP.NET Core>API>Dalej.
W oknie dialogowym Konfigurowanie nowego interfejsu API sieci Web ASP.NET Core wybierz pozycję Platforma docelowaplatformy .NET Core 3.1.
Wprowadź wartość PushDemoApi w polu Nazwa projektu , a następnie wybierz pozycję Utwórz.
Rozpocznij debugowanie (Klawisz Enter polecenia + ), aby przetestować aplikację szablonu.
Uwaga

Aplikacja szablonu jest skonfigurowana do używania elementu WeatherForecastController jako adresu launchUrl. Jest on ustawiany wlaunchSettings.jsonwłaściwości>.

Jeśli zostanie wyświetlony monit z komunikatem Znaleziono nieprawidłowy certyfikat dewelopera :
1. Kliknij przycisk Tak , aby wyrazić zgodę na uruchomienie narzędzia "dotnet dev-certs https", aby rozwiązać ten problem. Narzędzie "dotnet dev-certs https" wyświetli monit o wprowadzenie hasła do certyfikatu i hasła dla pęku kluczy.
2. Kliknij przycisk Tak po wyświetleniu monitu o zainstalowanie i zaufanie nowemu certyfikatowi, a następnie wprowadź hasło dla pęku kluczy.
Rozwiń folder Controllers , a następnie usuń WeatherForecastController.cs.
Usuń WeatherForecast.cs.
Skonfiguruj lokalne wartości konfiguracji przy użyciu narzędzia Secret Manager. Oddzielenie wpisów tajnych od rozwiązania zapewnia, że nie zostaną one zakończone w kontroli źródła. Otwórz terminal , a następnie przejdź do katalogu pliku projektu i uruchom następujące polecenia:
```
dotnet user-secrets init
dotnet user-secrets set "NotificationHub:Name" <value>
dotnet user-secrets set "NotificationHub:ConnectionString" <value>
```
Zastąp wartości symboli zastępczych własną nazwą centrum powiadomień i wartościami parametry połączenia. Zanotuj je w sekcji tworzenie centrum powiadomień . W przeciwnym razie można je wyszukać na platformie Azure.

NotificationHub:Name:
Zobacz Nazwę w podsumowaniu Podstawy w górnej części sekcji Przegląd.

NotificationHub:ConnectionString:
Zobacz DefaultFullSharedAccessSignature w zasadach dostępu

Uwaga

W przypadku scenariuszy produkcyjnych możesz zapoznać się z opcjami, takimi jak Azure KeyVault, aby bezpiecznie przechowywać parametry połączenia. Dla uproszczenia wpisy tajne zostaną dodane do ustawień aplikacji Azure App Service.

Uwierzytelnianie klientów przy użyciu klucza interfejsu API (opcjonalnie)

Klucze interfejsu API nie są tak bezpieczne jak tokeny, ale wystarczy do celów tego samouczka. Klucz interfejsu API można łatwo skonfigurować za pośrednictwem oprogramowania pośredniczącego ASP.NET.

Dodaj klucz interfejsu API do wartości konfiguracji lokalnej.
```
dotnet user-secrets set "Authentication:ApiKey" <value>
```
Uwaga

Należy zastąpić wartość symbolu zastępczego własną wartością i zanotować ją.
Kontroli + Kliknij projekt PushDemoApi , wybierz pozycję Nowy folder z menu Dodaj , a następnie kliknij pozycję Dodaj przy użyciu uwierzytelniania jako nazwę folderu.
Kontroli + Kliknij folder Authentication (Uwierzytelnianie ), a następnie wybierz pozycję Nowy plik... z menu Dodaj .

Wybierz pozycję Ogólna>pusta klasa, wprowadź ApiKeyAuthOptions.cs w polu Nazwa, a następnie kliknij pozycję Nowy , dodając następującą implementację.

using Microsoft.AspNetCore.Authentication;

namespace PushDemoApi.Authentication
{
    public class ApiKeyAuthOptions : AuthenticationSchemeOptions
    {
        public const string DefaultScheme = "ApiKey";
        public string Scheme => DefaultScheme;
        public string ApiKey { get; set; }
    }
}

Dodaj kolejną pustą klasę do folderu uwierzytelniania o nazwie ApiKeyAuthHandler.cs, a następnie dodaj następującą implementację.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Text.Encodings.Web;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authentication;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;

namespace PushDemoApi.Authentication
{
    public class ApiKeyAuthHandler : AuthenticationHandler<ApiKeyAuthOptions>
    {
        const string ApiKeyIdentifier = "apikey";

        public ApiKeyAuthHandler(
            IOptionsMonitor<ApiKeyAuthOptions> options,
            ILoggerFactory logger,
            UrlEncoder encoder,
            ISystemClock clock)
            : base(options, logger, encoder, clock) {}

        protected override Task<AuthenticateResult> HandleAuthenticateAsync()
        {
            string key = string.Empty;

            if (Request.Headers[ApiKeyIdentifier].Any())
            {
                key = Request.Headers[ApiKeyIdentifier].FirstOrDefault();
            }
            else if (Request.Query.ContainsKey(ApiKeyIdentifier))
            {
                if (Request.Query.TryGetValue(ApiKeyIdentifier, out var queryKey))
                    key = queryKey;
            }

            if (string.IsNullOrWhiteSpace(key))
                return Task.FromResult(AuthenticateResult.Fail("No api key provided"));

            if (!string.Equals(key, Options.ApiKey, StringComparison.Ordinal))
                return Task.FromResult(AuthenticateResult.Fail("Invalid api key."));

            var identities = new List<ClaimsIdentity> {
                new ClaimsIdentity("ApiKeyIdentity")
            };

            var ticket = new AuthenticationTicket(
                new ClaimsPrincipal(identities), Options.Scheme);

            return Task.FromResult(AuthenticateResult.Success(ticket));
        }
    }
}

Uwaga

Program obsługi uwierzytelniania to typ implementujący zachowanie schematu, w tym przypadku niestandardowy schemat klucza interfejsu API.

Dodaj kolejną pustą klasę do folderu uwierzytelniania o nazwie ApiKeyAuthenticationBuilderExtensions.cs, a następnie dodaj następującą implementację.

using System;
using Microsoft.AspNetCore.Authentication;

namespace PushDemoApi.Authentication
{
    public static class AuthenticationBuilderExtensions
    {
        public static AuthenticationBuilder AddApiKeyAuth(
            this AuthenticationBuilder builder,
            Action<ApiKeyAuthOptions> configureOptions)
        {
            return builder
                .AddScheme<ApiKeyAuthOptions, ApiKeyAuthHandler>(
                    ApiKeyAuthOptions.DefaultScheme,
                    configureOptions);
        }
    }
}

Uwaga

Ta metoda rozszerzenia upraszcza kod konfiguracji oprogramowania pośredniczącego w Startup.cs co czyni go bardziej czytelnym i ogólnie łatwiejszym do naśladowania.

W Startup.cs zaktualizuj metodę ConfigureServices , aby skonfigurować uwierzytelnianie klucza interfejsu API poniżej wywołania usług. AddControllers , metoda.

using PushDemoApi.Authentication;
using PushDemoApi.Models;
using PushDemoApi.Services;

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();

    services.AddAuthentication(options =>
    {
        options.DefaultAuthenticateScheme = ApiKeyAuthOptions.DefaultScheme;
        options.DefaultChallengeScheme = ApiKeyAuthOptions.DefaultScheme;
    }).AddApiKeyAuth(Configuration.GetSection("Authentication").Bind);
}

Nadal w Startup.cs zaktualizuj metodę Configure, aby wywołać metody rozszerzenia UseAuthentication i UseAuthorization w aplikacji IApplicationBuilder. Upewnij się, że te metody są wywoływane po użyciu usługi UseRouting i przed aplikacją. Użyj punktów końcowych.
```
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    app.UseHttpsRedirection();

    app.UseRouting();

    app.UseAuthentication();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });
}
```
Uwaga

Wywoływanie metody UseAuthentication rejestruje oprogramowanie pośredniczące, które używa wcześniej zarejestrowanych schematów uwierzytelniania (z usługi ConfigureServices). Należy to wywołać przed każdym oprogramowaniem pośredniczącym, które zależy od uwierzytelnienia użytkowników.

Dodawanie zależności i konfigurowanie usług

ASP.NET Core obsługuje wzorzec projektowania oprogramowania iniekcji zależności (DI), który jest techniką osiągnięcia inwersji kontroli (IoC) między klasami i ich zależnościami.

Korzystanie z centrum powiadomień i zestawu SDK usługi Notification Hubs na potrzeby operacji zaplecza jest hermetyzowane w usłudze. Usługa jest zarejestrowana i udostępniana za pośrednictwem odpowiedniej abstrakcji.

Kontroli + Kliknij folder Zależności , a następnie wybierz pozycję Zarządzaj pakietami NuGet....
Wyszukaj ciąg Microsoft.Azure.NotificationHubs i upewnij się, że jest zaznaczone.
Kliknij pozycję Dodaj pakiety, a następnie kliknij przycisk Akceptuj po wyświetleniu monitu o zaakceptowanie postanowień licencyjnych.
Kontroli + Kliknij projekt PushDemoApi , wybierz pozycję Nowy folder z menu Dodaj , a następnie kliknij pozycję Dodaj przy użyciu modeli jako nazwę folderu.
Kontroli + Kliknij folder Modele , a następnie wybierz pozycję Nowy plik... z menu Dodaj .

Wybierz pozycję Ogólna>pusta klasa, wprowadź PushTemplates.cs w polu Nazwa, a następnie kliknij pozycję Nowy , dodając następującą implementację.

namespace PushDemoApi.Models
{
    public class PushTemplates
    {
        public class Generic
        {
            public const string Android = "{ \"notification\": { \"title\" : \"PushDemo\", \"body\" : \"$(alertMessage)\"}, \"data\" : { \"action\" : \"$(alertAction)\" } }";
            public const string iOS = "{ \"aps\" : {\"alert\" : \"$(alertMessage)\"}, \"action\" : \"$(alertAction)\" }";
        }

        public class Silent
        {
            public const string Android = "{ \"data\" : {\"message\" : \"$(alertMessage)\", \"action\" : \"$(alertAction)\"} }";
            public const string iOS = "{ \"aps\" : {\"content-available\" : 1, \"apns-priority\": 5, \"sound\" : \"\", \"badge\" : 0}, \"message\" : \"$(alertMessage)\", \"action\" : \"$(alertAction)\" }";
        }
    }
}

Uwaga

Ta klasa zawiera tokenizowane ładunki powiadomień dla ogólnych i dyskretnych powiadomień wymaganych przez ten scenariusz. Ładunki są definiowane poza instalacją , aby umożliwić eksperymentowanie bez konieczności aktualizowania istniejących instalacji za pośrednictwem usługi. Obsługa zmian instalacji w ten sposób jest poza zakresem tego samouczka. W przypadku środowiska produkcyjnego rozważ szablony niestandardowe.

Dodaj kolejną pustą klasę do folderu Models o nazwie DeviceInstallation.cs, a następnie dodaj następującą implementację.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace PushDemoApi.Models
{
    public class DeviceInstallation
    {
        [Required]
        public string InstallationId { get; set; }

        [Required]
        public string Platform { get; set; }

        [Required]
        public string PushChannel { get; set; }

        public IList<string> Tags { get; set; } = Array.Empty<string>();
    }
}

Dodaj kolejną pustą klasę do folderu Models o nazwie NotificationRequest.cs, a następnie dodaj następującą implementację.

using System;

namespace PushDemoApi.Models
{
    public class NotificationRequest
    {
        public string Text { get; set; }
        public string Action { get; set; }
        public string[] Tags { get; set; } = Array.Empty<string>();
        public bool Silent { get; set; }
    }
}

Dodaj kolejną pustą klasę do folderu Models o nazwie NotificationHubOptions.cs, a następnie dodaj następującą implementację.

using System.ComponentModel.DataAnnotations;

namespace PushDemoApi.Models
{
    public class NotificationHubOptions
    {
        [Required]
        public string Name { get; set; }

        [Required]
        public string ConnectionString { get; set; }
    }
}

Dodaj nowy folder do projektu PushDemoApi o nazwie Usługi.

Dodaj pusty interfejs do folderu Services o nazwie INotificationService.cs, a następnie dodaj następującą implementację.

using System.Threading;
using System.Threading.Tasks;
using PushDemoApi.Models;

namespace PushDemoApi.Services
{
    public interface INotificationService
    {
        Task<bool> CreateOrUpdateInstallationAsync(DeviceInstallation deviceInstallation, CancellationToken token);
        Task<bool> DeleteInstallationByIdAsync(string installationId, CancellationToken token);
        Task<bool> RequestNotificationAsync(NotificationRequest notificationRequest, CancellationToken token);
    }
}

Dodaj pustą klasę do folderu Services o nazwie NotificationHubsService.cs, a następnie dodaj następujący kod, aby zaimplementować interfejs INotificationService :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Azure.NotificationHubs;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using PushDemoApi.Models;

namespace PushDemoApi.Services
{
    public class NotificationHubService : INotificationService
    {
        readonly NotificationHubClient _hub;
        readonly Dictionary<string, NotificationPlatform> _installationPlatform;
        readonly ILogger<NotificationHubService> _logger;

        public NotificationHubService(IOptions<NotificationHubOptions> options, ILogger<NotificationHubService> logger)
        {
            _logger = logger;
            _hub = NotificationHubClient.CreateClientFromConnectionString(
                options.Value.ConnectionString,
                options.Value.Name);

            _installationPlatform = new Dictionary<string, NotificationPlatform>
            {
                { nameof(NotificationPlatform.Apns).ToLower(), NotificationPlatform.Apns },
                { nameof(NotificationPlatform.Fcm).ToLower(), NotificationPlatform.Fcm }
            };
        }

        public async Task<bool> CreateOrUpdateInstallationAsync(DeviceInstallation deviceInstallation, CancellationToken token)
        {
            if (string.IsNullOrWhiteSpace(deviceInstallation?.InstallationId) ||
                string.IsNullOrWhiteSpace(deviceInstallation?.Platform) ||
                string.IsNullOrWhiteSpace(deviceInstallation?.PushChannel))
                return false;

            var installation = new Installation()
            {
                InstallationId = deviceInstallation.InstallationId,
                PushChannel = deviceInstallation.PushChannel,
                Tags = deviceInstallation.Tags
            };

            if (_installationPlatform.TryGetValue(deviceInstallation.Platform, out var platform))
                installation.Platform = platform;
            else
                return false;

            try
            {
                await _hub.CreateOrUpdateInstallationAsync(installation, token);
            }
            catch
            {
                return false;
            }

            return true;
        }

        public async Task<bool> DeleteInstallationByIdAsync(string installationId, CancellationToken token)
        {
            if (string.IsNullOrWhiteSpace(installationId))
                return false;

            try
            {
                await _hub.DeleteInstallationAsync(installationId, token);
            }
            catch
            {
                return false;
            }

            return true;
        }

        public async Task<bool> RequestNotificationAsync(NotificationRequest notificationRequest, CancellationToken token)
        {
            if ((notificationRequest.Silent &&
                string.IsNullOrWhiteSpace(notificationRequest?.Action)) ||
                (!notificationRequest.Silent &&
                (string.IsNullOrWhiteSpace(notificationRequest?.Text)) ||
                string.IsNullOrWhiteSpace(notificationRequest?.Action)))
                return false;

            var androidPushTemplate = notificationRequest.Silent ?
                PushTemplates.Silent.Android :
                PushTemplates.Generic.Android;

            var iOSPushTemplate = notificationRequest.Silent ?
                PushTemplates.Silent.iOS :
                PushTemplates.Generic.iOS;

            var androidPayload = PrepareNotificationPayload(
                androidPushTemplate,
                notificationRequest.Text,
                notificationRequest.Action);

            var iOSPayload = PrepareNotificationPayload(
                iOSPushTemplate,
                notificationRequest.Text,
                notificationRequest.Action);

            try
            {
                if (notificationRequest.Tags.Length == 0)
                {
                    // This will broadcast to all users registered in the notification hub
                    await SendPlatformNotificationsAsync(androidPayload, iOSPayload, token);
                }
                else if (notificationRequest.Tags.Length <= 20)
                {
                    await SendPlatformNotificationsAsync(androidPayload, iOSPayload, notificationRequest.Tags, token);
                }
                else
                {
                    var notificationTasks = notificationRequest.Tags
                        .Select((value, index) => (value, index))
                        .GroupBy(g => g.index / 20, i => i.value)
                        .Select(tags => SendPlatformNotificationsAsync(androidPayload, iOSPayload, tags, token));

                    await Task.WhenAll(notificationTasks);
                }

                return true;
            }
            catch (Exception e)
            {
                _logger.LogError(e, "Unexpected error sending notification");
                return false;
            }
        }

        string PrepareNotificationPayload(string template, string text, string action) => template
            .Replace("$(alertMessage)", text, StringComparison.InvariantCulture)
            .Replace("$(alertAction)", action, StringComparison.InvariantCulture);

        Task SendPlatformNotificationsAsync(string androidPayload, string iOSPayload, CancellationToken token)
        {
            var sendTasks = new Task[]
            {
                _hub.SendFcmNativeNotificationAsync(androidPayload, token),
                _hub.SendAppleNativeNotificationAsync(iOSPayload, token)
            };

            return Task.WhenAll(sendTasks);
        }

        Task SendPlatformNotificationsAsync(string androidPayload, string iOSPayload, IEnumerable<string> tags, CancellationToken token)
        {
            var sendTasks = new Task[]
            {
                _hub.SendFcmNativeNotificationAsync(androidPayload, tags, token),
                _hub.SendAppleNativeNotificationAsync(iOSPayload, tags, token)
            };

            return Task.WhenAll(sendTasks);
        }
    }
}

Uwaga

Wyrażenie tagu dostarczone do funkcji SendTemplateNotificationAsync jest ograniczone do 20 tagów. Jest ona ograniczona do 6 dla większości operatorów, ale wyrażenie zawiera tylko jednostki ORS (||) w tym przypadku. Jeśli w żądaniu znajduje się więcej niż 20 tagów, należy je podzielić na wiele żądań. Aby uzyskać więcej informacji, zobacz dokumentację routingu i wyrażeń tagów .

W Startup.cs zaktualizuj metodę ConfigureServices , aby dodać usługę NotificationHubsService jako pojedynczą implementację usługi INotificationService.


using PushDemoApi.Models;
using PushDemoApi.Services;

public void ConfigureServices(IServiceCollection services)
{
    ...

    services.AddSingleton<INotificationService, NotificationHubService>();

    services.AddOptions<NotificationHubOptions>()
        .Configure(Configuration.GetSection("NotificationHub").Bind)
        .ValidateDataAnnotations();
}

Tworzenie interfejsu API powiadomień

Kontroli + Kliknij folder Kontrolery , a następnie wybierz pozycję Nowy plik... z menu Dodaj .
Wybierz pozycję ASP.NET Core>Nazwa kontrolera interfejsu APIWeb, wprowadź NotificationsController jako nazwę, a następnie kliknij przycisk Nowy.

Uwaga

Jeśli korzystasz z programu Visual Studio 2019, wybierz kontroler interfejsu API z szablonem akcji odczytu/zapisu .

Dodaj następujące przestrzenie nazw w górnej części pliku.

using System.ComponentModel.DataAnnotations;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using PushDemoApi.Models;
using PushDemoApi.Services;

Zaktualizuj szablonowy kontroler, aby pochodził z kontroleraBase i został ozdobiony atrybutem ApiController .
```
[ApiController]
[Route("api/[controller]")]
public class NotificationsController : ControllerBase
{
    // Templated methods here
}
```
Uwaga

Klasa podstawowa Controller zapewnia obsługę widoków, ale nie jest to konieczne w tym przypadku, dlatego zamiast tego można użyć klasy ControllerBase . Jeśli korzystasz z programu Visual Studio 2019, możesz pominąć ten krok.
Jeśli zdecydujesz się ukończyć sekcję Uwierzytelnianie klientów przy użyciu klucza interfejsu API , należy również udekorować element NotificationsController z atrybutem Autoryzacja .
```
[Authorize]
```

Zaktualizuj konstruktor, aby akceptował zarejestrowane wystąpienie usługi INotificationService jako argument i przypisz go do elementu członkowskiego readonly.

readonly INotificationService _notificationService;

public NotificationsController(INotificationService notificationService)
{
    _notificationService = notificationService;
}

W launchSettings.json (w folderze Właściwości) zmień element launchUrl z weatherforecast na api/notifications, aby dopasować adres URL określony w atrybucie RouteRegistrationsController.
Rozpocznij debugowanie (Klawisz Enterpolecenia + ), aby sprawdzić, czy aplikacja współpracuje z nowym elementem NotificationsController i zwraca stan 401 Brak autoryzacji.

Uwaga

Program Visual Studio może nie uruchamiać automatycznie aplikacji w przeglądarce. Użyjesz narzędzia Postman do przetestowania interfejsu API od tego momentu.
Na nowej karcie Postman ustaw żądanie na GET. Wprowadź poniższy adres zastępując symbol zastępczy <applicationUrl ciągiem>https applicationUrl znalezionym w obszarze Właściwości>launchSettings.json.
```
<applicationUrl>/api/notifications
```
Uwaga

Element applicationUrl powinien mieć wartość "https://localhost:5001" dla profilu domyślnego. Jeśli używasz usług IIS (domyślnie w programie Visual Studio 2019 w systemie Windows), należy zamiast tego użyć elementu applicationUrl określonego w elemencie iisSettings . Jeśli adres jest nieprawidłowy, otrzymasz odpowiedź 404.
Jeśli wybrano ukończenie sekcji Uwierzytelnianie klientów przy użyciu klucza interfejsu API , pamiętaj o skonfigurowaniu nagłówków żądań w celu uwzględnienia wartości klucza apikey .

Klucz Wartość

apikey <your_api_key>
Kliknij przycisk Wyślij .

Uwaga

Powinien zostać wyświetlony stan 200 OK z zawartością JSON .

Jeśli zostanie wyświetlone ostrzeżenie o weryfikacji certyfikatu SSL , możesz przełączyć żądanie weryfikacji certyfikatu SSL Postman w obszarze Ustawienia.

Klucz	Wartość
apikey	<your_api_key>

Zastąp metody klas szablonów w NotificationsController.cs następującym kodem.

[HttpPut]
[Route("installations")]
[ProducesResponseType((int)HttpStatusCode.OK)]
[ProducesResponseType((int)HttpStatusCode.BadRequest)]
[ProducesResponseType((int)HttpStatusCode.UnprocessableEntity)]
public async Task<IActionResult> UpdateInstallation(
    [Required]DeviceInstallation deviceInstallation)
{
    var success = await _notificationService
        .CreateOrUpdateInstallationAsync(deviceInstallation, HttpContext.RequestAborted);

    if (!success)
        return new UnprocessableEntityResult();

    return new OkResult();
}

[HttpDelete()]
[Route("installations/{installationId}")]
[ProducesResponseType((int)HttpStatusCode.OK)]
[ProducesResponseType((int)HttpStatusCode.BadRequest)]
[ProducesResponseType((int)HttpStatusCode.UnprocessableEntity)]
public async Task<ActionResult> DeleteInstallation(
    [Required][FromRoute]string installationId)
{
    var success = await _notificationService
        .DeleteInstallationByIdAsync(installationId, CancellationToken.None);

    if (!success)
        return new UnprocessableEntityResult();

    return new OkResult();
}

[HttpPost]
[Route("requests")]
[ProducesResponseType((int)HttpStatusCode.OK)]
[ProducesResponseType((int)HttpStatusCode.BadRequest)]
[ProducesResponseType((int)HttpStatusCode.UnprocessableEntity)]
public async Task<IActionResult> RequestPush(
    [Required]NotificationRequest notificationRequest)
{
    if ((notificationRequest.Silent &&
        string.IsNullOrWhiteSpace(notificationRequest?.Action)) ||
        (!notificationRequest.Silent &&
        string.IsNullOrWhiteSpace(notificationRequest?.Text)))
        return new BadRequestResult();

    var success = await _notificationService
        .RequestNotificationAsync(notificationRequest, HttpContext.RequestAborted);

    if (!success)
        return new UnprocessableEntityResult();

    return new OkResult();
}

Tworzenie aplikacji interfejsu API

Teraz utworzysz aplikację interfejsu API w Azure App Service do hostowania usługi zaplecza.

Zaloguj się do Azure Portal.
Kliknij pozycję Utwórz zasób, a następnie wyszukaj i wybierz pozycję Aplikacja interfejsu API, a następnie kliknij pozycję Utwórz.
Zaktualizuj następujące pola, a następnie kliknij przycisk Utwórz.

Nazwa aplikacji:
Wprowadź globalnie unikatową nazwę aplikacji interfejsu API

Subskrypcji:
Wybierz tę samą docelową subskrypcję , w której utworzono centrum powiadomień.

Grupa zasobów:
Wybierz tę samą grupę zasobów utworzoną w centrum powiadomień.

plan/lokalizacja App Service:
Tworzenie nowego planu App Service

Uwaga

Zmień opcję domyślną na plan obejmujący obsługę protokołu SSL . W przeciwnym razie należy wykonać odpowiednie kroki podczas pracy z aplikacją mobilną, aby uniemożliwić zablokowanie żądań http .

Application Insights:
Zachowaj sugerowaną opcję (nowy zasób zostanie utworzony przy użyciu tej nazwy) lub wybierz istniejący zasób.
Po aprowizacji aplikacji interfejsu API przejdź do tego zasobu.
Zanotuj właściwość ADRESU URL w podsumowaniu Podstawy w górnej części przeglądu. Ten adres URL to punkt końcowy zaplecza , który będzie używany w dalszej części tego samouczka.

Uwaga

Adres URL używa podanej wcześniej nazwy aplikacji interfejsu API z formatem https://<app_name>.azurewebsites.net.
Wybierz pozycję Konfiguracja z listy (w obszarze Ustawienia).
Dla każdego z poniższych ustawień kliknij pozycję Nowe ustawienie aplikacji , aby wprowadzić nazwę i wartość, a następnie kliknij przycisk OK.

Nazwa Wartość

Authentication:ApiKey <api_key_value>

NotificationHub:Name <hub_name_value>

NotificationHub:ConnectionString <hub_connection_string_value>

Uwaga

Są to te same ustawienia zdefiniowane wcześniej w ustawieniach użytkownika. Powinno być możliwe skopiowanie tych danych. Ustawienie Authentication:ApiKey jest wymagane tylko wtedy, gdy wybrano opcję ukończenia uwierzytelniania klientów przy użyciu sekcji Klucz interfejsu API . W przypadku scenariuszy produkcyjnych możesz zapoznać się z opcjami, takimi jak Azure KeyVault. Zostały one dodane jako ustawienia aplikacji dla uproszczenia w tym przypadku.
Po dodaniu wszystkich ustawień aplikacji kliknij przycisk Zapisz, a następnie kontynuuj.

Nazwa	Wartość
`Authentication:ApiKey`	<api_key_value>
`NotificationHub:Name`	<hub_name_value>
`NotificationHub:ConnectionString`	<hub_connection_string_value>

Publikowanie usługi zaplecza

Następnie wdrożysz aplikację w aplikacji interfejsu API, aby była dostępna ze wszystkich urządzeń.

Uwaga

Poniższe kroki są specyficzne dla Visual Studio dla komputerów Mac. Jeśli korzystasz z programu Visual Studio 2019 w systemie Windows, przepływ publikowania będzie inny. Zobacz Publikowanie w Azure App Service w systemie Windows.

Zmień konfigurację z Debuguj na Wydanie , jeśli jeszcze tego nie zrobiono.
Kontroli + Kliknij projekt PushDemoApi , a następnie wybierz pozycję Publikuj na platformie Azure... z menu Publikuj .
Jeśli zostanie wyświetlony monit, postępuj zgodnie z przepływem uwierzytelniania. Użyj konta użytego w poprzedniej sekcji Tworzenie aplikacji interfejsu API .
Wybierz aplikację interfejsu API Azure App Service utworzoną wcześniej z listy jako element docelowy publikowania, a następnie kliknij pozycję Publikuj.

Po ukończeniu pracy kreatora publikuje ona aplikację na platformie Azure, a następnie otwiera aplikację. Zanotuj adres URL , jeśli jeszcze tego nie zrobiono. Ten adres URL to punkt końcowy zaplecza używany w dalszej części tego samouczka.

Weryfikowanie opublikowanego interfejsu API

W narzędziu Postman otwórz nową kartę, ustaw żądanie PUT i wprowadź poniższy adres. Zastąp symbol zastępczy adresem podstawowym zanotowanymi w poprzedniej sekcji publikowania usługi zaplecza .
```
https://<app_name>.azurewebsites.net/api/notifications/installations
```
Uwaga

Adres podstawowy powinien być w formacie https://<app_name>.azurewebsites.net/
Jeśli wybrano ukończenie sekcji Uwierzytelnianie klientów przy użyciu klucza interfejsu API , pamiętaj o skonfigurowaniu nagłówków żądań w celu uwzględnienia wartości klucza apikey .

Klucz Wartość

apikey <your_api_key>
Wybierz opcję nieprzetworzoną dla treści, a następnie wybierz pozycję JSON z listy opcji formatowania, a następnie dołącz zawartość JSON symbolu zastępczego:
```
{}
```
Kliknij pozycję Wyślij.

Uwaga

Powinien zostać wyświetlony stan 422 UnprocessableEntity z usługi.
Wykonaj ponownie kroki 1–4, ale tym razem określając punkt końcowy żądań w celu zweryfikowania, czy otrzymasz 400 odpowiedź na nieprawidłowe żądanie .
```
https://<app_name>.azurewebsites.net/api/notifications/requests
```

Klucz	Wartość
apikey	<your_api_key>

Uwaga

Nie można jeszcze przetestować interfejsu API przy użyciu prawidłowych danych żądania, ponieważ będzie to wymagało informacji specyficznych dla platformy z poziomu aplikacji mobilnej klienta.

Tworzenie międzyplatformowej aplikacji platformy Xamarin.Forms

W tej sekcji utworzysz aplikację mobilną platformy Xamarin.Forms , która implementuje powiadomienia wypychane w sposób międzyplatformowy.

Umożliwia ona rejestrowanie i wyrejestrowanie z centrum powiadomień za pośrednictwem utworzonej usługi zaplecza.

Alert jest wyświetlany, gdy zostanie określona akcja, a aplikacja znajduje się na pierwszym planie. W przeciwnym razie powiadomienia są wyświetlane w centrum powiadomień.

Uwaga

Zazwyczaj należy wykonać akcje rejestracji (i wyrejestrowania) w odpowiednim punkcie cyklu życia aplikacji (lub w ramach środowiska pierwszego uruchomienia, być może) bez jawnego rejestrowania/wyrejestrowania danych wejściowych użytkownika. Jednak w tym przykładzie wymagane będą jawne dane wejściowe użytkownika, aby umożliwić łatwiejsze eksplorowanie i przetestowanie tej funkcji.

Tworzenie rozwiązania Xamarin.Forms

W programie Visual Studio utwórz nowe rozwiązanie platformy Xamarin.Forms przy użyciu pustej aplikacji formularzy jako szablonu i wprowadź wartość PushDemo jako nazwę projektu.

Uwaga

W oknie dialogowym Konfigurowanie pustej aplikacji formularzy upewnij się, że identyfikator organizacji jest zgodny z wartością użytą wcześniej i że są sprawdzane zarówno elementy docelowe systemu Android , jak i iOS .
Kontroli + Kliknij rozwiązanie PushDemo , a następnie wybierz pozycję Aktualizuj pakiety NuGet.
Kontroli + Kliknij rozwiązanie PushDemo, a następnie wybierz pozycję Zarządzaj pakietami NuGet...
Wyszukaj plik Newtonsoft.Json i upewnij się, że jest zaznaczony.
Kliknij pozycję Dodaj pakiety, a następnie kliknij przycisk Akceptuj po wyświetleniu monitu o zaakceptowanie postanowień licencyjnych.
Skompiluj i uruchom aplikację na każdej platformie docelowej (Enter polecenia + ), aby przetestować działanie szablonu aplikacji na urządzeniach.

Implementowanie składników międzyplatformowych

Kontroli + Kliknij projekt PushDemo , wybierz pozycję Nowy folder z menu Dodaj , a następnie kliknij pozycję Dodaj przy użyciu modeli jako nazwę folderu.
Kontroli + Kliknij folder Modele , a następnie wybierz pozycję Nowy plik... z menu Dodaj .

Wybierz pozycję Ogólna>pusta klasa, wprowadź DeviceInstallation.cs, a następnie dodaj następującą implementację.

using System.Collections.Generic;
using Newtonsoft.Json;

namespace PushDemo.Models
{
    public class DeviceInstallation
    {
        [JsonProperty("installationId")]
        public string InstallationId { get; set; }

        [JsonProperty("platform")]
        public string Platform { get; set; }

        [JsonProperty("pushChannel")]
        public string PushChannel { get; set; }

        [JsonProperty("tags")]
        public List<string> Tags { get; set; } = new List<string>();
    }
}

Dodaj pusty wyliczenie do folderu Models o nazwie PushDemoAction.cs z następującą implementacją.

namespace PushDemo.Models
{
    public enum PushDemoAction
    {
        ActionA,
        ActionB
    }
}

Dodaj nowy folder do projektu PushDemo o nazwie Services , a następnie dodaj do tego folderu klasę Empty o nazwie ServiceContainer.cs z następującą implementacją.

using System;
using System.Collections.Generic;

namespace PushDemo.Services
{
   public static class ServiceContainer
   {
       static readonly Dictionary<Type, Lazy<object>> services
           = new Dictionary<Type, Lazy<object>>();

       public static void Register<T>(Func<T> function)
           => services[typeof(T)] = new Lazy<object>(() => function());

       public static T Resolve<T>()
           => (T)Resolve(typeof(T));

       public static object Resolve(Type type)
       {
           {
               if (services.TryGetValue(type, out var service))
                   return service.Value;

               throw new KeyNotFoundException($"Service not found for type '{type}'");
           }
       }
   }
}

Uwaga

Jest to przycięta wersja klasy ServiceContainer z repozytorium XamCAT . Będzie on używany jako lekki kontener IoC (Inversion of Control).

Dodaj pusty interfejs do folderu Services o nazwie IDeviceInstallationService.cs, a następnie dodaj następujący kod.
```
using PushDemo.Models;

namespace PushDemo.Services
{
    public interface IDeviceInstallationService
    {
        string Token { get; set; }
        bool NotificationsSupported { get; }
        string GetDeviceId();
        DeviceInstallation GetDeviceInstallation(params string[] tags);
    }
}
```
Uwaga

Ten interfejs zostanie zaimplementowany i uruchomiony przez każdy obiekt docelowy później, aby zapewnić funkcjonalność specyficzną dla platformy i informacje o instalacji urządzeń wymagane przez usługę zaplecza.

Dodaj kolejny pusty interfejs do folderu Services o nazwie INotificationRegistrationService.cs, a następnie dodaj następujący kod.

using System.Threading.Tasks;

namespace PushDemo.Services
{
    public interface INotificationRegistrationService
    {
        Task DeregisterDeviceAsync();
        Task RegisterDeviceAsync(params string[] tags);
        Task RefreshRegistrationAsync();
    }
}

Uwaga

Spowoduje to obsługę interakcji między klientem a usługą zaplecza.

Dodaj kolejny pusty interfejs do folderu Services o nazwie INotificationActionService.cs, a następnie dodaj następujący kod.
```
namespace PushDemo.Services
{
    public interface INotificationActionService
    {
        void TriggerAction(string action);
    }
}
```
Uwaga

Jest to używany jako prosty mechanizm służący do scentralizowanej obsługi akcji powiadomień.
Dodaj pusty interfejs do folderu Services o nazwie IPushDemoNotificationActionService.cs , który pochodzi z usługi INotificationActionService z następującą implementacją.
```
using System;
using PushDemo.Models;

namespace PushDemo.Services
{
    public interface IPushDemoNotificationActionService : INotificationActionService
    {
        event EventHandler<PushDemoAction> ActionTriggered;
    }
}
```
Uwaga

Ten typ jest specyficzny dla aplikacji PushDemo i używa wyliczenia PushDemoAction , aby zidentyfikować akcję wyzwalaną w sposób silnie typizowane.

Dodaj pustą klasę do folderu Services o nazwie NotificationRegistrationService.cs implementowania klasy INotificationRegistrationService przy użyciu następującego kodu.

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using PushDemo.Models;
using Xamarin.Essentials;

namespace PushDemo.Services
{
    public class NotificationRegistrationService : INotificationRegistrationService
    {
        const string RequestUrl = "api/notifications/installations";
        const string CachedDeviceTokenKey = "cached_device_token";
        const string CachedTagsKey = "cached_tags";

        string _baseApiUrl;
        HttpClient _client;
        IDeviceInstallationService _deviceInstallationService;

        public NotificationRegistrationService(string baseApiUri, string apiKey)
        {
            _client = new HttpClient();
            _client.DefaultRequestHeaders.Add("Accept", "application/json");
            _client.DefaultRequestHeaders.Add("apikey", apiKey);

            _baseApiUrl = baseApiUri;
        }

        IDeviceInstallationService DeviceInstallationService
            => _deviceInstallationService ??
                (_deviceInstallationService = ServiceContainer.Resolve<IDeviceInstallationService>());

        public async Task DeregisterDeviceAsync()
        {
            var cachedToken = await SecureStorage.GetAsync(CachedDeviceTokenKey)
                .ConfigureAwait(false);

            if (cachedToken == null)
                return;

            var deviceId = DeviceInstallationService?.GetDeviceId();

            if (string.IsNullOrWhiteSpace(deviceId))
                throw new Exception("Unable to resolve an ID for the device.");

            await SendAsync(HttpMethod.Delete, $"{RequestUrl}/{deviceId}")
                .ConfigureAwait(false);

            SecureStorage.Remove(CachedDeviceTokenKey);
            SecureStorage.Remove(CachedTagsKey);
        }

        public async Task RegisterDeviceAsync(params string[] tags)
        {
            var deviceInstallation = DeviceInstallationService?.GetDeviceInstallation(tags);

            await SendAsync<DeviceInstallation>(HttpMethod.Put, RequestUrl, deviceInstallation)
                .ConfigureAwait(false);

            await SecureStorage.SetAsync(CachedDeviceTokenKey, deviceInstallation.PushChannel)
                .ConfigureAwait(false);

            await SecureStorage.SetAsync(CachedTagsKey, JsonConvert.SerializeObject(tags));
        }

        public async Task RefreshRegistrationAsync()
        {
            var cachedToken = await SecureStorage.GetAsync(CachedDeviceTokenKey)
                .ConfigureAwait(false);

            var serializedTags = await SecureStorage.GetAsync(CachedTagsKey)
                .ConfigureAwait(false);

            if (string.IsNullOrWhiteSpace(cachedToken) ||
                string.IsNullOrWhiteSpace(serializedTags) ||
                string.IsNullOrWhiteSpace(DeviceInstallationService.Token) ||
                cachedToken == DeviceInstallationService.Token)
                return;

            var tags = JsonConvert.DeserializeObject<string[]>(serializedTags);

            await RegisterDeviceAsync(tags);
        }

        async Task SendAsync<T>(HttpMethod requestType, string requestUri, T obj)
        {
            string serializedContent = null;

            await Task.Run(() => serializedContent = JsonConvert.SerializeObject(obj))
                .ConfigureAwait(false);

            await SendAsync(requestType, requestUri, serializedContent);
        }

        async Task SendAsync(
            HttpMethod requestType,
            string requestUri,
            string jsonRequest = null)
        {
            var request = new HttpRequestMessage(requestType, new Uri($"{_baseApiUrl}{requestUri}"));

            if (jsonRequest != null)
                request.Content = new StringContent(jsonRequest, Encoding.UTF8, "application/json");

            var response = await _client.SendAsync(request).ConfigureAwait(false);

            response.EnsureSuccessStatusCode();
        }
    }
}

Uwaga

Argument apiKey jest wymagany tylko w przypadku wybrania ukończenia sekcji Uwierzytelnianie klientów przy użyciu klucza interfejsu API .

Dodaj pustą klasę do folderu Services o nazwie PushDemoNotificationActionService.cs implementowania usługi IPushDemoNotificationActionService przy użyciu następującego kodu.

using System;
using System.Collections.Generic;
using System.Linq;
using PushDemo.Models;

namespace PushDemo.Services
{
    public class PushDemoNotificationActionService : IPushDemoNotificationActionService
    {
        readonly Dictionary<string, PushDemoAction> _actionMappings = new Dictionary<string, PushDemoAction>
        {
            { "action_a", PushDemoAction.ActionA },
            { "action_b", PushDemoAction.ActionB }
        };

        public event EventHandler<PushDemoAction> ActionTriggered = delegate { };

        public void TriggerAction(string action)
        {
            if (!_actionMappings.TryGetValue(action, out var pushDemoAction))
                return;

            List<Exception> exceptions = new List<Exception>();

            foreach (var handler in ActionTriggered?.GetInvocationList())
            {
                try
                {
                    handler.DynamicInvoke(this, pushDemoAction);
                }
                catch (Exception ex)
                {
                    exceptions.Add(ex);
                }
            }

            if (exceptions.Any())
                throw new AggregateException(exceptions);
        }
    }
}

Dodaj pustą klasę do projektu PushDemo o nazwie Config.cs z następującą implementacją.
```
namespace PushDemo
{
    public static partial class Config
    {
        public static string ApiKey = "API_KEY";
        public static string BackendServiceEndpoint = "BACKEND_SERVICE_ENDPOINT";
    }
}
```
Uwaga

Jest to prosty sposób przechowywania wpisów tajnych poza kontrolą źródła. Te wartości można zastąpić w ramach zautomatyzowanej kompilacji lub zastąpić je przy użyciu lokalnej klasy częściowej. Zrobisz to w następnym kroku.

Pole ApiKey jest wymagane tylko w przypadku wybrania opcji Uwierzytelniania klientów przy użyciu klucza interfejsu API .
Dodaj kolejną pustą klasę do projektu PushDemo o nazwie Config.local_secrets.cs z następującą implementacją.
```
namespace PushDemo
{
    public static partial class Config
    {
        static Config()
        {
            ApiKey = "<your_api_key>";
            BackendServiceEndpoint = "<your_api_app_url>";
        }
    }
}
```
Uwaga

Zastąp wartości symboli zastępczych własnymi. Podczas tworzenia usługi zaplecza należy zanotować te kwestie. Adres URL aplikacji interfejsu API powinien mieć wartość https://<api_app_name>.azurewebsites.net/. Pamiętaj, aby dodać *.local_secrets.* plik gitignore, aby uniknąć zatwierdzania tego pliku.

Pole ApiKey jest wymagane tylko w przypadku wybrania opcji Uwierzytelniania klientów przy użyciu klucza interfejsu API .

Dodaj pustą klasę do projektu PushDemo o nazwie Bootstrap.cs z następującą implementacją.

using System;
using PushDemo.Services;

namespace PushDemo
{
    public static class Bootstrap
    {
        public static void Begin(Func<IDeviceInstallationService> deviceInstallationService)
        {
            ServiceContainer.Register(deviceInstallationService);

            ServiceContainer.Register<IPushDemoNotificationActionService>(()
                => new PushDemoNotificationActionService());

            ServiceContainer.Register<INotificationRegistrationService>(()
                => new NotificationRegistrationService(
                    Config.BackendServiceEndpoint,
                    Config.ApiKey));
        }
    }
}

Uwaga

Metoda Begin będzie wywoływana przez każdą platformę, gdy aplikacja uruchamia przekazywanie w implementacji usługi IDeviceInstallationService specyficznej dla platformy.

Argument konstruktora NotificationRegistrationServiceapiKey jest wymagany tylko wtedy, gdy wybrano opcję Uwierzytelniania klientów przy użyciu klucza interfejsu API .

Implementowanie wieloplatformowego interfejsu użytkownika

W projekcie PushDemo otwórz plik MainPage.xaml i zastąp kontrolkę StackLayout następującym kodem.

<StackLayout VerticalOptions="EndAndExpand"  
             HorizontalOptions="FillAndExpand"
             Padding="20,40">
    <Button x:Name="RegisterButton"
            Text="Register"
            Clicked="RegisterButtonClicked" />
    <Button x:Name="DeregisterButton"
            Text="Deregister"
            Clicked="DeregisterButtonClicked" />
</StackLayout>

Teraz w MainPage.xaml.cs dodaj pole do odczytu , aby zapisać odwołanie do implementacji INotificationRegistrationService .
```
readonly INotificationRegistrationService _notificationRegistrationService;
```
W konstruktorze MainPage rozwiąż implementację INotificationRegistrationService przy użyciu klasy ServiceContainer i przypisz ją do pola obsługi zapasowej notificationRegistrationService .
```
public MainPage()
{
    InitializeComponent();

    _notificationRegistrationService =
        ServiceContainer.Resolve<INotificationRegistrationService>();
}
```

Zaimplementuj programy obsługi zdarzeń dla przycisków RegisterButton i DeregisterButtonKliknięto zdarzenia wywołujące odpowiednie metodywyrejestrowaniarejestru/.

void RegisterButtonClicked(object sender, EventArgs e)
    => _notificationRegistrationService.RegisterDeviceAsync().ContinueWith((task)
        => { ShowAlert(task.IsFaulted ?
                task.Exception.Message :
                $"Device registered"); });

void DeregisterButtonClicked(object sender, EventArgs e)
    => _notificationRegistrationService.DeregisterDeviceAsync().ContinueWith((task)
        => { ShowAlert(task.IsFaulted ?
                task.Exception.Message :
                $"Device deregistered"); });

void ShowAlert(string message)
    => MainThread.BeginInvokeOnMainThread(()
        => DisplayAlert("PushDemo", message, "OK").ContinueWith((task)
            => { if (task.IsFaulted) throw task.Exception; }));

Teraz w App.xaml.cs upewnij się, że do następujących przestrzeni nazw są przywołyne.

using PushDemo.Models;
using PushDemo.Services;
using Xamarin.Essentials;
using Xamarin.Forms;

Zaimplementuj procedurę obsługi zdarzeń dla zdarzenia IPushDemoNotificationActionServiceActionTriggered .

void NotificationActionTriggered(object sender, PushDemoAction e)
    => ShowActionAlert(e);

void ShowActionAlert(PushDemoAction action)
    => MainThread.BeginInvokeOnMainThread(()
        => MainPage?.DisplayAlert("PushDemo", $"{action} action received", "OK")
            .ContinueWith((task) => { if (task.IsFaulted) throw task.Exception; }));

W konstruktorze aplikacji rozwiąż implementację IPushNotificationActionService przy użyciu usługi ServiceContainer i zasubskrybuj zdarzenie IPushDemoNotificationActionServiceActionTriggered .
```
public App()
{
    InitializeComponent();

    ServiceContainer.Resolve<IPushDemoNotificationActionService>()
        .ActionTriggered += NotificationActionTriggered;

    MainPage = new MainPage();
}
```
Uwaga

Jest to po prostu pokazanie potwierdzenia i propagacji akcji powiadomień wypychanych. Zazwyczaj są one obsługiwane w trybie dyskretnym, na przykład przechodzenie do określonego widoku lub odświeżanie niektórych danych, a nie wyświetlanie alertu za pośrednictwem strony głównej, w tym przypadku MainPage .

Konfigurowanie natywnego projektu systemu Android pod kątem powiadomień wypychanych

Weryfikowanie nazwy pakietu i uprawnień

W obszarze PushDemo.Android otwórz opcje projektu , a następnie pozycję Aplikacja systemu Android w sekcji Kompilacja .
Sprawdź, czy nazwa pakietu jest zgodna z wartością używaną w projekcie PushDemokonsoli Firebase. Nazwa pakietu była w formacie com.<organization>.pushdemo.
Ustaw minimalną wersję systemu Android na Android 8.0 (poziom 26 interfejsu API) i docelową wersję systemu Android na najnowszy poziom interfejsu API.

Uwaga

Tylko te urządzenia z poziomem interfejsu API na poziomie 26 i nowszym są obsługiwane na potrzeby tego samouczka, jednak można rozszerzyć go na obsługę urządzeń z starszymi wersjami.
Upewnij się, że uprawnienia Internet i READ_PHONE_STATE są włączone w obszarze Wymagane uprawnienia.
Kliknij przycisk OK

Dodawanie bazowych usług Xamarin Google Play i pakietów Xamarin.Firebase.Messaging

W folderze PushDemo.Androidkliknij + folder Packages, a następnie wybierz pozycję Zarządzaj pakietami NuGet....
Wyszukaj pozycję Xamarin.GooglePlayServices.Base (nie piwnica) i upewnij się, że jest zaznaczona.
Wyszukaj plik Xamarin.Firebase.Messaging i upewnij się, że jest on zaznaczony.
Kliknij pozycję Dodaj pakiety, a następnie kliknij przycisk Akceptuj po wyświetleniu monitu o zaakceptowanie postanowień licencyjnych.

Dodawanie pliku JSON usług Google Services

Kontroli + PushDemo.AndroidKliknij projekt, a następnie wybierz pozycję Istniejący plik... z menu Dodaj.
Wybierz pobrany wcześniej plik google-services.json podczas konfigurowania projektu PushDemo w konsoli Firebase , a następnie kliknij przycisk Otwórz.
Po wyświetleniu monitu wybierz opcję Skopiuj plik do katalogu.
Kontroli + Kliknij plik google-services.json w projekcie PushDemo.Android , a następnie upewnij się, że plik GoogleServicesJson jest ustawiony jako akcja kompilacji.

Obsługa powiadomień wypychanych dla systemu Android

Kontroli + PushDemo.AndroidKliknij projekt, wybierz pozycję Nowy folder z menu Dodaj, a następnie kliknij pozycję Dodaj przy użyciu usług jako nazwę folderu.
Kontroli + Kliknij folder Usługi , a następnie wybierz pozycję Nowy plik... z menu Dodaj .

Wybierz pozycję Ogólna>pusta klasa, wprowadź DeviceInstallationService.cs w polu Nazwa, a następnie kliknij pozycję Nowy , dodając następującą implementację.

using System;
using Android.App;
using Android.Gms.Common;
using PushDemo.Models;
using PushDemo.Services;
using static Android.Provider.Settings;

namespace PushDemo.Droid.Services
{
    public class DeviceInstallationService : IDeviceInstallationService
    {
        public string Token { get; set; }

        public bool NotificationsSupported
            => GoogleApiAvailability.Instance
                .IsGooglePlayServicesAvailable(Application.Context) == ConnectionResult.Success;

        public string GetDeviceId()
            => Secure.GetString(Application.Context.ContentResolver, Secure.AndroidId);

        public DeviceInstallation GetDeviceInstallation(params string[] tags)
        {
            if (!NotificationsSupported)
                throw new Exception(GetPlayServicesError());

            if (string.IsNullOrWhiteSpace(Token))
                throw new Exception("Unable to resolve token for FCM");

            var installation = new DeviceInstallation
            {
                InstallationId = GetDeviceId(),
                Platform = "fcm",
                PushChannel = Token
            };

            installation.Tags.AddRange(tags);

            return installation;
        }

        string GetPlayServicesError()
        {
            int resultCode = GoogleApiAvailability.Instance.IsGooglePlayServicesAvailable(Application.Context);

            if (resultCode != ConnectionResult.Success)
                return GoogleApiAvailability.Instance.IsUserResolvableError(resultCode) ?
                           GoogleApiAvailability.Instance.GetErrorString(resultCode) :
                           "This device is not supported";

            return "An error occurred preventing the use of push notifications";
        }
    }
}

Uwaga

Ta klasa udostępnia unikatowy identyfikator (przy użyciu identyfikatora Secure.AndroidId) w ramach ładunku rejestracji centrum powiadomień.

Dodaj kolejną pustą klasę do folderu Services o nazwie PushNotificationFirebaseMessagingService.cs, a następnie dodaj następującą implementację.

using Android.App;
using Android.Content;
using Firebase.Messaging;
using PushDemo.Services;

namespace PushDemo.Droid.Services
{
    [Service]
    [IntentFilter(new[] { "com.google.firebase.MESSAGING_EVENT" })]
    public class PushNotificationFirebaseMessagingService : FirebaseMessagingService
    {
        IPushDemoNotificationActionService _notificationActionService;
        INotificationRegistrationService _notificationRegistrationService;
        IDeviceInstallationService _deviceInstallationService;

        IPushDemoNotificationActionService NotificationActionService
            => _notificationActionService ??
                (_notificationActionService =
                ServiceContainer.Resolve<IPushDemoNotificationActionService>());

        INotificationRegistrationService NotificationRegistrationService
            => _notificationRegistrationService ??
                (_notificationRegistrationService =
                ServiceContainer.Resolve<INotificationRegistrationService>());

        IDeviceInstallationService DeviceInstallationService
            => _deviceInstallationService ??
                (_deviceInstallationService =
                ServiceContainer.Resolve<IDeviceInstallationService>());

        public override void OnNewToken(string token)
        {
            DeviceInstallationService.Token = token;

            NotificationRegistrationService.RefreshRegistrationAsync()
                .ContinueWith((task) => { if (task.IsFaulted) throw task.Exception; });
        }

        public override void OnMessageReceived(RemoteMessage message)
        {
            if(message.Data.TryGetValue("action", out var messageAction))
                NotificationActionService.TriggerAction(messageAction);
        }
    }
}

W MainActivity.cs upewnij się, że w górnej części pliku zostały dodane następujące przestrzenie nazw.

using System;
using Android.App;
using Android.Content;
using Android.Content.PM;
using Android.OS;
using Android.Runtime;
using Firebase.Iid;
using PushDemo.Droid.Services;
using PushDemo.Services;

W MainActivity.cs ustaw wartość LaunchMode na SingleTop , aby funkcja MainActivity nie została utworzona ponownie po otwarciu.

[Activity(
    Label = "PushDemo",
    LaunchMode = LaunchMode.SingleTop,
    Icon = "@mipmap/icon",
    Theme = "@style/MainTheme",
    MainLauncher = true,
    ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation)]

Dodaj właściwości prywatne i odpowiadające im pola kopii zapasowej, aby przechowywać odwołanie do implementacji IPushNotificationActionService i IDeviceInstallationService .

IPushDemoNotificationActionService _notificationActionService;
IDeviceInstallationService _deviceInstallationService;

IPushDemoNotificationActionService NotificationActionService
    => _notificationActionService ??
        (_notificationActionService =
        ServiceContainer.Resolve<IPushDemoNotificationActionService>());

IDeviceInstallationService DeviceInstallationService
    => _deviceInstallationService ??
        (_deviceInstallationService =
        ServiceContainer.Resolve<IDeviceInstallationService>());

Zaimplementuj interfejs IOnSuccessListener , aby pobrać i zapisać token Firebase .

public class MainActivity : global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity, Android.Gms.Tasks.IOnSuccessListener
{
    ...

    public void OnSuccess(Java.Lang.Object result)
        => DeviceInstallationService.Token =
            result.Class.GetMethod("getToken").Invoke(result).ToString();
}

Dodaj nową metodę o nazwie ProcessNotificationActions , która sprawdzi, czy dana intencja ma dodatkową wartość o nazwie action. Warunkowo wyzwalaj akcję przy użyciu implementacji IPushDemoNotificationActionService .

void ProcessNotificationActions(Intent intent)
{
    try
    {
        if (intent?.HasExtra("action") == true)
        {
            var action = intent.GetStringExtra("action");

            if (!string.IsNullOrEmpty(action))
                NotificationActionService.TriggerAction(action);
        }
    }
    catch (Exception ex)
    {
        System.Diagnostics.Debug.WriteLine(ex.Message);
    }
}

Zastąpi metodę OnNewIntent , aby wywołać metodę ProcessNotificationActions .
```
protected override void OnNewIntent(Intent intent)
{
    base.OnNewIntent(intent);
    ProcessNotificationActions(intent);
}
```
Uwaga

Ponieważ element LaunchMode dla działania jest ustawiony na wartość SingleTop, intencja zostanie wysłana do istniejącego wystąpienia działania za pośrednictwem metody OnNewIntent, a nie metody OnCreate, a więc musisz obsłużyć intencję przychodzącą zarówno w metodach OnCreate, jak i OnNewIntent.
Zaktualizuj metodę OnCreate , aby wywołać wywołanie bezpośrednio po wywołaniu Bootstrap.Begin w celu base.OnCreate przekazania implementacji specyficznej dla platformy usługi IDeviceInstallationService.
```
Bootstrap.Begin(() => new DeviceInstallationService());
```
W tej samej metodzie warunkowo wywołaj metodę GetInstanceId w wystąpieniu aplikacji FirebaseApp bezpośrednio po wywołaniu Bootstrap.Beginmetody , dodając element MainActivity jako element IOnSuccessListener.
```
if (DeviceInstallationService.NotificationsSupported)
{
    FirebaseInstanceId.GetInstance(Firebase.FirebaseApp.Instance)
        .GetInstanceId()
        .AddOnSuccessListener(this);
}
```
Nadal w obszarze OnCreate wywołaj metodę ProcessNotificationActions bezpośrednio po wywołaniu, aby przekazać LoadApplication bieżącą intencję.
```
...

LoadApplication(new App());

ProcessNotificationActions(Intent);
```

Uwaga

Musisz ponownie zarejestrować aplikację przy każdym uruchomieniu i zatrzymać ją z sesji debugowania, aby kontynuować odbieranie powiadomień wypychanych.

Konfigurowanie natywnego projektu systemu iOS pod kątem powiadomień wypychanych

Konfigurowanie pliku Info.plist i Entitlements.plist

Upewnij się, że zalogowaliśmy się do konta dewelopera apple wpreferencjachprogramu Visual Studio>...>Publikowania>Pobrano konta deweloperów firmy Apple oraz odpowiedni profil certyfikatu i aprowizacji. Te zasoby powinny zostać utworzone w ramach poprzednich kroków.
W pliku PushDemo.iOS otwórz plik Info.plist i upewnij się, że element BundleIdentifier jest zgodny z wartością użytą dla odpowiedniego profilu aprowizacji w portalu dla deweloperów firmy Apple. Element BundleIdentifier był w formacie com.<organization>.PushDemo.
W tym samym pliku ustaw minimalną wersję systemu na 13.0.

Uwaga

Tylko te urządzenia z systemem iOS 13.0 lub nowszym są obsługiwane na potrzeby tego samouczka, jednak można rozszerzyć go na urządzenia obsługujące starsze wersje.
Otwórz opcje projektu dla pliku PushDemo.iOS (kliknij dwukrotnie projekt).
W obszarze Opcje projektu w obszarze Kompilowanie > podpisywania pakietu systemu iOS upewnij się, że w obszarze Zespół wybrano konto dewelopera. Następnie upewnij się, że wybrano opcję "Automatyczne zarządzanie podpisywaniem", a automatycznie wybrano certyfikat podpisywania i profil aprowizacji.

Uwaga

Jeśli certyfikat podpisywania i profil aprowizacji nie zostały automatycznie wybrane, wybierz pozycję Ręczne aprowizowanie, a następnie kliknij pozycję Opcje podpisywania pakietu. Upewnij się, że twój zespół jest wybrany dla opcji Podpisywanie tożsamości, a profil aprowizacjipushDemo został wybrany dla profilu aprowizacji zarówno dla konfiguracji debugowania, jak i wydania, zapewniając, że w obu przypadkach wybrano dla platformytelefon iPhone.
W pliku PushDemo.iOS otwórz plik Entitlements.plist i upewnij się, że opcja Włącz powiadomienia wypychane jest sprawdzana po wyświetleniu na karcie Uprawnienia . Następnie upewnij się, że ustawienie Środowisko usługi APS jest ustawione na programowanie po wyświetleniu na karcie Źródło .

Obsługa powiadomień wypychanych dla systemu iOS

Kontroli + Kliknij projekt PushDemo.iOS , wybierz pozycję Nowy folder z menu Dodaj , a następnie kliknij pozycję Dodaj przy użyciu usług jako nazwę folderu.
Kontroli + Kliknij folder Usługi , a następnie wybierz pozycję Nowy plik... z menu Dodaj .

Wybierz pozycję Ogólna>pusta klasa, wprowadź DeviceInstallationService.cs w polu Nazwa, a następnie kliknij pozycję Nowy , dodając następującą implementację.

using System;
using PushDemo.Models;
using PushDemo.Services;
using UIKit;

namespace PushDemo.iOS.Services
{
    public class DeviceInstallationService : IDeviceInstallationService
    {
        const int SupportedVersionMajor = 13;
        const int SupportedVersionMinor = 0;

        public string Token { get; set; }

        public bool NotificationsSupported
            => UIDevice.CurrentDevice.CheckSystemVersion(SupportedVersionMajor, SupportedVersionMinor);

        public string GetDeviceId()
            => UIDevice.CurrentDevice.IdentifierForVendor.ToString();

        public DeviceInstallation GetDeviceInstallation(params string[] tags)
        {
            if (!NotificationsSupported)
                throw new Exception(GetNotificationsSupportError());

            if (string.IsNullOrWhiteSpace(Token))
                throw new Exception("Unable to resolve token for APNS");

            var installation = new DeviceInstallation
            {
                InstallationId = GetDeviceId(),
                Platform = "apns",
                PushChannel = Token
            };

            installation.Tags.AddRange(tags);

            return installation;
        }

        string GetNotificationsSupportError()
        {
            if (!NotificationsSupported)
                return $"This app only supports notifications on iOS {SupportedVersionMajor}.{SupportedVersionMinor} and above. You are running {UIDevice.CurrentDevice.SystemVersion}.";

            if (Token == null)
                return $"This app can support notifications but you must enable this in your settings.";


            return "An error occurred preventing the use of push notifications";
        }
    }
}

Uwaga

Ta klasa udostępnia unikatowy identyfikator (przy użyciu wartości UIDevice.IdentifierForVendor ) i ładunku rejestracji centrum powiadomień.

Dodaj nowy folder do projektu PushDemo.iOS o nazwie Extensions (Rozszerzenia), a następnie dodaj do tego folderu klasę pustą o nazwie NSDataExtensions.cs z następującą implementacją.

using System.Text;
using Foundation;

namespace PushDemo.iOS.Extensions
{
    internal static class NSDataExtensions
    {
        internal static string ToHexString(this NSData data)
        {
            var bytes = data.ToArray();

            if (bytes == null)
                return null;

            StringBuilder sb = new StringBuilder(bytes.Length * 2);

            foreach (byte b in bytes)
                sb.AppendFormat("{0:x2}", b);

            return sb.ToString().ToUpperInvariant();
        }
    }
}

W AppDelegate.cs upewnij się, że w górnej części pliku zostały dodane następujące przestrzenie nazw.

using System;
using System.Diagnostics;
using System.Threading.Tasks;
using Foundation;
using PushDemo.iOS.Extensions;
using PushDemo.iOS.Services;
using PushDemo.Services;
using UIKit;
using UserNotifications;
using Xamarin.Essentials;

Dodaj właściwości prywatne i odpowiednie pola kopii zapasowej, aby przechowywać odwołanie do implementacji IPushDemoNotificationActionService, INotificationRegistrationService i IDeviceInstallationService .

IPushDemoNotificationActionService _notificationActionService;
INotificationRegistrationService _notificationRegistrationService;
IDeviceInstallationService _deviceInstallationService;

IPushDemoNotificationActionService NotificationActionService
    => _notificationActionService ??
        (_notificationActionService =
        ServiceContainer.Resolve<IPushDemoNotificationActionService>());

INotificationRegistrationService NotificationRegistrationService
    => _notificationRegistrationService ??
        (_notificationRegistrationService =
        ServiceContainer.Resolve<INotificationRegistrationService>());

IDeviceInstallationService DeviceInstallationService
    => _deviceInstallationService ??
        (_deviceInstallationService =
        ServiceContainer.Resolve<IDeviceInstallationService>());

Dodaj metodę RegisterForRemoteNotifications , aby zarejestrować ustawienia powiadomień użytkownika, a następnie w przypadku powiadomień zdalnych przy użyciu usługi APNS.

void RegisterForRemoteNotifications()
{
    MainThread.BeginInvokeOnMainThread(() =>
    {
        var pushSettings = UIUserNotificationSettings.GetSettingsForTypes(
            UIUserNotificationType.Alert |
            UIUserNotificationType.Badge |
            UIUserNotificationType.Sound,
            new NSSet());

        UIApplication.SharedApplication.RegisterUserNotificationSettings(pushSettings);
        UIApplication.SharedApplication.RegisterForRemoteNotifications();
    });
}

Dodaj metodę CompleteRegistrationAsync , aby ustawić IDeviceInstallationService.Token wartość właściwości. Odśwież rejestrację i buforuj token urządzenia, jeśli został on zaktualizowany od czasu jego ostatniego przechowywania.
```
Task CompleteRegistrationAsync(NSData deviceToken)
{
    DeviceInstallationService.Token = deviceToken.ToHexString();
    return NotificationRegistrationService.RefreshRegistrationAsync();
}
```

Dodaj metodę ProcessNotificationActions do przetwarzania danych powiadomień NSDictionary i warunkowo wywołując notificationActionService.TriggerAction.

void ProcessNotificationActions(NSDictionary userInfo)
{
    if (userInfo == null)
        return;

    try
    {
        var actionValue = userInfo.ObjectForKey(new NSString("action")) as NSString;

        if (!string.IsNullOrWhiteSpace(actionValue?.Description))
            NotificationActionService.TriggerAction(actionValue.Description);
    }
    catch (Exception ex)
    {
        Debug.WriteLine(ex.Message);
    }
}

Zastąpij metodę RegisteredForRemoteNotifications przekazującą argument deviceToken do metody CompleteRegistrationAsync .

public override void RegisteredForRemoteNotifications(
    UIApplication application,
    NSData deviceToken)
    => CompleteRegistrationAsync(deviceToken).ContinueWith((task)
        => { if (task.IsFaulted) throw task.Exception; });

Zastąp metodę ReceivedRemoteNotification przekazującą argument userInfo do metody ProcessNotificationActions .

public override void ReceivedRemoteNotification(
    UIApplication application,
    NSDictionary userInfo)
    => ProcessNotificationActions(userInfo);

Zastąpi metodę FailedToRegisterForRemoteNotifications , aby zarejestrować błąd.
```
public override void FailedToRegisterForRemoteNotifications(
    UIApplication application,
    NSError error)
    => Debug.WriteLine(error.Description);
```
Uwaga

Jest to bardzo symbol zastępczy. Należy zaimplementować odpowiednie rejestrowanie i obsługę błędów w scenariuszach produkcyjnych.
Zaktualizuj metodę FinishedLaunching , aby wywołać wywołanie Bootstrap.Begin bezpośrednio po wywołaniu, aby przekazać Forms.Init implementację usługi IDeviceInstallationService specyficzną dla platformy.
```
Bootstrap.Begin(() => new DeviceInstallationService());
```

W tej samej metodzie warunkowo żądaj autoryzacji i zarejestruj się w celu otrzymywania powiadomień zdalnych bezpośrednio po Bootstrap.Begin.

if (DeviceInstallationService.NotificationsSupported)
{
    UNUserNotificationCenter.Current.RequestAuthorization(
            UNAuthorizationOptions.Alert |
            UNAuthorizationOptions.Badge |
            UNAuthorizationOptions.Sound,
            (approvalGranted, error) =>
            {
                if (approvalGranted && error == null)
                    RegisterForRemoteNotifications();
            });
}

Nadal w obszarze FinishedLaunching wywołaj metodę ProcessNotificationActions bezpośrednio po wywołaniu metody LoadApplication , jeśli argument options zawiera element UIApplication.LaunchOptionsRemoteNotificationKey przekazując wynikowy obiekt userInfo .
```
using (var userInfo = options?.ObjectForKey(
    UIApplication.LaunchOptionsRemoteNotificationKey) as NSDictionary)
        ProcessNotificationActions(userInfo);
```

Testowanie rozwiązania

Teraz możesz przetestować wysyłanie powiadomień za pośrednictwem usługi zaplecza.

Wysyłanie powiadomienia testowego

Otwórz nową kartę w narzędziu Postman.

Ustaw żądanie na POST i wprowadź następujący adres:

https://<app_name>.azurewebsites.net/api/notifications/requests

Jeśli wybrano ukończenie sekcji Uwierzytelnianie klientów przy użyciu klucza interfejsu API , pamiętaj o skonfigurowaniu nagłówków żądań w celu uwzględnienia wartości klucza apikey .

Klucz Wartość

apikey <your_api_key>
Wybierz opcję nieprzetworzoną dla treści, a następnie wybierz pozycję JSON z listy opcji formatowania, a następnie dołącz zawartość JSON symbolu zastępczego:
```
{
    "text": "Message from Postman!",
    "action": "action_a"
}
```
Wybierz przycisk Kod , który znajduje się w obszarze przycisku Zapisz w prawym górnym rogu okna. Żądanie powinno wyglądać podobnie do poniższego przykładu w przypadku wyświetlania kodu HTML (w zależności od tego, czy dołączono nagłówek apikey ):
```
POST /api/notifications/requests HTTP/1.1
Host: https://<app_name>.azurewebsites.net
apikey: <your_api_key>
Content-Type: application/json

{
    "text": "Message from backend service",
    "action": "action_a"
}
```
Uruchom aplikację PushDemo na jednej lub obu platformach docelowych (Android i iOS).

Uwaga

Jeśli testujesz w systemie Android , upewnij się, że nie korzystasz z debugowania lub jeśli aplikacja została wdrożona, uruchamiając aplikację, wymuś zamknięcie aplikacji i uruchom ją ponownie z poziomu uruchamiania.
W aplikacji PushDemo naciśnij przycisk Zarejestruj .
Po powrocie do narzędzia Postman zamknij okno Generowanie fragmentów kodu (jeśli jeszcze tego nie zrobiono), a następnie kliknij przycisk Wyślij .
Sprawdź, czy otrzymasz odpowiedź 200 OK w narzędziu Postman , a alert zostanie wyświetlony w aplikacji z odebraną akcją ActionA.
Zamknij aplikację PushDemo , a następnie ponownie kliknij przycisk Wyślij w narzędziu Postman.
Sprawdź, czy ponownie otrzymasz odpowiedź 200 OK w narzędziu Postman . Sprawdź, czy powiadomienie jest wyświetlane w obszarze powiadomień dla aplikacji PushDemo z poprawnym komunikatem.
Naciśnij powiadomienie, aby potwierdzić, że otworzy aplikację i wyświetli alert akcji ActionA.
Po powrocie do narzędzia Postman zmodyfikuj poprzednią treść żądania, aby wysłać dyskretne powiadomienie określające action_b zamiast action_a wartości akcji .
```
{
    "action": "action_b",
    "silent": true
}
```
Po otwarciu aplikacji kliknij przycisk Wyślij w narzędziu Postman.
Sprawdź, czy otrzymasz odpowiedź 200 OK w narzędziu Postman i że alert jest wyświetlany w aplikacji z odebraną akcją ActionB zamiast odebraną akcją ActionA.
Zamknij aplikację PushDemo , a następnie ponownie kliknij przycisk Wyślij w narzędziu Postman.
Sprawdź, czy otrzymasz odpowiedź 200 OK w narzędziu Postman i że dyskretne powiadomienie nie jest wyświetlane w obszarze powiadomień.

Klucz	Wartość
apikey	<your_api_key>

Rozwiązywanie problemów

Brak odpowiedzi z usługi zaplecza

Podczas testowania lokalnego upewnij się, że usługa zaplecza jest uruchomiona i używa poprawnego portu.

W przypadku testowania aplikacji interfejsu API platformy Azure sprawdź, czy usługa jest uruchomiona i została wdrożona i została uruchomiona bez błędów.

Upewnij się, że podczas testowania za pośrednictwem klienta poprawnie określono adres podstawowy w narzędziu Postman lub w konfiguracji aplikacji mobilnej. Adres podstawowy powinien wskazywać https://<api_name>.azurewebsites.net/ lub https://localhost:5001/ podczas testowania lokalnego.

Nie otrzymuję powiadomień w systemie Android po uruchomieniu lub zatrzymaniu sesji debugowania

Upewnij się, że zarejestrujesz się ponownie po rozpoczęciu lub zatrzymaniu sesji debugowania. Debuger spowoduje wygenerowanie nowego tokenu firebase . Należy również zaktualizować instalację centrum powiadomień.

Odbieranie kodu stanu 401 z usługi zaplecza

Sprawdź, czy ustawiasz nagłówek żądania apikey , a ta wartość jest zgodna z wartością skonfigurowaną dla usługi zaplecza.

Jeśli podczas testowania lokalnego wystąpi ten błąd, upewnij się, że wartość klucza zdefiniowana w konfiguracji klienta jest zgodna z wartością ustawienia użytkownika Authentication:ApiKey używaną przez interfejs API.

Jeśli testujesz za pomocą aplikacji interfejsu API, upewnij się, że wartość klucza w pliku konfiguracji klienta jest zgodna z ustawieniem aplikacji Authentication:ApiKey używanym w aplikacji interfejsu API.

Uwaga

Jeśli to ustawienie zostało utworzone lub zmienione po wdrożeniu usługi zaplecza, należy ponownie uruchomić usługę, aby usługa została wdrożona.

Jeśli nie wybrano ukończenia sekcji Uwierzytelnianie klientów przy użyciu klucza interfejsu API , upewnij się, że nie zastosowano atrybutu Authorize do klasy NotificationsController .

Odbieranie kodu stanu 404 z usługi zaplecza

Sprawdź, czy punkt końcowy i metoda żądania HTTP są poprawne. Na przykład punkty końcowe powinny wskazywać na:

[PUT]https://<api_name>.azurewebsites.net/api/notifications/installations
[DELETE]https://<api_name>.azurewebsites.net/api/notifications/installations/<installation_id>
[POST]https://<api_name>.azurewebsites.net/api/notifications/requests

Lub podczas lokalnego testowania:

[PUT]https://localhost:5001/api/notifications/installations
[DELETE]https://localhost:5001/api/notifications/installations/<installation_id>
[POST]https://localhost:5001/api/notifications/requests

Podczas określania adresu podstawowego w aplikacji klienckiej upewnij się, że kończy się /na . Adres podstawowy powinien wskazywać https://<api_name>.azurewebsites.net/ lub https://localhost:5001/ podczas testowania lokalnego.

Nie można zarejestrować i zostanie wyświetlony komunikat o błędzie centrum powiadomień

Sprawdź, czy urządzenie testowe ma łączność sieciową. Następnie określ kod stanu odpowiedzi Http, ustawiając punkt przerwania w celu sprawdzenia wartości właściwości StatusCode w obiekcie HttpResponse.

Przejrzyj poprzednie sugestie dotyczące rozwiązywania problemów, jeśli ma to zastosowanie na podstawie kodu stanu.

Ustaw punkt przerwania w wierszach, które zwracają te określone kody stanu dla odpowiedniego interfejsu API. Następnie spróbuj wywołać usługę zaplecza podczas lokalnego debugowania.

Sprawdź, czy usługa zaplecza działa zgodnie z oczekiwaniami za pośrednictwem narzędzia Postman przy użyciu odpowiedniego ładunku. Użyj rzeczywistego ładunku utworzonego przez kod klienta dla danej platformy.

Przejrzyj sekcje konfiguracji specyficzne dla platformy, aby upewnić się, że nie pominięto żadnych kroków. Sprawdź, czy odpowiednie wartości są rozpoznawane dla installation id zmiennych i token dla odpowiedniej platformy.

Nie można rozpoznać identyfikatora komunikatu o błędzie urządzenia

Przejrzyj sekcje konfiguracji specyficzne dla platformy, aby upewnić się, że nie pominięto żadnych kroków.

Następne kroki

Teraz powinna istnieć podstawowa aplikacja platformy Xamarin.Forms połączona z centrum powiadomień za pośrednictwem usługi zaplecza i może wysyłać i odbierać powiadomienia.

Prawdopodobnie konieczne będzie dostosowanie przykładu użytego w tym samouczku, aby dopasować go do własnego scenariusza. Zalecane jest również zaimplementowanie bardziej niezawodnej obsługi błędów, logiki ponawiania prób i rejestrowania.

Centrum aplikacji programu Visual Studio można szybko włączyć do aplikacji mobilnych zapewniających analizę i diagnostykę , aby ułatwić rozwiązywanie problemów.

Udostępnij za pośrednictwem

Samouczek: wysyłanie powiadomień wypychanych do aplikacji platformy Xamarin.Forms przy użyciu usługi Azure Notification Hubs za pośrednictwem usługi zaplecza

Wymagania wstępne

Konfigurowanie usług powiadomień wypychanych i usługi Azure Notification Hub

Tworzenie projektu Firebase i włączanie usługi Firebase Cloud Messaging dla systemu Android

Rejestrowanie aplikacji dla systemu iOS na potrzeby powiadomień wypychanych

Tworzenie certyfikatu dla usługi Notification Hubs

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

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

Tworzenie profilu aprowizacji dla aplikacji

Tworzenie centrum powiadomień

Konfigurowanie centrum powiadomień przy użyciu informacji usługi APNS

OPCJA 1: Używanie certyfikatu wypychania p12

OPCJA 2. Korzystanie z uwierzytelniania opartego na tokenach

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

Tworzenie aplikacji zaplecza internetowego interfejsu API ASP.NET Core

Tworzenie projektu internetowego

Uwierzytelnianie klientów przy użyciu klucza interfejsu API (opcjonalnie)

Dodawanie zależności i konfigurowanie usług

Tworzenie interfejsu API powiadomień

Tworzenie aplikacji interfejsu API

Publikowanie usługi zaplecza

Weryfikowanie opublikowanego interfejsu API

Tworzenie międzyplatformowej aplikacji platformy Xamarin.Forms

Tworzenie rozwiązania Xamarin.Forms

Implementowanie składników międzyplatformowych

Implementowanie wieloplatformowego interfejsu użytkownika

Konfigurowanie natywnego projektu systemu Android pod kątem powiadomień wypychanych

Weryfikowanie nazwy pakietu i uprawnień

Dodawanie bazowych usług Xamarin Google Play i pakietów Xamarin.Firebase.Messaging

Dodawanie pliku JSON usług Google Services

Obsługa powiadomień wypychanych dla systemu Android

Konfigurowanie natywnego projektu systemu iOS pod kątem powiadomień wypychanych

Konfigurowanie pliku Info.plist i Entitlements.plist

Obsługa powiadomień wypychanych dla systemu iOS

Testowanie rozwiązania

Wysyłanie powiadomienia testowego

Rozwiązywanie problemów

Brak odpowiedzi z usługi zaplecza

Nie otrzymuję powiadomień w systemie Android po uruchomieniu lub zatrzymaniu sesji debugowania

Odbieranie kodu stanu 401 z usługi zaplecza

Odbieranie kodu stanu 404 z usługi zaplecza

Nie można zarejestrować i zostanie wyświetlony komunikat o błędzie centrum powiadomień

Nie można rozpoznać identyfikatora komunikatu o błędzie urządzenia

Łącza pokrewne

Następne kroki

Dodatkowe zasoby