Oktatóanyag: Leküldéses értesítések küldése Xamarin.Forms-alkalmazásokba az Azure Notification Hubs használatával háttérszolgáltatáson keresztül

Cikk
07/27/2020

Ebben az oktatóanyagban az Azure Notification Hubs használatával küld leküldéses értesítéseket egy Androidot és iOS-t célzó Xamarin.Forms-alkalmazásba.

A ASP.NET Core Webes API-háttérrendszer az ügyfél eszközregisztrációjának kezelésére szolgál a legújabb és legjobb telepítési módszer használatával. A szolgáltatás leküldéses értesítéseket is küld platformfüggetlen módon.

Ezek a műveletek a Notification Hubs SDK-val kezelhetők a háttérműveletekhez. Az általános megközelítéssel kapcsolatos további részletekért tekintse meg a Regisztráció az alkalmazás háttérrendszeréből dokumentációt.

Ez az oktatóanyag végigvezeti az alábbi lépéseket:

A leküldéses értesítési szolgáltatások és az Azure Notification Hubs beállítása.
Hozzon létre egy ASP.NET Core Webes API háttéralkalmazást.
Platformfüggetlen Xamarin.Forms-alkalmazás létrehozása.
Konfigurálja a natív Android-projektet leküldéses értesítésekhez.
Konfigurálja a natív iOS-projektet leküldéses értesítésekhez.
A megoldás teszteléséhez.

Előfeltételek

A lépések követéséhez a következőkre van szükség:

Egy Azure-előfizetés ahol létrehozni és -erőforrások kezeléséhez.
Telepített Visual Studio for Mac vagy Visual Studio 2019-et futtató számítógép.
A Visual Studio 2019 felhasználóinak a .NET-tel és ASP.NET és webfejlesztési számítási feladatokkal is rendelkezniük kell a Mobilfejlesztés szolgáltatással.
Az alkalmazás futtatásának lehetősége Android (fizikai vagy emulátor) vagy iOS rendszeren (csak fizikai eszközökön).

Android esetén a következőkre van szüksége:

Egy fejlesztő feloldott egy fizikai eszközt vagy egy emulátort (az API 26-os vagy újabb verzióját futtatva, amelyen telepítve van a Google Play Services).

iOS esetén a következőkre van szükség:

Az aktív Apple Developer-fiók.
Egy fizikai iOS-eszköz, amely regisztrálva van a fejlesztői fiókjában(iOS 13.0-s vagy újabb rendszert futtat).
A kulcskarikára telepített .p12fejlesztői tanúsítvány lehetővé teszi egy alkalmazás fizikai eszközön való futtatását.

Megjegyzés

Az iOS-szimulátor nem támogatja a távoli értesítéseket, ezért fizikai eszközre van szükség a minta iOS-en való vizsgálatához. Az oktatóanyag elvégzéséhez azonban nem kell futtatnia az alkalmazást Android és iOS rendszeren is.

Az első alapelveket tartalmazó példában szereplő lépéseket előzetes tapasztalat nélkül is követheti. Az alábbi szempontok ismerete azonban hasznos lehet.

Fontos

A megadott lépések a Visual Studio for Mac vonatkoznak. A Visual Studio 2019-et használhatja, de lehet, hogy van néhány összeegyeztethető különbség. Például a felhasználói felület és a munkafolyamatok leírása, a sablonnevek, a környezet konfigurációja stb.

Leküldéses értesítési szolgáltatások és az Azure Notification Hub beállítása

Ebben a szakaszban a Firebase Cloud Messaging (FCM) és az Apple Push Notification Services (APNS) szolgáltatást állítja be. Ezután létre kell hoznia és konfigurálnia kell egy értesítési központot, hogy működjön ezekkel a szolgáltatásokkal.

Firebase-projekt létrehozása és a Firebase Cloud Messaging engedélyezése Androidhoz

Jelentkezzen be a Firebase-konzolra. Hozzon létre egy új Firebase-projektet, amely a PushDemo nevet adja meg projektnévként.

Megjegyzés

A rendszer létrehoz egy egyedi nevet. Alapértelmezés szerint ez a megadott név kisbetűs változata, valamint egy kötőjellel elválasztott generált számból áll. Ezt módosíthatja, ha szeretné, feltéve, hogy az továbbra is globálisan egyedi.
A projekt létrehozása után válassza a Firebase hozzáadása az Android-alkalmazáshoz lehetőséget.
Az Add Firebase to your Android app (Tűzbázis hozzáadása androidos alkalmazáshoz ) lapon hajtsa végre az alábbi lépéseket.
1. Az Android-csomag neveként adja meg a csomag nevét. Például: com.<organization_identifier>.<package_name>.
2. Válassza az Alkalmazás regisztrálása lehetőséget.
3. Válassza a Letöltés google-services.json lehetőséget. Ezután mentse a fájlt egy helyi mappába későbbi használatra, és válassza a Tovább gombot.
4. Kattintson a Tovább gombra.
5. Válassza a Folytatás konzolra lehetőséget
  
  Megjegyzés
  
  Ha a Folytatás konzolra gomb nincs engedélyezve, a telepítés ellenőrzésének ellenőrzése miatt válassza a Lépés kihagyása lehetőséget.
A Firebase konzolon válassza ki a projekthez tartozó fogaskerék elemet. Ezután válassza a Projektbeállítások lehetőséget.

Megjegyzés

Ha még nem töltötte le a google-services.json fájlt, letöltheti erre a lapra.
Váltson a felső Cloud Messaging (Felhőbeli üzenetkezelés ) lapra. Másolja ki és mentse a Kiszolgálókulcsot későbbi használatra. Ezzel az értékkel konfigurálhatja az értesítési központot.

iOS-alkalmazás regisztrálása leküldéses értesítésekhez

Ha leküldéses értesítéseket szeretne küldeni egy iOS-alkalmazásnak, regisztrálja alkalmazását az Apple-ben, és regisztráljon leküldéses értesítésekre is.

Ha még nem regisztrálta az alkalmazást, keresse meg az iOS kiépítési portálját az Apple Fejlesztői központban. Jelentkezzen be a portálra az Apple ID azonosítójával, lépjen a Tanúsítványok, azonosítók & Profilok elemre, majd válassza az Azonosítók lehetőséget. Kattintson ide + egy új alkalmazás regisztrálásához.
Az Új azonosító regisztrálása képernyőn válassza az Alkalmazásazonosítók választógombot. Ezután válassza a Folytatás elemet.
Frissítse a következő három értéket az új alkalmazáshoz, majd válassza a Folytatás lehetőséget:
- Leírás: Adjon meg egy leíró nevet az alkalmazásnak.
- Csomagazonosító: Adja meg a com.organization_identifier<> űrlap csomagazonosítóját.<>product_name az alkalmazásterjesztési útmutatóban leírtak szerint. Az alábbi képernyőképen az mobcat érték szervezeti azonosítóként, a PushDemo érték pedig a terméknév.
- Leküldéses értesítések: Ellenőrizze a Leküldéses értesítések lehetőséget a Képességek szakaszban.
  
  Ez a művelet létrehozza az alkalmazásazonosítót, és kéri, hogy erősítse meg az információkat. Válassza a Folytatás, majd a Regisztráció lehetőséget az új alkalmazásazonosító megerősítéséhez.
  
  Miután kiválasztotta a Regisztráció lehetőséget, az új alkalmazásazonosító sorelemként jelenik meg a Tanúsítványok, azonosítók & Profilok lapon.
A Tanúsítványok, azonosítók & Profilok lapon, az Azonosítók területen keresse meg a létrehozott Alkalmazásazonosító sorelemet. Ezután válassza ki a sorát az Alkalmazásazonosító konfigurációjának szerkesztése képernyő megjelenítéséhez.

Tanúsítvány létrehozása a Notification Hubshoz

Tanúsítvány szükséges ahhoz, hogy az értesítési központ működjön az Apple Push Notification Services (APNS) szolgáltatással, és kétféleképpen nyújtható:

P12 leküldéses tanúsítvány létrehozása, amely közvetlenül a Notification Hubra tölthető fel (az eredeti megközelítés)
Jogkivonatalapú hitelesítéshez használható p8-tanúsítvány létrehozása (az újabb és javasolt megközelítés)

Az újabb megközelítés számos előnnyel rendelkezik az APNS tokenalapú (HTTP/2) hitelesítésében dokumentált módon. Kevesebb lépésre van szükség, de adott forgatókönyvekhez is kötelező megadni. A lépések azonban mindkét megközelítéshez meg lettek adva, mivel mindkét módszer az oktatóanyag céljaira fog működni.

1. LEHETŐSÉG: P12 leküldéses tanúsítvány létrehozása, amely közvetlenül a Notification Hubra tölthető fel

Mac gépen futtassa a Keychain Access eszközt. A Utilities mappából vagy a Launchpad Egyéb mappájából nyitható meg.
Válassza a Keychain Access lehetőséget, bontsa ki a Tanúsítványsegéd elemet, majd válassza a Tanúsítvány kérése hitelesítésszolgáltatótól lehetőséget.

Megjegyzés

Alapértelmezés szerint a Keychain Access kiválasztja a lista első elemét. Ez akkor lehet probléma, ha a Tanúsítványok kategóriában van, és az Apple Worldwide Developer Relations Hitelesítésszolgáltató nem az első elem a listában. A CSR (tanúsítvány-aláírási kérelem) létrehozása előtt győződjön meg arról, hogy nincs kulcseleme, vagy az Apple Worldwide Developer Relations hitelesítésszolgáltatója kulcs van kiválasztva.
Válassza ki a felhasználó Email címét, adja meg a Common Name (Közös név) értéket, győződjön meg arról, hogy a Mentés lemezre lehetőséget adja meg, majd válassza a Folytatás lehetőséget. Hagyja üresen a hitelesítésszolgáltató Email Cím mezőt, mert nincs rá szükség.
Adja meg a Tanúsítvány-aláírási kérelem (CSR) fájl nevét a Mentés másként területen, válassza ki a helyet a Hol, majd válassza a Mentés lehetőséget.

Ez a művelet a CSR-fájlt a kiválasztott helyre menti. Az alapértelmezett hely az Asztal. Jegyezze meg a fájlhoz kiválasztott helyet.
Térjen vissza a Tanúsítványok, azonosítók & Profilok lapra az iOS kiépítési portálon, görgessen le a leküldéses értesítések jelölőnégyzethez, majd válassza a Konfigurálás lehetőséget a tanúsítvány létrehozásához.
Megjelenik az Apple Leküldéses értesítési szolgáltatás TLS/SSL-tanúsítványok ablaka . Válassza a Tanúsítvány létrehozása gombot a Fejlesztési TLS/SSL-tanúsítvány szakaszban.

Megjelenik az Új tanúsítvány létrehozása képernyő.

Megjegyzés

Ez az oktatóanyag fejlesztési tanúsítványt használ. Ugyanezt a folyamatot használja az éles tanúsítvány regisztrálásakor. Csak győződjön meg arról, hogy ugyanazt a tanúsítványtípust használja az értesítések küldésekor.
Válassza a Fájl kiválasztása lehetőséget, keresse meg azt a helyet, ahová a CSR-fájlt mentette, majd kattintson duplán a tanúsítvány nevére a betöltéséhez. Ezután válassza a Folytatás elemet.
Miután a portál létrehozta a tanúsítványt, válassza a Letöltés gombot. Mentse a tanúsítványt, és jegyezze meg a mentés helyét.

A rendszer letölti és menti a tanúsítványt a számítógépre a Letöltések mappában.

Megjegyzés

Alapértelmezés szerint a letöltött fejlesztési tanúsítvány neve aps_development.cer.
Kattintson duplán a letöltött leküldéses tanúsítványra aps_development.cer. Ez a művelet telepíti az új tanúsítványt a kulcskarikán, az alábbi képen látható módon:

Megjegyzés

Bár a tanúsítványban szereplő név eltérő lehet, a név az Apple Development iOS Push Services előtaggal lesz ellátva, és hozzá lesz rendelve a megfelelő csomagazonosító.
A Kulcskarika-hozzáférés területen + kattintson a Tanúsítványok kategóriában létrehozott új leküldéses tanúsítványra . Válassza az Exportálás lehetőséget, nevezze el a fájlt, válassza ki a p12 formátumot, majd válassza a Mentés lehetőséget.

Dönthet úgy, hogy jelszóval védi a tanúsítványt, de a jelszó megadása nem kötelező. Ha meg szeretné kerülni a jelszó létrehozását, kattintson az OK gombra . Jegyezze fel az exportált p12-tanúsítvány fájlnevét és helyét. Az APN-ekkel történő hitelesítés engedélyezésére szolgálnak.

Megjegyzés

A p12-fájl neve és helye eltérhet az oktatóanyagban láthatótól.

2. LEHETŐSÉG: Jogkivonatalapú hitelesítéshez használható p8-tanúsítvány létrehozása

Jegyezze fel a következő részleteket:
- Alkalmazásazonosító előtag (csapatazonosító)
- Csomagazonosító
A Tanúsítványok, azonosítók & profilok területen kattintson a Kulcsok elemre.

Megjegyzés

Ha már rendelkezik az APNS-hez konfigurált kulccsal, használhatja újra a közvetlenül a létrehozása után letöltött p8-tanúsítványt. Ha igen, figyelmen kívül hagyhatja a 3 – 5. lépést.
Kattintson a + gombra (vagy a Kulcs létrehozása gombra) egy új kulcs létrehozásához.
Adjon meg egy megfelelő Kulcsnév értéket, majd ellenőrizze az Apple Push Notifications szolgáltatás (APNS) beállítását, majd kattintson a Folytatás, majd a Regisztráció elemre a következő képernyőn.
Kattintson a Letöltés gombra, majd helyezze át a p8 fájlt ( AuthKey_ előtaggal) egy biztonságos helyi könyvtárba, majd kattintson a Kész gombra.

Megjegyzés

Ügyeljen arra, hogy a p8-fájl biztonságos helyen legyen (és mentsen egy biztonsági másolatot). A kulcs letöltése után nem tölthető le újra a kiszolgálópéldány eltávolításakor.
A Kulcsok területen kattintson a létrehozott kulcsra (vagy egy meglévő kulcsra, ha ezt választotta).
Jegyezze fel a Kulcsazonosító értéket.
Nyissa meg a p8-tanúsítványt egy tetszőleges alkalmazásban, például a Visual Studio Code-ban. Jegyezze fel a kulcs értékét ( -----BEGIN PRIVATE KEY----- és -----END PRIVATE KEY----- között).

-----BEGIN PRIVATE KEY-----
<key_value>
-----END PRIVATE KEY-----

Megjegyzés

Ez az a tokenérték , amelyet később a Notification Hub konfigurálásához használunk.

Ezeknek a lépéseknek a végén a következő információkkal kell rendelkeznie, amelyeket később használhat az Értesítési központ konfigurálása APNS-adatokkal című cikkben:

Csapatazonosító (lásd: 1. lépés)
Csomagazonosító (lásd: 1. lépés)
Kulcsazonosító (lásd a 7. lépést)
Jogkivonat értéke (a 8. lépésben kapott p8 kulcsérték)

Üzembe helyezési profil létrehozása az alkalmazáshoz

Térjen vissza az iOS kiépítési portálra, válassza a Tanúsítványok, azonosítók & Profilok lehetőséget, válassza a profilok lehetőséget a bal oldali menüben, majd válasszon + új profil létrehozásához. Megjelenik az Új kiépítési profil regisztrálása képernyő.
A kiépítési profil típusaként válassza az iOS-alkalmazásfejlesztés lehetőséget a Fejlesztés területen, majd válassza a Folytatás lehetőséget.
Ezután válassza ki a létrehozott alkalmazásazonosítót az Alkalmazásazonosító legördülő listából, majd válassza a Folytatás lehetőséget.
A Tanúsítványok kiválasztása ablakban válassza ki a kódaláíráshoz használt fejlesztési tanúsítványt, majd válassza a Folytatás lehetőséget.

Megjegyzés

Ez a tanúsítvány nem az előző lépésben létrehozott leküldéses tanúsítvány. Ez az Ön fejlesztési tanúsítványa. Ha nem létezik, létre kell hoznia, mivel ez az oktatóanyag előfeltétele . A fejlesztői tanúsítványok az Apple Fejlesztői portálon, az Xcode-on vagy a Visual Studióban hozhatók létre.
Térjen vissza a Tanúsítványok, azonosítók & Profilok lapra, válassza a Profilok lehetőséget a bal oldali menüből, majd válassza ki + az új profil létrehozásához. Megjelenik az Új kiépítési profil regisztrálása képernyő.
A Tanúsítványok kiválasztása ablakban válassza ki a létrehozott fejlesztési tanúsítványt. Ezután válassza a Folytatás elemet.
Ezután válassza ki a teszteléshez használni kívánt eszközöket, majd válassza a Folytatás lehetőséget.
Végül válassza ki a profil nevét a Kiépítési profil neve területen, majd válassza a Létrehozás lehetőséget.
Az új kiépítési profil létrehozásakor válassza a Letöltés lehetőséget. Jegyezze meg a mentés helyét.
Keresse meg a kiépítési profil helyét, majd kattintson rá duplán a fejlesztőgépen való telepítéshez.

Értesítési központ létrehozása

Ebben a szakaszban létrehoz egy értesítési központot, és konfigurálja a hitelesítést az APNS használatával. P12 leküldéses tanúsítványt vagy jogkivonat-alapú hitelesítést is használhat. Ha egy már létrehozott értesítési központot szeretne használni, ugorjon az 5. lépésre.

Jelentkezzen be az Azure-ba.
Kattintson az Erőforrás létrehozása elemre, keresse meg és válassza az Értesítési központ lehetőséget, majd kattintson a Létrehozás gombra.
Frissítse a következő mezőket, majd kattintson a Létrehozás gombra:

ALAPSZINTŰ RÉSZLETEK

Előfizetés: Válassza ki a cél-előfizetést a legördülő listából
Erőforráscsoport: Új erőforráscsoport létrehozása (vagy meglévő kiválasztása)

NÉVTÉR RÉSZLETEI

Notification Hub-névtér: Adjon meg egy globálisan egyedi nevet a Notification Hub névteréhez

Megjegyzés

Győződjön meg arról, hogy az Új létrehozása lehetőség van kiválasztva ehhez a mezőhöz.

ÉRTESÍTÉSI KÖZPONT ADATAI

Értesítési központ: Adja meg a Notification Hub nevét
Helyen: Válasszon egy megfelelő helyet a legördülő listából
Tarifacsomag: Az alapértelmezett ingyenes beállítás megtartása

Megjegyzés

Hacsak nem érte el az ingyenes szinten található központok maximális számát.
A Notification Hub kiépítése után keresse meg az erőforrást.
Lépjen az új Értesítési központra.
Válassza a Hozzáférési szabályzatok elemet a listából (a KEZELÉS területen).
Jegyezze fel a Szabályzatnév értékeket a hozzájuk tartozó kapcsolati sztringértékekkel együtt.

A Notification Hub konfigurálása APNS-adatokkal

A Notification Services (Értesítési szolgáltatások) területen válassza az Apple lehetőséget, majd kövesse a megfelelő lépéseket az Értesítési központok tanúsítványának létrehozása szakaszban korábban kiválasztott megközelítés alapján.

Megjegyzés

Csak akkor használja az Alkalmazáshoz készült élesüzemmódot , ha leküldéses értesítéseket szeretne küldeni azoknak a felhasználóknak, akik az alkalmazást az áruházból vásárolták.

1. LEHETŐSÉG: .p12 leküldéses tanúsítvány használata

Válassza a Tanúsítvány elemet.
Válassza a fájl ikont.
Jelölje ki a korábban exportált .p12 fájlt, majd válassza a Megnyitás lehetőséget.
Szükség esetén adja meg a megfelelő jelszót.
Válassza a Védőfal módot.
Kattintson a Mentés gombra.

2. LEHETŐSÉG: Jogkivonatalapú hitelesítés használata

Válassza a Jogkivonat lehetőséget.
Adja meg a korábban beszerzett alábbi értékeket:
- Kulcsazonosító
- Csomagazonosító
- Csapatazonosító
- Token
Válassza a Tesztkörnyezet lehetőséget.
Kattintson a Mentés gombra.

Az értesítési központ konfigurálása FCM-adatokkal

A bal oldali menü Beállítások szakaszában válassza a Google (GCM/FCM) lehetőséget.
Adja meg a Google Firebase-konzolról feljegyzett kiszolgálókulcsot.
Válassza az eszköztár Save (Mentés) elemét.

ASP.NET Core Webes API háttéralkalmazás létrehozása

Ebben a szakaszban a ASP.NET Core Webes API-háttérrendszert hozza létre az eszközregisztráció és az értesítések Xamarin.Forms mobilalkalmazásba való küldéséhez.

Webes projekt létrehozása

A Visual Studióban válassza a Fájl>új megoldás lehetőséget.
Válassza a .NETCore-alkalmazás>>ASP.NET Core>API>Tovább lehetőséget.
Az új ASP.NET Core Webes API konfigurálása párbeszédpanelen válassza a .NET Core 3.1cél keretrendszerét.
Írja be a PushDemoApi nevet a projektnévhez , majd válassza a Létrehozás lehetőséget.
Indítsa el a hibakeresést (Command + Enter) a sablonalapú alkalmazás teszteléséhez.
Megjegyzés

A sablonalapú alkalmazás úgy van konfigurálva, hogy a WeatherForecastControllerthasználja launchUrlként. Ez a Tulajdonságok>launchSettings.json van beállítva.

Ha a rendszer érvénytelen fejlesztési tanúsítványt talált üzenettel kéri:
1. Kattintson az Igen gombra a "dotnet dev-certs https" eszköz futtatásához a probléma megoldásához. A "dotnet dev-certs https" eszköz ezután megkéri, hogy adja meg a tanúsítvány jelszavát és a kulcskarika jelszavát.
2. Kattintson az Igen gombra, amikor a rendszer az új tanúsítvány telepítésére és megbízhatóságára kéri, majd adja meg a kulcskarika jelszavát.
Bontsa ki a Controllers mappát, majd törölje WeatherForecastController.cs.
Törölje WeatherForecast.cs.
Állítson be helyi konfigurációs értékeket a Secret Manager eszközzel. A titkos kódok megoldástól való leválasztása biztosítja, hogy ne kerülnek a forráskontrollba. Nyissa meg a Terminált , majd nyissa meg a projektfájl könyvtárát, és futtassa a következő parancsokat:
```
dotnet user-secrets init
dotnet user-secrets set "NotificationHub:Name" <value>
dotnet user-secrets set "NotificationHub:ConnectionString" <value>
```
Cserélje le a helyőrző értékeket a saját értesítési központ nevére és kapcsolati karakterlánc értékeire. Ezeket az értesítési központ létrehozása szakaszban jegyezte fel. Ellenkező esetben megkeresheti őket az Azure-ban.

NotificationHub:Name:
Lásd: Név az Áttekintés tetején található Essentials-összefoglalásban.

NotificationHub:ConnectionString:
Lásd: DefaultFullSharedAccessSignature in Access Policies

Megjegyzés

Éles forgatókönyvek esetén olyan lehetőségeket tekinthet meg, mint az Azure KeyVault a kapcsolati karakterlánc biztonságos tárolásához. Az egyszerűség kedvéért a titkos kulcsok hozzá lesznek adva a Azure App Service alkalmazásbeállításokhoz.

Ügyfelek hitelesítése API-kulccsal (nem kötelező)

Az API-kulcsok nem olyan biztonságosak, mint a tokenek, de elegendőek az oktatóanyag céljaira. Az API-kulcsok egyszerűen konfigurálhatók a ASP.NET Köztes szoftveren keresztül.

Adja hozzá az API-kulcsot a helyi konfigurációs értékekhez.
```
dotnet user-secrets set "Authentication:ApiKey" <value>
```
Megjegyzés

Cserélje le a helyőrző értékét a sajátjára, és jegyezze fel.
Ellenőrzés + Kattintson a PushDemoApi projektre, válassza az Új mappa lehetőséget a Hozzáadás menüben, majd kattintson a Hozzáadás hitelesítésselmappanévként elemre.
Ellenőrzés + Kattintson a Hitelesítés mappára, majd válassza az Új fájl... lehetőséget a Hozzáadás menüben.

Válassza az Általános>üres osztály lehetőséget , írja be ApiKeyAuthOptions.cs a Név mezőbe, majd kattintson az Új gombra, és adja hozzá a következő implementációt.

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

Adjon hozzá egy másik üres osztályt a ApiKeyAuthHandler.cs nevű hitelesítési mappához, majd adja hozzá a következő implementációt.

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

Megjegyzés

A Hitelesítési kezelő egy olyan típus, amely implementálja egy séma viselkedését, ebben az esetben egy egyéni API-kulcsséma.

Adjon hozzá egy másik üres osztályt a ApiKeyAuthenticationBuilderExtensions.cs nevű hitelesítési mappához, majd adja hozzá a következő implementációt.

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

Megjegyzés

Ez a bővítménymetódus leegyszerűsíti a köztes szoftver konfigurációs kódját Startup.cs olvashatóbbá és általában könnyebben követhetővé teszi.

A Startup.cs frissítse a ConfigureServices metódust, hogy konfigurálja az API-kulcs hitelesítését a szolgáltatások hívása alatt . AddControllers metódus.

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

Továbbra is Startup.cs frissítse a Configure metódust, hogy meghívja a UseAuthentication és a UseAuthorization bővítménymetódusokat az alkalmazás IApplicationBuilderjén. Győződjön meg arról, hogy ezek a metódusok a UseRouting és az alkalmazás előtt lettek meghívva . UseEndpoints.
```
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();
    });
}
```
Megjegyzés

A UseAuthentication hívása regisztrálja a korábban regisztrált hitelesítési sémákat használó köztes szoftvereket (a ConfigureServices szolgáltatásból). Ezt minden olyan köztes szoftver előtt meg kell hívni, amely a felhasználók hitelesítésétől függ.

Függőségek hozzáadása és szolgáltatások konfigurálása

ASP.NET Core támogatja a függőséginjektálási (DI) szoftvertervezési mintát, amely az osztályok és függőségeik közötti vezérlés inverziójának (IoC) elérésére szolgáló technika.

Az értesítési központ és a Notification Hubs SDK háttérműveletekhez való használata egy szolgáltatásba van beágyazva. A szolgáltatás regisztrálva van, és megfelelő absztrakción keresztül érhető el.

Ellenőrzés + Kattintson a Függőségek mappára, majd válassza a NuGet-csomagok kezelése... lehetőséget.
Keressen rá a Microsoft.Azure.NotificationHubs kifejezésre , és ellenőrizze, hogy be van-e jelölve.
Kattintson a Csomagok hozzáadása, majd az Elfogadás gombra, amikor a rendszer a licencfeltételek elfogadására kéri.
Ellenőrzés + Kattintson a PushDemoApi projektre, válassza az Új mappa lehetőséget a Hozzáadás menüben, majd kattintson a Hozzáadásmodellek használatával mappanévként elemre.
Ellenőrzés + Kattintson a Modellek mappára, majd válassza az Új fájl... lehetőséget a Hozzáadás menüben.

Válassza az Általános>üres osztály lehetőséget, írja be PushTemplates.cs a Név mezőbe, majd kattintson az Új elemre a következő implementáció hozzáadásakor.

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

Megjegyzés

Ez az osztály tartalmazza az ebben a forgatókönyvben megkövetelt általános és csendes értesítések tokenizált értesítési hasznos adatait. A hasznos adatok a telepítésen kívül vannak meghatározva, hogy lehetővé tegyék a kísérletezést anélkül, hogy frissíteniük kellene a meglévő telepítéseket a szolgáltatáson keresztül. A telepítések ilyen módon végzett módosításainak kezelése az oktatóanyag hatókörén kívül esik. Éles környezetben fontolja meg az egyéni sablonok használatát.

Adjon hozzá egy másik Üres osztályt a Models mappához DeviceInstallation.cs néven, majd adja hozzá a következő implementációt.

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

Adjon hozzá egy másik Üres osztályt a Models (Modellek ) mappához NotificationRequest.cs néven, majd adja hozzá a következő implementációt.

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

Adjon hozzá egy másik Üres osztályt a Models mappához NotificationHubOptions.cs néven, majd adja hozzá a következő implementációt.

using System.ComponentModel.DataAnnotations;

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

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

Adjon hozzá egy új mappát a PushDemoApi projekthez Services néven.

Adjon hozzá egy Empty Interface (Üres felület) elemet az INotificationService.cs nevű Services mappához, majd adja hozzá a következő implementációt.

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

Adjon hozzá egy Üres osztályt a NotificationHubsService.cs nevű Services mappához, majd adja hozzá a következő kódot az INotificationService felület implementálásához:

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

Megjegyzés

A SendTemplateNotificationAsync számára megadott címkekifejezés legfeljebb 20 címkére korlátozódik. A legtöbb operátor esetében 6-ra van korlátozva, de a kifejezés ebben az esetben csak az ORS-eket (||) tartalmazza. Ha a kérelemben több mint 20 címke szerepel, akkor több kérelemre kell felosztani őket. További részletekért tekintse meg az Útválasztási és címkekifejezések dokumentációját.

A Startup.cs frissítse a ConfigureServices metódust, hogy az INotificationService egyszeri implementációjaként adja hozzá a NotificationHubsService-t.


using PushDemoApi.Models;
using PushDemoApi.Services;

public void ConfigureServices(IServiceCollection services)
{
    ...

    services.AddSingleton<INotificationService, NotificationHubService>();

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

Az értesítési API létrehozása

Ellenőrzés + Kattintson a Vezérlők mappára, majd válassza az Új fájl... lehetőséget a Hozzáadás menüben.
Válassza a ASP.NET Core>Web API-vezérlő osztályt, írja be a NotificationsController nevet a Név mezőbe, majd kattintson az Új gombra.

Megjegyzés

Ha követi a Visual Studio 2019-et, válassza az OLVASÁSI/írási műveletek sablonnal rendelkező API-vezérlőt .

Adja hozzá a következő névtereket a fájl elejéhez.

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;

Frissítse a sablonalapú vezérlőt úgy, hogy az a ControllerBase-ből származzon, és az ApiController attribútummal van díszítve.
```
[ApiController]
[Route("api/[controller]")]
public class NotificationsController : ControllerBase
{
    // Templated methods here
}
```
Megjegyzés

A Controller alaposztály támogatja a nézeteket, de erre ebben az esetben nincs szükség, így a ControllerBase használható helyette. Ha a Visual Studio 2019-et követi, kihagyhatja ezt a lépést.
Ha az Ügyfelek hitelesítése API-kulcs használatával szakaszt választotta, akkor az NotificationsControllert is az Authorize attribútummal kell díszítenie.
```
[Authorize]
```

Frissítse a konstruktort, hogy argumentumként fogadja el az INotificationService regisztrált példányát , és rendelje hozzá egy olvasható taghoz.

readonly INotificationService _notificationService;

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

A launchSettings.json (a Tulajdonságok mappában) módosítsa a launchUrl értéket api/notifications értékreweatherforecast, hogy megfeleljen a RegistrationsControllerRoute attribútumban megadott URL-címnek.
Indítsa el a hibakeresést (Command + Enter) annak ellenőrzéséhez, hogy az alkalmazás működik-e az új NotificationsControllerrel , és 401 Jogosulatlan állapotot ad vissza.

Megjegyzés

Előfordulhat, hogy a Visual Studio nem indítja el automatikusan az alkalmazást a böngészőben. A Postman használatával ettől a ponttól kezdve tesztelheti az API-t.
Egy új Postman lapon állítsa a kérést GET értékre. Írja be az alábbi címet az applicationUrl> helyőrző< helyett a Tulajdonságok>launchSettings.json található https applicationUrl értékre.
```
<applicationUrl>/api/notifications
```
Megjegyzés

Az alapértelmezett profilhoz az applicationUrl értéknek "https://localhost:5001" kell lennie. Ha IIS-t használ (windowsos Visual Studio 2019-ben alapértelmezés szerint), akkor az iisSettings elemben megadott applicationUrl elemet kell használnia. Ha a cím helytelen, 404-et kap.
Ha az ügyfelek hitelesítése API-kulcs használatával szakaszt választotta, mindenképpen konfigurálja úgy a kérésfejléceket, hogy tartalmazzák az apikey értékét.

Kulcs Value

apikey <your_api_key>
Kattintson a Küldés gombra.

Megjegyzés

200 OK állapotúnak kell lennie néhány JSON-tartalommal.

Ha SSL-tanúsítvány-ellenőrzési figyelmeztetést kap, a Beállítások területen kikapcsolhatja az SSL-tanúsítvány-ellenőrzés Postman-kérését.

Kulcs	Value
apikey	<your_api_key>

Cserélje le az NotificationsController.cs sablonalapú osztály metódusát a következő kódra.

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

Az API-alkalmazás létrehozása

Most létrehoz egy API-alkalmazást Azure App Service a háttérszolgáltatás üzemeltetéséhez.

Jelentkezzen be az Azure Portalra.
Kattintson az Erőforrás létrehozása elemre, keresse meg és válassza az API-alkalmazás lehetőséget, majd kattintson a Létrehozás gombra.
Frissítse a következő mezőket, majd kattintson a Létrehozás gombra.

Alkalmazás neve:
Adja meg az API-alkalmazás globálisan egyedi nevét

Előfizetés:
Válassza ki ugyanazt a cél előfizetést , amelyben az értesítési központot létrehozta.

Erőforráscsoport:
Válassza ki ugyanazt az erőforráscsoportot , amelyben az értesítési központot létrehozta.

App Service csomag/hely:
Új App Service-csomag létrehozása

Megjegyzés

Váltson az alapértelmezett beállításról ssl-támogatást tartalmazó csomagra. Ellenkező esetben meg kell tennie a megfelelő lépéseket a mobilalkalmazás használatakor, hogy megakadályozza a HTTP-kérések blokkolását.

Application Insights:
Tartsa meg a javasolt beállítást (új erőforrás jön létre ezzel a névvel), vagy válasszon ki egy meglévő erőforrást.
Az API-alkalmazás kiépítése után lépjen az erőforráshoz.
Jegyezze fel az URL-tulajdonságot az Áttekintés tetején található Essentials-összefoglalásban. Ez az URL-cím a háttérbeli végpont , amelyet az oktatóanyag későbbi részében fogunk használni.

Megjegyzés

Az URL-cím a korábban megadott API-alkalmazásnevet használja a következő formátumban https://<app_name>.azurewebsites.net: .
Válassza a Konfiguráció lehetőséget a listából (a Beállítások területen).
Az alábbi beállítások mindegyikéhez kattintson az Új alkalmazásbeállítás elemre a Név és az Érték megadásához, majd kattintson az OK gombra.

Name (Név) Value

Authentication:ApiKey <api_key_value>

NotificationHub:Name <hub_name_value>

NotificationHub:ConnectionString <hub_connection_string_value>

Megjegyzés

Ezek ugyanazok a beállítások, amelyeket korábban a felhasználói beállításokban definiált. Ezeket át kell tudnia másolni. Az Authentication:ApiKey beállítás csak akkor szükséges, ha az Ügyfelek hitelesítése API-kulcs használatával szakaszt választotta. Éles forgatókönyvek esetén olyan lehetőségeket tekinthet meg, mint az Azure KeyVault. Ezek az egyszerűség kedvéért alkalmazásbeállításokként lettek hozzáadva ebben az esetben.
Az összes alkalmazásbeállítás hozzáadása után kattintson a Mentés, majd a Folytatás gombra.

Name (Név)	Value
`Authentication:ApiKey`	<api_key_value>
`NotificationHub:Name`	<hub_name_value>
`NotificationHub:ConnectionString`	<hub_connection_string_value>

A háttérszolgáltatás közzététele

Ezután üzembe helyezi az alkalmazást az API-alkalmazásban, hogy minden eszközről elérhető legyen.

Megjegyzés

Az alábbi lépések a Visual Studio for Mac vonatkoznak. Ha windowsos Visual Studio 2019-et követ, a közzétételi folyamat más lesz. Lásd: Közzététel Azure App Service Windows rendszeren.

Ha még nem tette meg, módosítsa a konfigurációt HibakeresésrőlKiadásra .
Ellenőrzés + Kattintson a PushDemoApi projektre, majd válassza a Közzététel az Azure-ban... lehetőséget a Közzététel menüben.
Kövesse a hitelesítési folyamatot, ha a rendszer erre kéri. Használja az előző létrehozási API-alkalmazás szakaszban használt fiókot.
Jelölje ki a korábban a listából a közzétételi célként létrehozott Azure App Service API-alkalmazást, majd kattintson a Közzététel gombra.

Miután befejezte a varázslót, közzéteszi az alkalmazást az Azure-ban, majd megnyitja az alkalmazást. Jegyezze fel az URL-címet , ha még nem tette meg. Ez az URL-cím az oktatóanyag későbbi részében használt háttérbeli végpont .

A közzétett API ellenőrzése

A Postmanben nyisson meg egy új lapot, állítsa a kérelmet PUT értékre, és adja meg az alábbi címet. Cserélje le a helyőrzőt arra az alapcímre, amelyről az előző közzétételi háttérszolgáltatás szakaszban feljegyzett.
```
https://<app_name>.azurewebsites.net/api/notifications/installations
```
Megjegyzés

Az alapcím formátuma legyen https://<app_name>.azurewebsites.net/
Ha az ügyfelek hitelesítése API-kulcs használatával szakaszt választotta, mindenképpen konfigurálja úgy a kérésfejléceket, hogy tartalmazzák az apikey értékét.

Kulcs Value

apikey <your_api_key>
Válassza ki a törzs nyers beállítását, majd a formátumbeállítások listájában válassza a JSON lehetőséget, majd adjon meg néhány helyőrző JSON-tartalmat:
```
{}
```
Kattintson a küldése.

Megjegyzés

422 UnprocessableEntity állapotot kell kapnia a szolgáltatástól.
Végezze el ismét az 1–4. lépést, de ezúttal adja meg a kérések végpontját annak ellenőrzéséhez, hogy 400 hibás kérésre adott válasz érkezik-e.
```
https://<app_name>.azurewebsites.net/api/notifications/requests
```

Kulcs	Value
apikey	<your_api_key>

Megjegyzés

Az API-t még nem lehet érvényes kérelemadatokkal tesztelni, mivel ehhez platformspecifikus információkra lesz szükség az ügyfél-mobilalkalmazásból.

Platformfüggetlen Xamarin.Forms-alkalmazás létrehozása

Ebben a szakaszban egy Xamarin.Forms mobilalkalmazást hoz létre, amely platformfüggetlen módon implementálja a leküldéses értesítéseket.

Lehetővé teszi az értesítési központ regisztrációját és regisztrációjának törlését a létrehozott háttérszolgáltatáson keresztül.

Riasztás jelenik meg, ha egy művelet meg van adva, és az alkalmazás az előtérben van. Ellenkező esetben az értesítések megjelennek az értesítési központban.

Megjegyzés

A regisztrációs (és törlési) műveleteket általában az alkalmazás életciklusának megfelelő pontján (vagy esetleg az első futtatás részeként) hajtaná végre explicit felhasználói regisztráció/regisztráció törlése nélkül. Ebben a példában azonban explicit felhasználói bevitelre lesz szükség ahhoz, hogy ez a funkció könnyebben megvizsgálható és tesztelhető legyen.

A Xamarin.Forms-megoldás létrehozása

A Visual Studióban hozzon létre egy új Xamarin.Forms-megoldást sablonként az Üres űrlapok alkalmazással , és adja meg a PushDemo nevet a projektnévhez.

Megjegyzés

Az Üres űrlapok alkalmazás konfigurálása párbeszédpanelen győződjön meg arról, hogy a szervezeti azonosító megegyezik a korábban használt értékkel, és hogy az Android - és iOS-példányok is be vannak jelölve.
Ellenőrzés + Kattintson a PushDemo megoldásra, majd válassza a NuGet-csomagok frissítése lehetőséget.
Ellenőrzés + Kattintson a PushDemo megoldásra, majd válassza a NuGet-csomagok kezelése lehetőséget...
Keresse meg a Newtonsoft.Json fájlt, és ellenőrizze, hogy be van-e jelölve.
Kattintson a Csomagok hozzáadása, majd az Elfogadás gombra, amikor a rendszer a licencfeltételek elfogadására kéri.
Hozza létre és futtassa az alkalmazást minden célplatformon (Command + Enter), hogy tesztelje a sablonalapú alkalmazás futtatását az eszközön(ok)on.

Platformfüggetlen összetevők implementálása

Ellenőrzés + Kattintson a PushDemo projektre, válassza az Új mappa lehetőséget a Hozzáadás menüben, majd kattintson a Hozzáadásmodellek használatával mappanévként elemre.
Ellenőrzés + Kattintson a Modellek mappára, majd válassza az Új fájl... lehetőséget a Hozzáadás menüben.

Válassza az Általános>üres osztály lehetőséget, írja be DeviceInstallation.cs, majd adja hozzá a következő implementációt.

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

Adjon hozzá egy Empty Enumeration (Üres számbavétel) elemet az PushDemoAction.cs nevű Models mappához az alábbi implementációval.
```
namespace PushDemo.Models
{
    public enum PushDemoAction
    {
        ActionA,
        ActionB
    }
}
```

Adjon hozzá egy új mappát a Services nevű PushDemo projekthez, majd adjon hozzá egy Üres osztályt a ServiceContainer.cs nevű mappához az alábbi implementációval.

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

Megjegyzés

Ez a ServiceContainer osztály levágott verziója az XamCAT-adattárból . Kis súlyú IoC-tárolóként (Inversion of Control) fogjuk használni.

Adjon hozzá egy üres felületet a IDeviceInstallationService.cs nevű Services mappához, majd adja hozzá a következő kódot.
```
using PushDemo.Models;

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

Ezt a felületet később minden cél implementálja és elindítja, hogy biztosítsa a háttérszolgáltatás által igényelt platformspecifikus funkciókat és DeviceInstallation-információkat .

Adjon hozzá egy másik Üres felületet a Services mappához INotificationRegistrationService.cs néven, majd adja hozzá a következő kódot.

using System.Threading.Tasks;

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

Megjegyzés

Ez kezeli az ügyfél és a háttérszolgáltatás közötti interakciót.

Adjon hozzá egy másik Üres felületet a Services mappához INotificationActionService.cs néven, majd adja hozzá a következő kódot.
```
namespace PushDemo.Services
{
    public interface INotificationActionService
    {
        void TriggerAction(string action);
    }
}
```
Megjegyzés

Ez egy egyszerű mechanizmus, amellyel központosíthatja az értesítési műveletek kezelését.
Adjon hozzá egy Üres felületet az INotificationActionService szolgáltatásból származó IPushDemoNotificationActionService.cs nevű Services mappához az alábbi implementációval.
```
using System;
using PushDemo.Models;

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

Ez a típus a PushDemo alkalmazásra jellemző, és a PushDemoAction enumerálás használatával azonosítja az erősen gépelt módon aktivált műveletet.

Adjon hozzá egy Üres osztályt a Services mappához NotificationRegistrationService.cs az INotificationRegistrationService implementálásához az alábbi kóddal.

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

Megjegyzés

Az apiKey argumentum csak akkor szükséges, ha az Ügyfelek hitelesítése API-kulcs használatával szakaszt választotta.

Adjon hozzá egy Üres osztályt az IPushDemoNotificationActionService PushDemoNotificationActionService.cs nevű Services mappához az alábbi kóddal.

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

Adjon hozzá egy Üres osztályt a Config.cs nevű PushDemo-projekthez az alábbi implementációval.
```
namespace PushDemo
{
    public static partial class Config
    {
        public static string ApiKey = "API_KEY";
        public static string BackendServiceEndpoint = "BACKEND_SERVICE_ENDPOINT";
    }
}
```
Megjegyzés

Ez egy egyszerű módszer arra, hogy a titkos kulcsokat ne legyen forráskontroll. Ezeket az értékeket lecserélheti egy automatikus build részeként, vagy felülbírálhatja őket egy helyi részleges osztály használatával. Ezt a következő lépésben fogja megtenni.

Az ApiKey mező csak akkor szükséges, ha az Ügyfelek hitelesítése API-kulcs használatával szakaszt választotta.
Adjon hozzá egy másik Üres osztályt a PushDemo projekthez, amelynek neve ezúttal Config.local_secrets.cs a következő implementációval.
```
namespace PushDemo
{
    public static partial class Config
    {
        static Config()
        {
            ApiKey = "<your_api_key>";
            BackendServiceEndpoint = "<your_api_app_url>";
        }
    }
}
```
Megjegyzés

Cserélje le a helyőrző értékeket a saját értékére. Ezeket fel kellett volna jegyeznie a háttérszolgáltatás létrehozásakor. Az API-alkalmazás URL-címének a következőnek kell lennie https://<api_app_name>.azurewebsites.net/: . Ne felejtse el hozzáadni *.local_secrets.* a gitignore-fájlhoz a fájl véglegesítésének elkerülése érdekében.

Az ApiKey mező csak akkor szükséges, ha az Ügyfelek hitelesítése API-kulcs használatával szakaszt választotta.

Adjon hozzá egy Üres osztályt a Bootstrap.cs nevű PushDemo-projekthez a következő implementációval.

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

Megjegyzés

A Begin metódust minden platform meghívja, amikor az alkalmazás elindítja az IDeviceInstallationService platformspecifikus implementációját.

A NotificationRegistrationServiceapiKey konstruktor argumentum csak akkor szükséges, ha az Ügyfelek hitelesítése API-kulcs használatával szakaszt választotta.

A platformfüggetlen felhasználói felület implementálása

A PushDemo projektben nyissa meg a MainPage.xaml fájlt, és cserélje le a StackLayout vezérlőt a következőre.

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

Most MainPage.xaml.cs adjon hozzá egy egyszerű háttérmezőt az INotificationRegistrationService implementációra mutató hivatkozás tárolásához.
```
readonly INotificationRegistrationService _notificationRegistrationService;
```
A MainPage konstruktorban oldja fel az INotificationRegistrationService implementációt a ServiceContainer használatával, és rendelje hozzá a notificationRegistrationService háttérmezőhöz.
```
public MainPage()
{
    InitializeComponent();

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

Implementálja a RegisterButton és a DeregisterButton gombok eseménykezelőit A megfelelő Regisztráció/törlése metódusokat meghívó Kattintásra események elemre kattintott.

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

Most a App.xaml.cs győződjön meg arról, hogy a következő névterekre hivatkozik.

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

Implementálja az IPushDemoNotificationActionServiceActionTriggered esemény eseménykezelőt .

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

Az alkalmazáskonstruktorban oldja fel az IPushNotificationActionService implementációt a ServiceContainer használatával, és iratkozzon fel az IPushDemoNotificationActionServiceActionTriggered eseményre.
```
public App()
{
    InitializeComponent();

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

    MainPage = new MainPage();
}
```
Megjegyzés

Ez egyszerűen a leküldéses értesítési műveletek fogadásának és propagálásának szemléltetésére való. Ezeket általában csendesen kezelik, például egy adott nézetre navigálnak, vagy bizonyos adatokat frissítenek ahelyett, hogy riasztást jelenítenének meg a MainPagegyökéroldalán keresztül ebben az esetben.

A natív Android-projekt konfigurálása leküldéses értesítésekhez

Csomag nevének és engedélyeinek ellenőrzése

A PushDemo.Android fájlban nyissa meg a Projektbeállítások , majd az Android-alkalmazás lehetőséget a Build (Build ) szakaszban.
Ellenőrizze, hogy a Csomag neve megegyezik-e a Firebase ConsolePushDemo projektben használt értékkel. A Csomag neve a következő formátumban com.<organization>.pushdemovolt: .
Állítsa a Minimális Android-verziótAndroid 8.0 -ra (API level 26) és a Target Android Version (Cél Android-verzió ) értékre a legújabb API-szintre.

Megjegyzés

Ebben az oktatóanyagban csak az API 26-os vagy újabb verzióját futtató eszközök támogatottak, de kiterjesztheti a régebbi verziókat futtató eszközökre.
Győződjön meg arról, hogy az INTERNET és a READ_PHONE_STATE engedélyek engedélyezve vannak a Szükséges engedélyek területen.
Kattintson az OK gombra

Adja hozzá a Xamarin Google Play Services alap- és Xamarin.Firebase.Messaging csomagokat

A PushDemo.Android + vezérlőbenkattintson a Csomagok mappára, majd válassza a NuGet-csomagok kezelése... lehetőséget.
Keressen rá a Xamarin.GooglePlayServices.Base kifejezésre (nem pedig a Basement kifejezésre), és ellenőrizze, hogy be van-e jelölve.
Keressen rá a Xamarin.Firebase.Messaging kifejezésre , és ellenőrizze, hogy be van-e jelölve.
Kattintson a Csomagok hozzáadása, majd az Elfogadás gombra, amikor a rendszer a licencfeltételek elfogadására kéri.

A Google Services JSON-fájljának hozzáadása

Ellenőrzés + Kattintson a projektre, majd válassza a PushDemo.AndroidMeglévő fájl... lehetőséget a Hozzáadás menüben.
Válassza ki a Firebase-konzolPushDemo-projektjének beállításakor korábban letöltött google-services.json fájlt, majd kattintson a Megnyitás gombra.
Amikor a rendszer kéri, válassza a Fájl másolása a könyvtárba lehetőséget.
Ellenőrzés + Kattintson az google-services.json fájlra a projekten belül, majd győződjön meg arról, hogy a PushDemo.AndroidGoogleServicesJsonösszeállítási műveletként van beállítva.

Leküldéses értesítések kezelése Android rendszeren

Ellenőrzés + Kattintson a projektre, válassza az PushDemo.AndroidÚj mappa lehetőséget a Hozzáadás menüben, majd kattintson a Hozzáadásszolgáltatások használatával mappanévként elemre.
Ellenőrzés + Kattintson a Szolgáltatások mappára, majd válassza az Új fájl... lehetőséget a Hozzáadás menüben.

Válassza az Általános>üres osztály lehetőséget, írja be DeviceInstallationService.cs a Név mezőbe, majd kattintson az Új elemre a következő implementáció hozzáadása gombra.

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

Megjegyzés

Ez az osztály egyedi azonosítót biztosít ( Secure.AndroidId használatával) az értesítési központ regisztrációs hasznos adatainak részeként.

Adjon hozzá egy másik Üres osztályt az PushNotificationFirebaseMessagingService.cs nevű Services mappához, majd adja hozzá a következő implementációt.

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

A MainActivity.cs győződjön meg arról, hogy a következő névterek lettek hozzáadva a fájl elejéhez.

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;

A MainActivity.cs állítsa a LaunchMode értékétSingleTop értékre, így a MainActivity nem jön létre újra a megnyitáskor.

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

Adjon hozzá privát tulajdonságokat és a megfelelő háttérmezőket az IPushNotificationActionService és az IDeviceInstallationService implementációkra mutató hivatkozás tárolásához.

IPushDemoNotificationActionService _notificationActionService;
IDeviceInstallationService _deviceInstallationService;

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

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

Implementálja az IOnSuccessListener felületet a Firebase-jogkivonat lekéréséhez és tárolásához.

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

Adjon hozzá egy ProcessNotificationActions nevű új metódust , amely ellenőrzi, hogy egy adott szándék rendelkezik-e egy művelet nevű extra értékkel. A művelet feltételes aktiválása az IPushDemoNotificationActionService implementációval.

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

Bírálja felül az OnNewIntentmetódust a ProcessNotificationActions metódus meghívásához.
```
protected override void OnNewIntent(Intent intent)
{
    base.OnNewIntent(intent);
    ProcessNotificationActions(intent);
}
```
Megjegyzés

Mivel a TevékenységLaunchMode tulajdonságaSingleTop értékre van állítva, a rendszer az OnNewIntent metódus helyett az OnNewIntent metódussal küld egy szándékot a meglévő tevékenységpéldánynak, így a bejövő szándékot az OnCreate és az OnNewIntent metódusban is kezelnie kell.
Frissítse az OnCreate metódust , hogy közvetlenül a hívás után hívja Bootstrap.Begin meg base.OnCreate az IDeviceInstallationService platformspecifikus implementációját.
```
Bootstrap.Begin(() => new DeviceInstallationService());
```
Ugyanebben a metódusban feltételesen hívja meg a GetInstanceId azonosítót a FirebaseApp-példányon közvetlenül a hívás Bootstrap.Beginután, és vegye fel a MainActivity elemet IOnSuccessListenerként.
```
if (DeviceInstallationService.NotificationsSupported)
{
    FirebaseInstanceId.GetInstance(Firebase.FirebaseApp.Instance)
        .GetInstanceId()
        .AddOnSuccessListener(this);
}
```
Továbbra is az OnCreate-ban hívja meg a ProcessNotificationActions parancsot közvetlenül az aktuális szándék átadására irányuló LoadApplication hívás után.
```
...

LoadApplication(new App());

ProcessNotificationActions(Intent);
```

Megjegyzés

A leküldéses értesítések fogadásához minden futtatáskor újra regisztrálnia kell az alkalmazást, és le kell állítania egy hibakeresési munkamenetből.

A natív iOS-projekt konfigurálása leküldéses értesítésekhez

Az Info.plist és az Entitlements.plist konfigurálása

Győződjön meg arról, hogy bejelentkezett apple-fejlesztői fiókjába a Visual Studio>Beállításai...>Közzétételi>Az Apple Fejlesztői fiókok és a megfelelő tanúsítvány- és kiépítési profil le lett töltve. Ezeket az eszközöket az előző lépések részeként kellett volna létrehoznia.
A PushDemo.iOS-ben nyissa meg az Info.plist fájlt, és győződjön meg arról, hogy a BundleIdentifier megegyezik az Apple fejlesztői portálon a megfelelő kiépítési profilhoz használt értékkel. A BundleIdentifier formátuma com.<organization>.PushDemo.
Ugyanebben a fájlban állítsa a Minimális rendszerverzió13.0 értékre.

Megjegyzés

Ebben az oktatóanyagban csak az iOS 13.0-s vagy újabb verzióját futtató eszközök támogatottak, de kiterjesztheti a régebbi verziókat futtató eszközökre.
Nyissa meg a PushDemo.iOSprojektbeállításai lehetőséget (kattintson duplán a projektre).
A Projektbeállítások területen, az iOS-csomagaláírás létrehozása >területen győződjön meg arról, hogy a Fejlesztői fiók a Csapat területen van kiválasztva. Ezután győződjön meg arról, hogy az "Aláírás automatikus kezelése" lehetőség van kiválasztva, és az aláíró tanúsítvány és a kiépítési profil automatikusan ki van jelölve.

Megjegyzés

Ha az aláíró tanúsítvány és a kiépítési profil nincs automatikusan kiválasztva, válassza a Manuális kiépítés lehetőséget, majd kattintson a Csomagaláírási beállítások elemre. Győződjön meg arról, hogy a csapat ki van jelölve az Aláíróidentitás beállításhoz, és a PushDemo-specifikus kiépítési profil ki van választva a Kiépítési profil beállításhoz a hibakeresési és kiadási konfigurációk esetében is, biztosítva, hogy mindkét esetben az iPhone legyen kiválasztva a platformhoz .
A PushDemo.iOS-ben nyissa meg az Entitlements.plist fájlt, és győződjön meg arról, hogy a Leküldéses értesítések engedélyezése jelölőnégyzet be van jelölve a Jogosultságok lapon való megtekintéskor. Ezután győződjön meg arról, hogy az APS-környezet beállítás fejlesztési értékre van állítva a Forrás lapon való megtekintéskor.

Leküldéses értesítések kezelése iOS rendszeren

Ellenőrzés + Kattintson a PushDemo.iOS projektre, válassza az Új mappa lehetőséget a Hozzáadás menüben, majd kattintson a Hozzáadásszolgáltatások használatával mappanévként elemre.
Ellenőrzés + Kattintson a Szolgáltatások mappára, majd válassza az Új fájl... lehetőséget a Hozzáadás menüben.

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

Megjegyzés

Ez az osztály egyedi azonosítót biztosít (az UIDevice.IdentifierForVendor érték használatával) és az értesítési központ regisztrációs hasznos adatait.

Adjon hozzá egy új mappát a PushDemo.iOSprojekthez Extensions néven, majd adjon hozzá egy Empty Class (Üres osztály ) nevű mappát NSDataExtensions.cs nevű mappához az alábbi implementációval.

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

A AppDelegate.cs győződjön meg arról, hogy a következő névterek lettek hozzáadva a fájl elejéhez.

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;

Adjon hozzá privát tulajdonságokat és a hozzájuk tartozó háttérmezőket az IPushDemoNotificationActionService, az INotificationRegistrationService és az IDeviceInstallationService implementációkra mutató hivatkozás tárolásához.

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

Adja hozzá a RegisterForRemoteNotifications metódust a felhasználói értesítési beállítások regisztrálásához, majd az APNS-sel történő távoli értesítésekhez.

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

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

Adja hozzá a CompleteRegistrationAsync metódust a IDeviceInstallationService.Token tulajdonságérték beállításához. Frissítse a regisztrációt, és gyorsítótárazza az eszköz jogkivonatát, ha az utolsó tárolás óta frissült.
```
Task CompleteRegistrationAsync(NSData deviceToken)
{
    DeviceInstallationService.Token = deviceToken.ToHexString();
    return NotificationRegistrationService.RefreshRegistrationAsync();
}
```

Adja hozzá a ProcessNotificationActions metódust az NSDictionary értesítési adatok feldolgozásához és a NotificationActionService.TriggerAction feltételes meghívásához.

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

Bírálja felül a RegisteredForRemoteNotifications metódust , amely átadja a deviceToken argumentumot a CompleteRegistrationAsync metódusnak.

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

Bírálja felül a ReceivedRemoteNotification metódust , amely átadja a userInfo argumentumot a ProcessNotificationActions metódusnak .

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

A hiba naplózásához felülbírálja a FailedToRegisterForRemoteNotifications metódust .
```
public override void FailedToRegisterForRemoteNotifications(
    UIApplication application,
    NSError error)
    => Debug.WriteLine(error.Description);
```
Megjegyzés

Ez nagyon sok helyőrző. Az éles forgatókönyvekhez megfelelő naplózást és hibakezelést kell implementálnia.
Frissítse a FinishedLaunching metódust , hogy közvetlenül a hívás után hívja Bootstrap.Begin meg Forms.Init az IDeviceInstallationService platformspecifikus implementációját.
```
Bootstrap.Begin(() => new DeviceInstallationService());
```

Ugyanebben a módszerben feltételesen kérjen engedélyt, és regisztráljon a távoli értesítésekre közvetlenül a következő után Bootstrap.Begin: .

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

Továbbra is a FinishedLaunching alatt hívja meg a ProcessNotificationActions parancsot közvetlenül a hívás LoadApplication után, ha a beállítások argumentum tartalmazza az UIApplication.LaunchOptionsRemoteNotificationKey értéket, amely az eredményül kapott userInfo objektumnak ad át.
```
using (var userInfo = options?.ObjectForKey(
    UIApplication.LaunchOptionsRemoteNotificationKey) as NSDictionary)
        ProcessNotificationActions(userInfo);
```

A megoldás teszteléséhez

Mostantól tesztelheti az értesítések küldését a háttérszolgáltatáson keresztül.

Tesztértesítés küldése

Nyisson meg egy új lapon Postman.

A kérelem beállítása POST, és adja meg a következő címre:

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

Ha az ügyfelek hitelesítése API-kulcs használatával szakaszt választotta, mindenképpen konfigurálja úgy a kérésfejléceket, hogy tartalmazzák az apikey értékét.

Kulcs Value

apikey <your_api_key>
Válassza ki a törzs nyers beállítását, majd a formátumbeállítások listájában válassza a JSON lehetőséget, majd adjon meg néhány helyőrző JSON-tartalmat:
```
{
    "text": "Message from Postman!",
    "action": "action_a"
}
```
Válassza a Kód gombot, amely az ablak jobb felső sarkában található Mentés gomb alatt található. A kérésnek az alábbi példához hasonlóan kell kinéznie a HTML-hez való megjelenítéskor (attól függően, hogy tartalmazott-e apikey fejlécet):
```
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"
}
```
Futtassa a PushDemo alkalmazást az egyik vagy mindkét célplatformon (Android és iOS).

Megjegyzés

Ha Androidon tesztel, győződjön meg arról, hogy nem a Hibakeresésben fut, vagy ha az alkalmazást az alkalmazás futtatásával telepítette, kényszerítse az alkalmazás bezárását, és indítsa újra a indítóból.
A PushDemo alkalmazásban koppintson a Regisztráció gombra.
A Postmanben zárja be a Kódrészletek létrehozása ablakot (ha még nem tette meg), majd kattintson a Küldés gombra.
Ellenőrizze, hogy kap-e 200 OK-választ a Postmanben , és a riasztás megjelenik az alkalmazásban, amelyen az ActionA művelet érkezett.
Zárja be a PushDemo alkalmazást, majd kattintson ismét a Küldés gombra a Postmanben.
Ellenőrizze, hogy ismét 200 OK-választ kap-e a Postmanben . Ellenőrizze, hogy a megfelelő üzenettel jelenik-e meg egy értesítés a PushDemo alkalmazás értesítési területén.
Koppintson az értesítésre annak megerősítéséhez, hogy megnyitja az alkalmazást, és megjeleníti a kapott ActionA művelet riasztását.
A Postmanben módosítsa az előző kérelemtörzset úgy, hogy csendes értesítést küldjön, amely action_b a műveletértékaction_a helyett.
```
{
    "action": "action_b",
    "silent": true
}
```
Ha az alkalmazás továbbra is nyitva van, kattintson a Küldés gombra a Postmanben.
Ellenőrizze, hogy 200 OK-választ kap-e a Postmanben, és hogy a riasztás megjelenik-e az alkalmazásban, amely a kapott ActionA művelet helyett az ActionB-műveletet jeleníti meg.
Zárja be a PushDemo alkalmazást, majd kattintson ismét a Küldés gombra a Postmanben.
Ellenőrizze, hogy 200 OK-választ kap-e a Postmanben , és hogy a csendes értesítés nem jelenik-e meg az értesítési területen.

Kulcs	Value
apikey	<your_api_key>

Hibaelhárítás

Nincs válasz a háttérszolgáltatástól

Helyi teszteléskor győződjön meg arról, hogy a háttérszolgáltatás fut, és a megfelelő portot használja.

Ha az Azure API-alkalmazáson tesztel, ellenőrizze, hogy a szolgáltatás fut-e, és üzembe lett-e helyezve, és hiba nélkül elindult-e.

Győződjön meg arról, hogy helyesen adta meg az alapcímet a Postmanben vagy a mobilalkalmazás konfigurációjában az ügyfélen keresztüli teszteléskor. Az alapcímnek indikatív módon vagy https://localhost:5001/ helyi teszteléskor kell lenniehttps://<api_name>.azurewebsites.net/.

Hibakeresési munkamenet indítása vagy leállítása után nem érkezik értesítés Androidon

Győződjön meg arról, hogy a hibakeresési munkamenet elindítása vagy leállítása után ismét regisztrál. A hibakereső új Firebase-jogkivonatot hoz létre. Az értesítési központ telepítését is frissíteni kell.

401-es állapotkód fogadása a háttérszolgáltatásból

Ellenőrizze, hogy az apikey-kérelem fejlécét állítja-e be, és ez az érték megegyezik a háttérszolgáltatáshoz konfigurált értékkel.

Ha ezt a hibát a helyi tesztelés során kapja, győződjön meg arról, hogy az ügyfélkonfigurálásban megadott kulcsérték megegyezik az API által használt Authentication:ApiKey felhasználóbeállítási értékkel.

Ha API-alkalmazással tesztel, győződjön meg arról, hogy az ügyfél konfigurációs fájljának kulcsértéke megegyezik az API-alkalmazásban használt Authentication:ApiKey alkalmazásbeállítással.

Megjegyzés

Ha ezt a beállítást a háttérszolgáltatás üzembe helyezése után hozta létre vagy módosította, a szolgáltatás érvénybe lépéséhez újra kell indítania a szolgáltatást.

Ha úgy döntött, hogy nem végzi el az ügyfelek hitelesítése API-kulcs használatával szakaszt , győződjön meg arról, hogy nem alkalmazta az Authorize attribútumot az NotificationsController osztályra.

404-es állapotkód fogadása a háttérszolgáltatásból

Ellenőrizze, hogy a végpont és a HTTP-kérelem metódusa helyes-e. A végpontoknak például a következőnek kell lenniük:

[PUT]https://<api_name>.azurewebsites.net/api/notifications/installations
[TÖRLÉS]https://<api_name>.azurewebsites.net/api/notifications/installations/<installation_id>
[POST]https://<api_name>.azurewebsites.net/api/notifications/requests

Vagy helyi tesztelés esetén:

[PUT]https://localhost:5001/api/notifications/installations
[TÖRLÉS]https://localhost:5001/api/notifications/installations/<installation_id>
[POST]https://localhost:5001/api/notifications/requests

Amikor megadja az alapcímet az ügyfélalkalmazásban, győződjön meg arról, hogy a végződése egy /. Az alapcímnek indikatív módon vagy https://localhost:5001/ helyi teszteléskor kell lenniehttps://<api_name>.azurewebsites.net/.

Nem lehet regisztrálni, és megjelenik egy értesítési központ hibaüzenete

Ellenőrizze, hogy a teszteszköz rendelkezik-e hálózati kapcsolattal. Ezután határozza meg a Http-válasz állapotkódját úgy, hogy beállít egy töréspontot a HttpResponseStatusCode tulajdonságértékének vizsgálatához.

Ha lehetséges, tekintse át az előző hibaelhárítási javaslatokat az állapotkód alapján.

Állítson be egy töréspontot azokra a sorokra, amelyek ezeket a konkrét állapotkódokat adják vissza a megfelelő API-hoz. Ezután próbálja meg meghívni a háttérszolgáltatást helyi hibakereséskor.

Ellenőrizze, hogy a háttérszolgáltatás a várt módon működik-e a Postmanen keresztül a megfelelő hasznos adatok használatával. Használja a szóban forgó platform ügyfélkódja által létrehozott tényleges hasznos adatokat.

Tekintse át a platformspecifikus konfigurációs szakaszokat, hogy biztosan ne maradjon le a lépésekről. Ellenőrizze, hogy a megfelelő értékek és token változók feloldása installation id folyamatban van-e a megfelelő platformon.

Nem sikerült feloldani az eszköz azonosítóját hibaüzenet jelenik meg

Tekintse át a platformspecifikus konfigurációs szakaszokat, hogy biztosan ne maradjon le a lépésekről.

További lépések

Most már rendelkeznie kell egy alapszintű Xamarin.Forms-alkalmazással, amely egy háttérszolgáltatáson keresztül csatlakozik egy értesítési központhoz, és képes értesítéseket küldeni és fogadni.

Az oktatóanyagban használt példát valószínűleg a saját forgatókönyvéhez kell igazítania. A robusztusabb hibakezelés, az újrapróbálkozási logika és a naplózás megvalósítása is ajánlott.

A Visual Studio App Center gyorsan beépíthető mobilalkalmazásokba , amelyek elemzéseket és diagnosztikát biztosítanak a hibaelhárítás elősegítéséhez.

Oktatóanyag: Leküldéses értesítések küldése Xamarin.Forms-alkalmazásokba az Azure Notification Hubs használatával háttérszolgáltatáson keresztül

Előfeltételek

Leküldéses értesítési szolgáltatások és az Azure Notification Hub beállítása

Firebase-projekt létrehozása és a Firebase Cloud Messaging engedélyezése Androidhoz

iOS-alkalmazás regisztrálása leküldéses értesítésekhez

Tanúsítvány létrehozása a Notification Hubshoz

1. LEHETŐSÉG: P12 leküldéses tanúsítvány létrehozása, amely közvetlenül a Notification Hubra tölthető fel

2. LEHETŐSÉG: Jogkivonatalapú hitelesítéshez használható p8-tanúsítvány létrehozása

Üzembe helyezési profil létrehozása az alkalmazáshoz

Értesítési központ létrehozása

A Notification Hub konfigurálása APNS-adatokkal

1. LEHETŐSÉG: .p12 leküldéses tanúsítvány használata

2. LEHETŐSÉG: Jogkivonatalapú hitelesítés használata

Az értesítési központ konfigurálása FCM-adatokkal

ASP.NET Core Webes API háttéralkalmazás létrehozása

Webes projekt létrehozása

Ügyfelek hitelesítése API-kulccsal (nem kötelező)

Függőségek hozzáadása és szolgáltatások konfigurálása

Az értesítési API létrehozása

Az API-alkalmazás létrehozása

A háttérszolgáltatás közzététele

A közzétett API ellenőrzése

Platformfüggetlen Xamarin.Forms-alkalmazás létrehozása

A Xamarin.Forms-megoldás létrehozása

Platformfüggetlen összetevők implementálása

A platformfüggetlen felhasználói felület implementálása

A natív Android-projekt konfigurálása leküldéses értesítésekhez

Csomag nevének és engedélyeinek ellenőrzése

Adja hozzá a Xamarin Google Play Services alap- és Xamarin.Firebase.Messaging csomagokat

A Google Services JSON-fájljának hozzáadása

Leküldéses értesítések kezelése Android rendszeren

A natív iOS-projekt konfigurálása leküldéses értesítésekhez

Az Info.plist és az Entitlements.plist konfigurálása

Leküldéses értesítések kezelése iOS rendszeren

A megoldás teszteléséhez

Tesztértesítés küldése

Hibaelhárítás

Nincs válasz a háttérszolgáltatástól

Hibakeresési munkamenet indítása vagy leállítása után nem érkezik értesítés Androidon

401-es állapotkód fogadása a háttérszolgáltatásból

404-es állapotkód fogadása a háttérszolgáltatásból

Nem lehet regisztrálni, és megjelenik egy értesítési központ hibaüzenete

Nem sikerült feloldani az eszköz azonosítóját hibaüzenet jelenik meg

Kapcsolódó hivatkozások

További lépések

További források