Kurz: Odesílání nabízených oznámení do aplikací .NET MAUI pomocí služby Azure Notification Hubs prostřednictvím back-endové služby

Článek
08/07/2024

Nabízená oznámení doručí informace z back-endového systému do klientské aplikace. Apple, Google a další platformy mají svoji vlastní službu nabízených oznámení (PNS). Azure Notification Hubs umožňuje centralizovat oznámení napříč platformami, aby vaše back-endová aplikace mohla komunikovat s jedním centrem, které se postará o distribuci oznámení do jednotlivých sítí PNS.

Azure Notification Hubs vyžaduje, aby se aplikace zaregistrovaly v centru a volitelně definovaly šablony nebo se přihlásily k odběru značek:

Provedení instalace zařízení propojuje popisovač PNS s identifikátorem v Centru oznámení Azure. Další informace o registracích najdete v tématu Správa registrací.
Šablony umožňují zařízením zadat parametrizované šablony zpráv. Příchozí zprávy je možné přizpůsobit na zařízení. Další informace najdete v tématu Šablony Notification Hubs.
Značky se dají použít k odběru kategorií zpráv, jako jsou zprávy, sporty a počasí. Další informace najdete v tématu Směrování a výrazy značek.

V tomto kurzu použijete Azure Notification Hubs k odesílání nabízených oznámení do aplikace .NET Pro více platforem (.NET MAUI), která cílí na Android a iOS. Back-end webového rozhraní API ASP.NET Core se používá ke zpracování registrace zařízení pro klienta a k zahájení nabízeného oznámení. Tyto operace se zpracovávají pomocí balíčku NuGet Microsoft.Azure.NotificationHubs . Další informace o celkovém přístupu najdete v tématu Správa registrací z back-endu.

V tomto kurzu se naučíte:

Nastavte služby nabízených oznámení a Centrum oznámení Azure.
Vytvořte back-endovou aplikaci ASP.NET Core WebAPI.
Vytvoření aplikace .NET MAUI
Nakonfigurujte aplikaci pro Android pro nabízená oznámení.
Nakonfigurujte aplikaci pro iOS pro nabízená oznámení.
Otestujete aplikaci.
Vyřešte případné problémy s nastavením a konfigurací.

Požadavky

K dokončení tohoto kurzu budete potřebovat:

Účet Azure s aktivním předplatným.
Počítač PC nebo Mac s nejnovější verzí sady Visual Studio/Visual Studio Code s úlohou vývoje uživatelského rozhraní pro více platforem .NET a nainstalovanými úlohami ASP.NET a vývoje webu.

Pro Android musíte mít:

Vývojář odemčený fyzický zařízení nebo emulátor, na kterém běží rozhraní API 26 nebo novější s nainstalovanými službami Google Play.

Pro iOS musíte mít:

Aktivní vývojářský účet Apple.
Mac se systémem Xcode spolu s platným certifikátem vývojáře nainstalovaným do klíčenky.

Pak byste v iOSu měli mít:

Simulátor iOS 16 a novější, který běží v macOS 13+ na počítačích Mac s procesory Apple silicon nebo T2.

NEBO
Fyzické zařízení s iOSem zaregistrované ve vašem vývojářském účtu (se systémem iOS 13.0+).
Vaše fyzické zařízení zaregistrované ve vašem vývojářském účtu Apple a přidružené k vašemu certifikátu.

Důležité

Simulátor iOS podporuje vzdálená oznámení v iOSu 16+ při spuštění v macOS 13+ na počítačích Mac s procesory Apple silicon nebo T2. Pokud tyto požadavky na hardware nesplňujete, budete potřebovat aktivní vývojářský účet Apple a fyzické zařízení.

Pokud chcete postupovat podle tohoto kurzu, měli byste znát:

I když tento kurz cílí na Visual Studio, je možné ho sledovat pomocí editoru Visual Studio Code na počítači PC nebo Mac. Budou ale potřeba některé rozdíly shodovat. Například popisy uživatelského rozhraní a pracovních postupů, názvů šablon a konfigurace prostředí.

Nastavení služeb nabízených oznámení a Centra oznámení Azure

V této části nastavíte Firebase Cloud Messaging a Apple Push Notification Services (APNS). Pak vytvoříte a nakonfigurujete centrum oznámení Azure tak, aby fungovalo s těmito službami.

Vytvoření projektu Firebase

Vytvoření projektu Firebase:

Ve webovém prohlížeči se přihlaste ke konzole Firebase.
V konzole Firebase vyberte tlačítko Přidat projekt a vytvořte nový projekt Firebase a jako název projektu zadejte PushDemo.

Poznámka:

Pro vás se vygeneruje jedinečný název. Ve výchozím nastavení se skládá z malé varianty názvu, který jste zadali, plus vygenerované číslo oddělené pomlčkou. Pokud chcete, můžete to změnit za předpokladu, že vaše úpravy jsou stále globálně jedinečné.
Po vytvoření projektu vyberte logo Androidu a přidejte Firebase do aplikace pro Android:
Na stránce přidat Firebase na stránku aplikace pro Android zadejte název balíčku, volitelně přezdívku aplikace a vyberte tlačítko Zaregistrovat aplikaci:
Na stránce Přidat Firebase na stránku aplikace pro Android vyberte tlačítko Stáhnout google-services.json a před výběrem tlačítka Další soubor uložte do místní složky:
Na stránce Přidat Firebase na stránku aplikace pro Android vyberte tlačítko Další.
Na stránce Přidat Firebase na stránku aplikace pro Android vyberte tlačítko Pokračovat na konzolu.
V konzole Firebase vyberte ikonu Přehled projektu a pak vyberte Nastavení projektu:
V nastavení projektu vyberte kartu Zasílání zpráv v cloudu. Uvidíte, že je povolené rozhraní FIREBASE Cloud Messaging API (V1):
V nastavení projektu vyberte kartu Účty služeb a pak vyberte tlačítko Generovat nový privátní klíč.
V dialogovém okně Generovat nový privátní klíč vyberte tlačítko Generovat klíč :

Stáhne se soubor JSON, který bude obsahovat hodnoty, které zadáte do centra oznámení Azure.

Registrace aplikace pro iOS pro nabízená oznámení

Pokud chcete odesílat nabízená oznámení do aplikace pro iOS, musíte aplikaci zaregistrovat v Apple a zaregistrovat se k nabízeným oznámením. Toho lze dosáhnout provedením kroků v následující dokumentaci k Centru oznámení Azure:

Pokud chcete přijímat nabízená oznámení na fyzickém zařízení, budete také muset vytvořit zřizovací profil.

Důležité

Pokud chcete dostávat oznámení na pozadí v iOSu, musíte do aplikace přidat režim pozadí vzdálených oznámení. Další informace najdete v tématu Povolení funkce vzdálených oznámení na developer.apple.com.

Vytvoření centra oznámení Azure

Vytvoření centra oznámení na webu Azure Portal:

Ve webovém prohlížeči se přihlaste k webu Azure Portal.
Na webu Azure Portal klikněte na tlačítko Vytvořit prostředek a pak před výběrem tlačítka Vytvořit vyhledejte a zvolte Centrum oznámení.
Na stránce Centra oznámení proveďte následující kroky:
1. V poli Předplatné vyberte název předplatného Azure, které chcete použít, a pak vyberte existující skupinu prostředků nebo vytvořte novou.
2. Do pole Podrobnosti oboru názvů zadejte jedinečný název nového oboru názvů.
3. Do pole Podrobnosti centra oznámení zadejte název centra oznámení. To je povinné, protože obor názvů obsahuje jedno nebo více center oznámení.
4. V rozevíracím seznamu Umístění vyberte hodnotu, která určuje umístění, ve kterém chcete centrum oznámení vytvořit.
5. Zkontrolujte možnost Zóny dostupnosti. Pokud jste vybrali oblast, která má zóny dostupnosti, je ve výchozím nastavení zaškrtnuté políčko.
  
  Poznámka:
  
  Zóny dostupnosti jsou placenou funkcí, takže do vaší úrovně se přidá další poplatek.
6. Zvolte možnost zotavení po havárii: žádná, spárovaná oblast obnovení nebo flexibilní oblast obnovení. Pokud zvolíte spárovanou oblast obnovení, zobrazí se oblast převzetí služeb při selhání. Pokud vyberete flexibilní oblast obnovení, vyberte si z rozevíracího seznamu oblastí obnovení.
7. Vyberte tlačítko Vytvořit. Vytvoří se centrum oznámení.
Na webu Azure Portal přejděte do nově vytvořeného centra oznámení a pak přejděte do okna Spravovat > zásady přístupu.
V okně Zásady přístupu si poznamenejte připojovací řetězec DefaultFullSharedAccessSignature zásady. Budete to potřebovat později při vytváření back-endové služby, která komunikuje s centrem oznámení.

Další informace o vytvoření centra oznámení najdete v tématu Vytvoření centra oznámení Azure na webu Azure Portal.

Konfigurace služby Firebase Cloud Messaging v centru oznámení

Konfigurace centra oznámení pro komunikaci se službou Firebase Cloud Messaging:

Na webu Azure Portal přejděte do centra oznámení a vyberte okno Nastavení > Google (FCM v1).

V okně Google (FCM v1) zadejte hodnoty polí Private Key, Client Email a Project ID . Tyto hodnoty najdete v souboru JSON privátního klíče, který jste stáhli z Firebase Cloud Messaging:

Pole Azure	Klíč JSON	Příklad hodnoty JSON
Soukromý klíč	`private_key`	Tato hodnota by měla začínat `-----BEGIN PRIVATE KEY-----\n` a končit .`-----END PRIVATE KEY-----\n`
E-mail klienta	`client_email`	`firebase-adminsdk-55sfg@pushdemo-d6ab2.iam.gserviceaccount.com`
ID projektu	`project_id`	`pushdemo-d6ab2`

V okně Google (FCM v1) vyberte tlačítko Uložit .

Konfigurace služby Apple Push Notification Service v centru oznámení

Na webu Azure Portal přejděte do centra oznámení a vyberte okno Nastavení > Apple (APNS). Pak postupujte podle příslušných kroků na základě přístupu, který jste zvolili dříve při vytváření certifikátu pro centrum oznámení.

Důležité

Při nastavování režimu aplikace zvolte produkční , jenom pokud chcete odesílat nabízená oznámení uživatelům, kteří si aplikaci koupili ve Storu.

Možnost 1 – Použití certifikátu push .p12

V okně Apple (APNS) vyberte režim ověřování certifikátu .
V okně Apple (APNS) vyberte ikonu souboru vedle pole Nahrát certifikát . Pak vyberte soubor .p12, který jste vyexportovali dříve, a nahrajte ho.
V okně Apple (APNS) zadejte v případě potřeby heslo certifikátu do pole Heslo .
V okně Apple (APNS) vyberte režim aplikace sandboxu.
V okně Apple (APNS) vyberte tlačítko Uložit .

Možnost 2 – Použití ověřování založeného na tokenech

V okně Apple (APNS) vyberte režim ověřování tokenu.
V okně Apple (APNS) zadejte hodnoty, které jste předtím získali pro pole ID klíče, ID sady, ID týmu a tokenu.
V okně Apple (APNS) vyberte režim aplikace sandboxu.
V okně Apple (APNS) vyberte tlačítko Uložit .

Vytvoření back-endové aplikace webového rozhraní API ASP.NET Core

V této části vytvoříte back-end webového rozhraní API ASP.NET Core pro zpracování instalace zařízení a odesílání oznámení do aplikace .NET MAUI.

Vytvoření projektu webového rozhraní API

Vytvoření projektu webového rozhraní API:

V sadě Visual Studio vytvořte projekt webového rozhraní API ASP.NET Core:
V dialogovém okně Konfigurace nového projektu pojmenujte projekt PushNotificationsAPI.
V dialogovém okně Další informace se ujistěte, že jsou povolená zaškrtávací políčka Konfigurovat pro kontrolery HTTPS a Použít:
Po vytvoření projektu spusťte projekt stisknutím klávesy F5 .

Aplikace je aktuálně nakonfigurovaná tak, aby používala WeatherForecastController jako launchUrl, která je nastavena v souboru Properties\launchSettings.json . Aplikace se spustí ve webovém prohlížeči a zobrazí některá data JSON.

Důležité

Když spustíte projekt ASP.NET Core, který používá protokol HTTPS, Sada Visual Studio zjistí, jestli je do místního úložiště certifikátů uživatele nainstalovaný vývojový certifikát HTTPS ASP.NET Core, a nabídne mu instalaci a důvěryhodnost, pokud chybí.
Zavřete webový prohlížeč.
V Průzkumník řešení rozbalte složku Kontrolery a odstraňte WeatherForecastController.cs.
V Průzkumník řešení odstraňte v kořenovém adresáři projektu WeatherForecast.cs.

Otevřete příkazové okno a přejděte do adresáře, který obsahuje soubor projektu. Pak spusťte následující příkazy:

dotnet user-secrets init
dotnet user-secrets set "NotificationHub:Name" <value>
dotnet user-secrets set "NotificationHub:ConnectionString" "<value>"

Zástupné hodnoty nahraďte vlastním názvem centra oznámení Azure a připojovací řetězec hodnotami. Najdete je v následujících umístěních ve vašem centru azure Notification Hub:

Hodnota konfigurace	Umístění
`NotificationHub:Name`	Název najdete v souhrnu Základy v horní části stránky Přehled.
`NotificationHub:ConnectinString`	Viz DefaultFullSharedAccessSignature* na stránce Zásady přístupu.

Tím se nastaví místní hodnoty konfigurace pomocí nástroje Secret Manager. Tím se oddělí tajné kódy azure Notification Hubu od řešení sady Visual Studio, aby se zajistilo, že neskončí ve správě zdrojového kódu.

Tip

V případě produkčních scénářů zvažte službu, jako je Azure KeyVault, aby se připojovací řetězec bezpečně ukládaly.

Ověřování klientů pomocí klíče rozhraní API

Ověření klientů pomocí klíče rozhraní API:

Otevřete příkazové okno a přejděte do adresáře, který obsahuje soubor projektu. Pak spusťte následující příkazy:
```
dotnet user-secrets set "Authentication:ApiKey" <value>
```
Zástupnou hodnotu nahraďte klíčem rozhraní API, což může být libovolná hodnota.

V sadě Visual Studio přidejte do projektu novou složku s názvem Ověřování a pak do složky Authentication přidejte novou třídu ApiKeyAuthOptions a nahraďte její kód následujícím kódem:

using Microsoft.AspNetCore.Authentication;

namespace PushNotificationsAPI.Authentication;

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

V sadě Visual Studio přidejte do složky Authentication novou třídu s názvem ApiKeyAuthHandler a nahraďte její kód následujícím kódem:

using Microsoft.AspNetCore.Authentication;
using Microsoft.Extensions.Options;
using System.Security.Claims;
using System.Text.Encodings.Web;

namespace PushNotificationsAPI.Authentication;

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

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

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

Obslužná rutina ověřování je typ, který implementuje chování schématu, což je v tomto případě vlastní schéma klíče rozhraní API.

V sadě Visual Studio přidejte do složky Authentication novou třídu s názvem AuthenticationBuilderExtensions a nahraďte její kód následujícím kódem:

using Microsoft.AspNetCore.Authentication;

namespace PushNotificationsAPI.Authentication;

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

Tato metoda rozšíření se použije ke zjednodušení konfiguračního kódu middlewaru v Program.cs.

V sadě Visual Studio otevřete Program.cs a aktualizujte kód tak, aby nakonfigurovali ověřování pomocí klíče rozhraní API pod voláním builder.Services.AddControllers metody:

using PushNotificationsAPI.Authentication;

builder.Services.AddControllers();

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

V Program.cs aktualizujte kód pod // Configure the HTTP request pipeline komentářem, aby volal UseRoutingmetody , UseAuthenticationa MapControllers rozšíření:
```
// Configure the HTTP request pipeline.

app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
app.MapControllers();

app.Run();
```
Metoda UseAuthentication rozšíření zaregistruje middleware, který používá dříve registrované schéma ověřování. UseAuthentication musí být volána před jakýmkoli middlewarem, který závisí na ověřování uživatelů.

Poznámka:

I když klíč rozhraní API není tak zabezpečený jako token, stačí pro účely tohoto kurzu a snadno ho nakonfigurujete prostřednictvím middlewaru ASP.NET.

Přidání a konfigurace služeb

Přidání a konfigurace služeb v back-endové aplikaci webového rozhraní API:

V sadě Visual Studio přidejte do projektu balíček NuGet Microsoft.Azure.NotificationHubs . Tento balíček NuGet se používá pro přístup k centru oznámení zapouzdřený v rámci služby.

V sadě Visual Studio přidejte do projektu novou složku s názvem Models a pak do složky Models přidejte novou třídu PushTemplates a nahraďte její kód následujícím kódem:

namespace PushNotificationsAPI.Models;

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

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

Třída PushTemplates obsahuje tokenizované datové části oznámení pro obecná a bezobslužná nabízená oznámení. Tyto datové části jsou definovány mimo instalaci , aby bylo možné experimentovat, aniž by bylo nutné aktualizovat stávající instalace prostřednictvím služby. Zpracování změn instalací tímto způsobem je mimo rozsah tohoto článku. Ve scénářích produktů zvažte použití vlastních šablon.

V sadě Visual Studio přidejte novou třídu pojmenovanou DeviceInstallation do složky Models a nahraďte její kód následujícím kódem:

using System.ComponentModel.DataAnnotations;

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

V sadě Visual Studio přidejte novou třídu pojmenovanou NotificationRequest do složky Models a nahraďte její kód následujícím kódem:

namespace PushNotificationsAPI.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; }
}

V sadě Visual Studio přidejte novou třídu pojmenovanou NotificationHubOptions do složky Models a nahraďte její kód následujícím kódem:

using System.ComponentModel.DataAnnotations;

namespace PushNotificationsAPI.Models;

public class NotificationHubOptions
{
    [Required]
    public string Name { get; set; }

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

V sadě Visual Studio přidejte do projektu novou složku s názvem Services a pak do složky Services přidejte nové rozhraní INotificationService a nahraďte jeho kód následujícím kódem:

using PushNotificationsAPI.Models;

namespace PushNotificationsAPI.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);
}

V sadě Visual Studio přidejte do složky Services novou třídu s názvem NotificationHubService a nahraďte její kód následujícím kódem:

using Microsoft.Extensions.Options;
using Microsoft.Azure.NotificationHubs;
using PushNotificationsAPI.Models;

namespace PushNotificationsAPI.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.FcmV1).ToLower(), NotificationPlatform.FcmV1 }
        };
    }

    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.SendFcmV1NativeNotificationAsync(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.SendFcmV1NativeNotificationAsync(androidPayload, tags, token),
            _hub.SendAppleNativeNotificationAsync(iOSPayload, tags, token)
        };

        return Task.WhenAll(sendTasks);
    }
}

Výraz značky poskytnutý metodě SendTemplateNotificationsAsync je omezen na 20 značek, pokud obsahují pouze ORS. V opačném případě jsou omezeny na 6 značek. Další informace naleznete v tématu Směrování a značky výrazy.

V sadě Visual Studio otevřete Program.cs a aktualizujte kód tak, aby se přidal NotificationHubService jako singleton implementace INotificationService pod volání metody builder.Services.AddAuthentication :

using PushNotificationsAPI.Authentication;
using PushNotificationsAPI.Services;
using PushNotificationsAPI.Models;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.

builder.Services.AddControllers();

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

builder.Services.AddSingleton<INotificationService, NotificationHubService>();
builder.Services.AddOptions<NotificationHubOptions>()
    .Configure(builder.Configuration.GetSection("NotificationHub").Bind)
    .ValidateDataAnnotations();

var app = builder.Build();

Vytvoření rozhraní REST API pro oznámení

Vytvoření rozhraní REST API pro oznámení:

V sadě Visual Studio přidejte nový kontroler pojmenovaný NotificationsController do složky Kontrolery .

Tip

Zvolte kontroler rozhraní API se šablonou akcí čtení a zápisu.

Do souboru NotificationsController.cs přidejte do horní části souboru následující using příkazy:

using System.ComponentModel.DataAnnotations;
using System.Net;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using PushNotificationsAPI.Models;
using PushNotificationsAPI.Services;

Do souboru NotificationsController.cs přidejte Authorize atribut do NotificationsController třídy:

[Authorize]
[ApiController]
[Route("api/[controller]")]
public class NotificationsController : ControllerBase

V souboru NotificationsController.cs aktualizujte NotificationsContoller konstruktor tak, aby přijímal zaregistrovanou instanci INotificationService jako argument, a přiřaďte ji ke členu jen pro čtení:
```
readonly INotificationService _notificationService;

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

V souboru NotificationsContoller.cs nahraďte všechny metody následujícím kódem:

[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)
{
    // Probably want to ensure deletion even if the connection is broken
    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();
}

V souboru Properties/launchSettings.json změňte launchUrl vlastnost pro každý profil z weatherforecast na api/notifications.

Vytvoření aplikace API

Teď vytvoříte aplikaci API ve službě Aplikace Azure Service pro hostování back-endové služby. Toho lze dosáhnout přímo ze sady Visual Studio nebo editoru Visual Studio Code pomocí Azure CLI, Azure PowerShellu, Azure Developer CLI a webu Azure Portal. Další informace najdete v tématu Publikování webové aplikace.

Vytvoření aplikace API na webu Azure Portal:

Ve webovém prohlížeči se přihlaste k webu Azure Portal.
Na webu Azure Portal klikněte na tlačítko Vytvořit prostředek a pak před výběrem tlačítka Vytvořit vyhledejte a zvolte aplikaci API.

Na stránce Vytvořit aplikaci API aktualizujte před výběrem tlačítka Vytvořit následující pole:

Pole	Akce
Předplatné	Zvolte stejné cílové předplatné, ve které jste vytvořili centrum oznámení.
Skupina prostředků	Zvolte stejnou skupinu prostředků, ve které jste vytvořili centrum oznámení.
Název	Zadejte globálně jedinečný název.
Zásobník modulu runtime	Ujistěte se, že je vybraná nejnovější verze .NET.

Po zřízení aplikace API přejděte k prostředku.
Na stránce Přehled si poznamenejte výchozí hodnotu domény. Tato adresa URL je váš back-endový koncový bod, který bude spotřebován z vaší aplikace .NET MAUI. Adresa URL použije název aplikace API, který jste zadali, ve formátu https://<app_name>.azurewebsites.net.
Na webu Azure Portal přejděte do okna Proměnné prostředí nastavení > a ujistěte se, že je vybraná karta Nastavení aplikace. Pak pomocí tlačítka Přidat přidejte následující nastavení:

Jméno Hodnota

Ověřování:ApiKey <api_key_value>

NotificationHub:Name <hub_name_value>

NotificationHub:ConnectionString <hub_connection_string_value>

Důležité

Nastavení Authentication:ApiKey aplikace bylo přidáno kvůli jednoduchosti. V případě produkčních scénářů zvažte službu, jako je Azure KeyVault, aby se připojovací řetězec bezpečně ukládaly.

Po zadání všech těchto nastavení vyberte tlačítko Použít a pak tlačítko Potvrdit .

Jméno	Hodnota
Ověřování:ApiKey	<api_key_value>
NotificationHub:Name	<hub_name_value>
NotificationHub:ConnectionString	<hub_connection_string_value>

Publikování back-endové služby

Publikování back-endové služby do služby Aplikace Azure Service:

V sadě Visual Studio klikněte pravým tlačítkem na projekt a vyberte Publikovat.
V průvodci publikováním vyberte Azure a pak tlačítko Další .
V průvodci publikováním vyberte Aplikace Azure Service (Windows) a pak tlačítko Další.
V průvodci publikováním postupujte podle postupu ověřování a připojte Visual Studio k vašemu předplatnému Azure a publikujte aplikaci.

Visual Studio sestaví, balíčky a publikuje aplikaci do Azure a pak ji spustí ve výchozím prohlížeči. Další informace najdete v tématu Publikování webové aplikace ASP.NET.

Tip

Profil publikování pro aplikaci si můžete stáhnout z okna Přehled vaší aplikace API na webu Azure Portal a pak pomocí profilu v sadě Visual Studio aplikaci publikovat.

Ověření publikovaného rozhraní API

Pokud chcete zkontrolovat, jestli je aplikace API publikovaná správně, měli byste k odeslání POST požadavku na následující adresu použít nástroje REST podle vašeho výběru:

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

Poznámka:

Základní adresa je https://<app_name>.azurewebsites.net.

Ujistěte se, že nakonfigurujete hlavičky požadavku tak, aby zahrnovaly klíč apikey a jeho hodnotu, nastavte text na nezpracovaný a použijte následující zástupný obsah JSON:

{}

Měli byste obdržet 400 Bad Request odpověď ze služby.

Poznámka:

Rozhraní API zatím není možné otestovat pomocí platných dat požadavků, protože to bude vyžadovat informace specifické pro platformu z aplikace .NET MAUI.

Další informace o volání rozhraní REST API naleznete v tématu Použití souborů .http v sadě Visual Studio a testování webových rozhraní API pomocí http Repl. V editoru Visual Studio Code lze k otestování rozhraní REST API použít klienta REST .

Vytvoření aplikace .NET MAUI

V této části vytvoříte aplikaci .NET Pro víceplatformní aplikaci (.NET MAUI), která vám umožní zaregistrovat se k příjmu nabízených oznámení z centra oznámení prostřednictvím back-endové služby a zrušení registrace.

Vytvoření aplikace .NET MAUI:

V sadě Visual Studio vytvořte novou aplikaci .NET MAUI s názvem PushNotificationsDemo pomocí šablony projektu aplikace .NET MAUI.

V sadě Visual Studio přidejte do projektu .NET MAUI novou složku s názvem Models a pak do složky Models přidejte novou třídu s názvem DeviceInstallation Models a nahraďte její kód následujícím kódem:

using System.Text.Json.Serialization;

namespace PushNotificationsDemo.Models;

public class DeviceInstallation
{
    [JsonPropertyName("installationId")]
    public string InstallationId { get; set; }

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

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

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

V sadě Visual Studio přidejte výčet pojmenovaný PushDemoAction do složky Models a nahraďte jeho kód následujícím kódem:
```
namespace PushNotificationsDemo.Models;

public enum PushDemoAction
{
    ActionA,
    ActionB
}
```
V sadě Visual Studio přidejte do projektu .NET MAUI novou složku s názvem Services a pak do složky Services přidejte nové rozhraní s názvem IDeviceInstallationService Services a nahraďte jeho kód následujícím kódem:
```
using PushNotificationsDemo.Models;

namespace PushNotificationsDemo.Services;

public interface IDeviceInstallationService
{
    string Token { get; set; }
    bool NotificationsSupported { get; }
    string GetDeviceId();
    DeviceInstallation GetDeviceInstallation(params string[] tags);
}
```
Toto rozhraní se později implementuje na každé platformě, aby poskytovalo DeviceInstallation informace vyžadované back-endovou službou.
V sadě Visual Studio přidejte rozhraní pojmenované INotificationRegistrationService do složky Services a nahraďte jeho kód následujícím kódem:
```
namespace PushNotificationsDemo.Services;

public interface INotificationRegistrationService
{
    Task DeregisterDeviceAsync();
    Task RegisterDeviceAsync(params string[] tags);
    Task RefreshRegistrationAsync();
}
```
Toto rozhraní bude zpracovávat interakci mezi klientem a back-endovou službou.
V sadě Visual Studio přidejte rozhraní pojmenované INotificationActionService do složky Services a nahraďte jeho kód následujícím kódem:
```
namespace PushNotificationsDemo.Services;

public interface INotificationActionService
{
    void TriggerAction(string action);
}
```
Toto rozhraní se použije jako jednoduchý mechanismus pro centralizované zpracování akcí oznámení.
V sadě Visual Studio přidejte rozhraní pojmenované IPushDemoNotificationActionService do složky Services a nahraďte jeho kód následujícím kódem:
```
using PushNotificationsDemo.Models;

namespace PushNotificationsDemo.Services;

public interface IPushDemoNotificationActionService : INotificationActionService
{
    event EventHandler<PushDemoAction> ActionTriggered;
}
```
Typ IPushDemoNotificationActionService je specifický pro tuto aplikaci a pomocí výčtu PushDemoAction identifikuje akci aktivovanou pomocí přístupu silného typu.

V sadě Visual Studio přidejte do složky Services třídu s názvem NotificationRegistrationService a nahraďte její kód následujícím kódem:

using System.Text;
using System.Text.Json;
using PushNotificationsDemo.Models;

namespace PushNotificationsDemo.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;

    IDeviceInstallationService DeviceInstallationService =>
        _deviceInstallationService ?? (_deviceInstallationService = Application.Current.Windows[0].Page.Handler.MauiContext.Services.GetService<IDeviceInstallationService>());

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

        _baseApiUrl = baseApiUri;
    }

    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, JsonSerializer.Serialize(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 = JsonSerializer.Deserialize<string[]>(serializedTags);

        await RegisterDeviceAsync(tags);
    }

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

        await Task.Run(() => serializedContent = JsonSerializer.Serialize(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();
    }
}

V sadě Visual Studio přidejte do složky Services třídu s názvem PushDemoNotificationActionService a nahraďte její kód následujícím kódem:

using PushNotificationsDemo.Models;

namespace PushNotificationsDemo.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);
    }
}

V sadě Visual Studio přidejte do kořenového adresáře projektu třídu Config a nahraďte její kód následujícím kódem:
```
namespace PushNotificationsDemo;

public static partial class Config
{
    public static string ApiKey = "API_KEY";
    public static string BackendServiceEndpoint = "BACKEND_SERVICE_ENDPOINT";
}
```
Třída Config se používá jako jednoduchý způsob, jak udržet tajné kódy mimo správu zdrojového kódu. Tyto hodnoty můžete nahradit jako součást automatizovaného sestavení nebo je přepsat pomocí místní částečné třídy.

Důležité

Při zadávání základní adresy v aplikaci .NET MAUI se ujistěte, že končí na /.
V sadě Visual Studio přidejte třídu pojmenovanou Config.local_secrets do kořenového adresáře projektu. Potom nahraďte kód v souboru Config.local_secrets.cs následujícím kódem:
```
namespace PushNotificationsDemo;

public static partial class Config
{
    static Config()
    {
        ApiKey = "<your_api_key>";
        BackendServiceEndpoint = "<your_api_app_url>";
    }
}
```
Zástupné hodnoty nahraďte hodnotami, které jste zvolili při vytváření back-endové služby. Adresa BackendServiceEndpoint URL by měla používat formát https://<api_app_name>.azurewebsites.net/.

Tip

Nezapomeňte do .gitignore souboru přidat*.local_secrets.*, abyste se vyhnuli potvrzení tohoto souboru do správy zdrojového kódu.

Vytvoření uživatelského rozhraní

Vytvoření uživatelského rozhraní aplikace:

V sadě Visual Studio otevřete MainPage.xaml a nahraďte podřízené položky VerticalStackLayout následujícím kódem XAML:

<VerticalStackLayout Margin="20"
                     Spacing="6">
    <Button x:Name="registerButton"
            Text="Register"
            Clicked="OnRegisterButtonClicked" />
    <Button x:Name="deregisterButton"
            Text="Deregister"
            Clicked="OnDeregisterButtonClicked" />
</VerticalStackLayout>

V sadě Visual Studio otevřete MainPage.xaml.cs a přidejte using příkaz pro PushNotificationsDemo.Services obor názvů:
```
using PushNotificationsDemo.Services;
```
V MainPage.xaml.cs přidejte readonly záložní pole pro uložení odkazu na implementaci INotificationRegistrationService :
```
readonly INotificationRegistrationService _notificationRegistrationService;
```
V konstruktoru MainPage přeložte implementaci INotificationRegistrationService a přiřaďte ji do _notificationRegistrationService backingového pole:
```
public MainPage(INotificationRegistrationService service)
{
    InitializeComponent();

    _notificationRegistrationService = service;
}
```

MainPage Ve třídě implementujte OnRegisterButtonClicked obslužné rutiny událostí OnDeregisterButtonClicked volání odpovídajících metod registru a deregister u objektuINotificationRegistrationService:

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

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

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

Důležité

V aplikaci se registrace a zrušení registrace provádí v reakci na vstup uživatele, aby bylo možné tuto funkci prozkoumat a snadněji testovat. V produkční aplikaci byste obvykle prováděli akce registrace a zrušení registrace během příslušného bodu životního cyklu aplikace, aniž byste museli explicitně zadat uživatele.

V sadě Visual Studio otevřete App.xaml.cs a přidejte následující using příkazy:
```
using PushNotificationsDemo.Models;
using PushNotificationsDemo.Services;
```
V App.xaml.cs přidejte readonly záložní pole pro uložení odkazu na implementaci IPushDemoNotificationActionService :
```
readonly IPushDemoNotificationActionService _actionService;
```

V konstruktoru App přeložte implementaci IPushDemoNotificationActionService a přiřaďte ji k záložnímu _actionService poli a přihlaste se k odběru IPushDemoNotificationActionService.ActionTriggered události:

public App(IPushDemoNotificationActionService service)
{
    InitializeComponent();

    _actionService = service;
    _actionService.ActionTriggered += NotificationActionTriggered;

    MainPage = new AppShell();
}

V konstruktoru App přeložte implementaci IPushDemoNotificationActionService a přiřaďte ji k záložnímu _actionService poli a přihlaste se k odběru IPushDemoNotificationActionService.ActionTriggered události:
```
public App(IPushDemoNotificationActionService service)
{
    InitializeComponent();

    _actionService = service;
    _actionService.ActionTriggered += NotificationActionTriggered;
}
```

App Ve třídě implementujte obslužnou rutinu IPushDemoNotificationActionService.ActionTriggered události pro událost:

void NotificationActionTriggered(object sender, PushDemoAction e)
{
    ShowActionAlert(e);
}

void ShowActionAlert(PushDemoAction action)
{
    MainThread.BeginInvokeOnMainThread(() =>
    {
        Windows[0].Page?.DisplayAlert("Push notifications demo", $"{action} action received.", "OK")
            .ContinueWith((task) =>
            {
                if (task.IsFaulted)
                    throw task.Exception;
            });
    });
}

Obslužná rutina události události ActionTriggered ukazuje příjem a šíření akcí nabízených oznámení. Ty by se obvykle zpracovávaly bezobslužně, například přechod na konkrétní zobrazení nebo aktualizaci některých dat místo zobrazení výstrahy.

Konfigurace aplikace pro Android

Konfigurace aplikace .NET MAUI v Androidu pro příjem a zpracování nabízených oznámení:

V sadě Visual Studio přidejte balíček NuGet Xamarin.Firebase.Messaging do projektu aplikace .NET MAUI.
V sadě Visual Studio přidejte soubor google-services.json do složky Platformy/Android projektu aplikace .NET MAUI. Po přidání souboru do projektu by se měl přidat akce GoogleServicesJsonsestavení:
```
<ItemGroup Condition="'$(TargetFramework)' == 'net8.0-android'">
  <GoogleServicesJson Include="Platforms\Android\google-services.json" />
</ItemGroup>
```
Tip

Nezapomeňte do .gitignore souboru přidatgoogle-services.json, abyste se vyhnuli potvrzení tohoto souboru do správy zdrojového kódu.
V sadě Visual Studio upravte soubor projektu (*.csproj) a nastavte SupportedOSPlatformVersion pro Android hodnotu 26.0:
```
<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'android'">26.0</SupportedOSPlatformVersion>
```
Google provedl změny kanálů oznámení Androidu v rozhraní API 26. Další informace najdete v tématu Kanály oznámení na developer.android.com.

Do složky Platforms/Android projektu přidejte novou třídu s názvem DeviceInstallationService a nahraďte její kód následujícím kódem:

using Android.Gms.Common;
using PushNotificationsDemo.Models;
using PushNotificationsDemo.Services;
using static Android.Provider.Settings;

namespace PushNotificationsDemo.Platforms.Android;

public class DeviceInstallationService : IDeviceInstallationService
{
    public string Token { get; set; }

    public bool NotificationsSupported
        => GoogleApiAvailability.Instance.IsGooglePlayServicesAvailable(Platform.AppContext) == ConnectionResult.Success;

    public string GetDeviceId()
        => Secure.GetString(Platform.AppContext.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 FCMv1.");

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

        installation.Tags.AddRange(tags);

        return installation;
    }

    string GetPlayServicesError()
    {
        int resultCode = GoogleApiAvailability.Instance.IsGooglePlayServicesAvailable(Platform.AppContext);

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

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

Tato třída poskytuje jedinečné ID s použitím Secure.AndroidId hodnoty a datové části registrace centra oznámení.

Do složky Platforms/Android projektu přidejte novou třídu s názvem PushNotificationFirebaseMessagingService a nahraďte její kód následujícím kódem:

using Android.App;
using Firebase.Messaging;
using PushNotificationsDemo.Services;

namespace PushNotificationsDemo.Platforms.Android;

[Service(Exported = false)]
[IntentFilter(new[] { "com.google.firebase.MESSAGING_EVENT" })]
public class PushNotificationFirebaseMessagingService : FirebaseMessagingService
{
    IPushDemoNotificationActionService _notificationActionService;
    INotificationRegistrationService _notificationRegistrationService;
    IDeviceInstallationService _deviceInstallationService;
    int _messageId;

    IPushDemoNotificationActionService NotificationActionService =>
        _notificationActionService ?? (_notificationActionService = IPlatformApplication.Current.Services.GetService<IPushDemoNotificationActionService>());

    INotificationRegistrationService NotificationRegistrationService =>
        _notificationRegistrationService ?? (_notificationRegistrationService = IPlatformApplication.Current.Services.GetService<INotificationRegistrationService>());

    IDeviceInstallationService DeviceInstallationService =>
        _deviceInstallationService ?? (_deviceInstallationService = IPlatformApplication.Current.Services.GetService<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)
    {
        base.OnMessageReceived(message);

        if (message.Data.TryGetValue("action", out var messageAction))
            NotificationActionService.TriggerAction(messageAction);
    }
}

Tato třída má IntentFilter atribut, který obsahuje com.google.firebase.MESSAGING_EVENT filtr. Tento filtr umožňuje Androidu předávat příchozí zprávy této třídě ke zpracování.

Informace o formátu zpráv Firebase Cloud Messaging naleznete v tématu Informace o zprávách FCM na developer.android.com.

V sadě Visual Studio otevřete soubor MainActivity.cs ve složce Platformy/Android a přidejte následující using příkazy:

using Android.App;
using Android.Content;
using Android.Content.PM;
using Android.OS;
using PushNotificationsDemo.Services;
using Firebase.Messaging;

MainActivity Ve třídě nastavte LaunchMode hodnotu takSingleTop, aby MainActivity se při otevření znovu nevytvořila:

[Activity(
    Theme = "@style/Maui.SplashTheme",
    MainLauncher = true,
    LaunchMode = LaunchMode.SingleTop,
    ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation | ConfigChanges.UiMode | ConfigChanges.ScreenLayout | ConfigChanges.SmallestScreenSize | ConfigChanges.Density)]

MainActivity Do třídy přidejte zpětná pole pro ukládání odkazů na implementaci IPushDemoNotificationActionService a IDeviceInstallationService odkazy:
```
IPushDemoNotificationActionService _notificationActionService;
IDeviceInstallationService _deviceInstallationService;
```

MainActivity Ve třídě přidejte NotificationActionService a DeviceInstallationService privátní vlastnosti, které načítají jejich konkrétní implementace z kontejneru injektáže závislostí aplikace:

IPushDemoNotificationActionService NotificationActionService =>
    _notificationActionService ?? (_notificationActionService = IPlatformApplication.Current.Services.GetService<IPushDemoNotificationActionService>());

IDeviceInstallationService DeviceInstallationService =>
    _deviceInstallationService ?? (_deviceInstallationService = IPlatformApplication.Current.Services.GetService<IDeviceInstallationService>());

MainActivity Ve třídě implementujte Android.Gms.Tasks.IOnSuccessListener rozhraní pro načtení a uložení tokenu Firebase:

public class MainActivity : MauiAppCompatActivity, Android.Gms.Tasks.IOnSuccessListener
{
    public void OnSuccess(Java.Lang.Object result)
    {
        DeviceInstallationService.Token = result.ToString();
    }
}

MainActivity Do třídy přidejte metoduProcessNotificationActions, která zkontroluje, jestli má daná Intent hodnota navíc pojmenovanou action, a podmíněně aktivujte, že action pomocí IPushDemoNotificationActionService implementace:

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

MainActivity Ve třídě přepište metodu OnNewIntent tak, aby volala metoduProcessNotificationActions:
```
protected override void OnNewIntent(Intent? intent)
{
    base.OnNewIntent(intent);
    ProcessNotificationsAction(intent);
}
```
Vzhledem k tomu, že LaunchMode je nastavena Activity SingleTopna hodnotu , Intent bude odeslána do existující Activity instance prostřednictvím OnNewIntent přepsání, nikoli OnCreate metody. Proto musíte zpracovat příchozí záměr v obou OnNewIntent a OnCreate.
MainActivity Ve třídě přepište metodu OnCreate ProcessNotificationActions volání metody a načtení tokenu z Firebase přidáním MainActivity jako IOnSuccessListener:
```
protected override void OnCreate(Bundle? savedInstanceState)
{
    base.OnCreate(savedInstanceState);

    if (DeviceInstallationService.NotificationsSupported)
        FirebaseMessaging.Instance.GetToken().AddOnSuccessListener(this);

    ProcessNotificationsAction(Intent);
}
```
Poznámka:

Aby aplikace dál přijímala nabízená oznámení, musí se znovu zaregistrovat při každém spuštění a zastavit ji z ladicí relace.
V sadě Visual Studio přidejte POST_NOTIFICATIONS oprávnění k souboru AndroidManifest.xml ve složce Platforms/Android :
```
<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
```
Další informace o tomto oprávnění najdete v tématu Oprávnění modulu runtime oznámení pro developer.android.com.
V sadě Visual Studio otevřete MainPage.xaml.cs a do třídy přidejte následující kód MainPage :
```
#if ANDROID
        protected override async void OnAppearing()
        {
            base.OnAppearing();

            PermissionStatus status = await Permissions.RequestAsync<Permissions.PostNotifications>();
        }
#endif
```
Tento kód se spustí v Androidu, jakmile se MainPage zobrazí, a požádá uživatele o udělení POST_NOTIFICATIONS oprávnění. Další informace o oprávněních .NET MAUI najdete v tématu Oprávnění.

Konfigurace aplikace pro iOS

Simulátor iOS podporuje vzdálená oznámení v iOSu 16+ při spuštění v macOS 13+ na počítačích Mac s procesory Apple silicon nebo T2. Každý simulátor generuje registrační tokeny, které jsou jedinečné pro kombinaci tohoto simulátoru a hardwaru Mac, na kterém běží.

Důležité

Simulátor podporuje sandboxové prostředí služby Apple Push Notification Service.

Následující pokyny předpokládají, že používáte hardware, který podporuje přijímání vzdálených oznámení v simulátoru iOS. Pokud tomu tak není, budete muset aplikaci pro iOS spustit na fyzickém zařízení, což bude vyžadovat vytvoření zřizovacího profilu pro vaši aplikaci, která zahrnuje funkci nabízených oznámení. Pak budete muset zajistit, aby vaše aplikace byla sestavena pomocí vašeho certifikátu a zřizovacího profilu. Další informace o tom, jak to udělat, najdete v tématu Nastavení aplikace pro iOS pro práci se službou Azure Notification Hubs a poté postupujte podle následujících pokynů.

Konfigurace aplikace .NET MAUI v iOSu pro příjem a zpracování nabízených oznámení:

V sadě Visual Studio upravte soubor projektu (*.csproj) a nastavte SupportedOSPlatformVersion pro iOS hodnotu 13.0:
```
<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'ios'">13.0</SupportedOSPlatformVersion>
```
Apple ve své nabízené službě v iOSu 13 provedl změny. Další informace najdete v tématu Aktualizace služby Azure Notification Hubs pro iOS 13.
V sadě Visual Studio přidejte soubor Entitlements.plist do složky Platforms/iOS projektu a do souboru přidejte následující KÓD XML:
```
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
  <key>aps-environment</key>
  <string>development</string>
</dict>
</plist>
```
Tím se nastaví nárok na prostředí APS a určuje použití vývojového prostředí služby Apple Push Notification. V produkčních aplikacích by tato hodnota nároku měla být nastavena na productionhodnotu . Další informace o tomto nároku najdete v tématu APS Environment Entitlement on developer.apple.com.

Další informace o přidání souboru nároků najdete v tématu Nároky na iOS.

V sadě Visual Studio přidejte novou třídu pojmenovanou DeviceInstallationService do složky Platforms/iOS projektu a do souboru přidejte následující kód:

using PushNotificationsDemo.Services;
using PushNotificationsDemo.Models;
using UIKit;

namespace PushNotificationsDemo.Platforms.iOS;

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

Tato třída poskytuje jedinečné ID s použitím UIDevice.IdentifierForVendor hodnoty a datové části registrace centra oznámení.

V sadě Visual Studio přidejte novou třídu pojmenovanou NSDataExtensions do složky Platforms/iOS projektu a do souboru přidejte následující kód:

using Foundation;
using System.Text;

namespace PushNotificationsDemo.Platforms.iOS;

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

Metoda ToHexString rozšíření bude spotřebována kódem, který parsuje načtený token zařízení.

V sadě Visual Studio otevřete soubor AppDelegate.cs ve složce Platforms/iOS a přidejte následující using příkazy:

using System.Diagnostics;
using Foundation;
using PushNotificationsDemo.Platforms.iOS;
using PushNotificationsDemo.Services;
using UIKit;
using UserNotifications;

AppDelegate Ve třídě přidejte backing pole pro uložení odkazů na IPushDemoNotificationActionService, INotificationRegistrationServicea IDeviceInstallationService implementace:

IPushDemoNotificationActionService _notificationActionService;
INotificationRegistrationService _notificationRegistrationService;
IDeviceInstallationService _deviceInstallationService;

AppDelegate Ve třídě přidejte NotificationActionServicea NotificationRegistrationServiceDeviceInstallationService privátní vlastnosti, které načítají jejich konkrétní implementace z kontejneru injektáže závislostí aplikace:

IPushDemoNotificationActionService NotificationActionService =>
    _notificationActionService ?? (_notificationActionService = IPlatformApplication.Current.Services.GetService<IPushDemoNotificationActionService>());

INotificationRegistrationService NotificationRegistrationService =>
    _notificationRegistrationService ?? (_notificationRegistrationService = IPlatformApplication.Current.Services.GetService<INotificationRegistrationService>());

IDeviceInstallationService DeviceInstallationService =>
    _deviceInstallationService ?? (_deviceInstallationService = IPlatformApplication.Current.Services.GetService<IDeviceInstallationService>());

AppDelegate Do třídy přidejte metodu CompleteRegistrationAsync IDeviceInstallationService.Token pro nastavení hodnoty vlastnosti:
```
Task CompleteRegistrationAsync(NSData deviceToken)
{
    DeviceInstallationService.Token = deviceToken.ToHexString();
    return NotificationRegistrationService.RefreshRegistrationAsync();
}
```
Tato metoda také aktualizuje registraci a uloží token zařízení do mezipaměti, pokud se aktualizuje od posledního uložení.

AppDelegate Do třídy přidejte metodu ProcessNotificationActions pro zpracování NSDictionary dat oznámení a podmíněné voláníNotificationActionService.TriggerAction:

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

    try
    {
        // If your app isn't in the foreground, the notification goes to Notification Center.
        // If your app is in the foreground, the notification goes directly to your app and you
        // need to process the notification payload yourself.
        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);
    }
}

AppDelegate Do třídy přidejte metodu RegisteredForRemoteNotifications deviceToken, která předá argument metoděCompleteRegistrationAsync:
```
[Export("application:didRegisterForRemoteNotificationsWithDeviceToken:")]
public void RegisteredForRemoteNotifications(UIApplication application, NSData deviceToken)
{
    CompleteRegistrationAsync(deviceToken)
        .ContinueWith((task) =>
        {
            if (task.IsFaulted)
                throw task.Exception;
        });
}
```
Tato metoda se zavolá, když je aplikace zaregistrovaná pro příjem vzdáleného oznámení a použije se k vyžádání jedinečného tokenu zařízení, což je v podstatě adresa vaší aplikace v zařízení.
AppDelegate Do třídy přidejte metodu ReceivedRemoteNotification userInfo, která předá argument metoděProcessNotificationActions:
```
[Export("application:didReceiveRemoteNotification:")]
public void ReceivedRemoteNotification(UIApplication application, NSDictionary userInfo)
{
    ProcessNotificationActions(userInfo);
}
```
Tato metoda se zavolá, když aplikace přijala vzdálené oznámení a použije se ke zpracování oznámení.
AppDelegate Do třídy přidejte metodu FailedToRegisterForRemoteNotifications pro protokolování chyb:
```
[Export("application:didFailToRegisterForRemoteNotificationsWithError:")]
public void FailedToRegisterForRemoteNotifications(UIApplication application, NSError error)
{
    Debug.WriteLine(error.Description);
}
```
Tato metoda bude volána, když se aplikace nepodařilo zaregistrovat pro příjem vzdálených oznámení. Registrace může selhat, pokud zařízení není připojené k síti, pokud je server APNS nedostupný nebo pokud je aplikace nesprávně nakonfigurovaná.

Poznámka:

V produkčních scénářích budete chtít v FailedToRegisterForRemoteNotifications metodě implementovat správné protokolování a zpracování chyb.

AppDelegate Ve třídě přidejte metodu FinishedLaunching pro podmíněnou žádost o oprávnění k používání oznámení a registraci vzdálených oznámení:

[Export("application:didFinishLaunchingWithOptions:")]
public override bool FinishedLaunching(UIApplication application, NSDictionary launchOptions)
{
    if (DeviceInstallationService.NotificationsSupported)
    {
        UNUserNotificationCenter.Current.RequestAuthorization(
            UNAuthorizationOptions.Alert |
            UNAuthorizationOptions.Badge |
            UNAuthorizationOptions.Sound,
            (approvalGranted, error) =>
            {
                if (approvalGranted && error == null)
                {
                    MainThread.BeginInvokeOnMainThread(() =>
                    {
                        UIApplication.SharedApplication.RegisterForRemoteNotifications();
                    });
                }
            });
    }

    using (var userInfo = launchOptions?.ObjectForKey(UIApplication.LaunchOptionsRemoteNotificationKey) as NSDictionary)
    {
        ProcessNotificationActions(userInfo);
    }

    return base.FinishedLaunching(application, launchOptions);
}

Informace o tom, jak požádat o oprávnění k používání oznámení, najdete v tématu Dotazování oprávnění k používání oznámení na developer.apple.com.

Informace o oznámeních v iOSu najdete v tématu Oznámení uživatelů na developer.apple.com.

Registrace typů pomocí kontejneru injektáže závislostí aplikace

V sadě Visual Studio otevřete MauiProgram.cs a přidejte using příkaz pro PushNotificationsDemo.Services obor názvů:
```
using PushNotificationsDemo.Services;
```

MauiProgram Ve třídě přidejte kód pro metodu RegisterServices rozšíření, která zaregistruje na DeviceInstallationService každé platformě, a multiplatformní PushDemoNotificationActionService a NotificationRegistrationService služby a vrací MauiAppBuilder objekt:

public static MauiAppBuilder RegisterServices(this MauiAppBuilder builder)
{
#if IOS
    builder.Services.AddSingleton<IDeviceInstallationService, PushNotificationsDemo.Platforms.iOS.DeviceInstallationService>();
#elif ANDROID
    builder.Services.AddSingleton<IDeviceInstallationService, PushNotificationsDemo.Platforms.Android.DeviceInstallationService>();
#endif

    builder.Services.AddSingleton<IPushDemoNotificationActionService, PushDemoNotificationActionService>();
    builder.Services.AddSingleton<INotificationRegistrationService>(new NotificationRegistrationService(Config.BackendServiceEndpoint, Config.ApiKey));

    return builder;
}

MauiProgram Do třídy přidejte kód pro rozšiřující metodu RegisterViews MainPage, která registruje typ jako singleton a který vrací MauiAppBuilder objekt:
```
public static MauiAppBuilder RegisterViews(this MauiAppBuilder builder)
{
    builder.Services.AddSingleton<MainPage>();
    return builder;
}
```
Typ MainPage je registrován, protože vyžaduje závislost a všechny typy, které vyžadují INotificationRegistrationService závislost, musí být registrovány v kontejneru injektáž závislostí.

MauiProgram Ve třídě upravte metodu CreateMauiApp tak, aby volaly RegisterServices metody a RegisterViews metody rozšíření:

public static MauiApp CreateMauiApp()
{
    var builder = MauiApp.CreateBuilder();
    builder
        .UseMauiApp<App>()
        .ConfigureFonts(fonts =>
        {
            fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
            fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
        })
        .RegisterServices()
        .RegisterViews();

#if DEBUG
      builder.Logging.AddDebug();
#endif
      return builder.Build();
}

Další informace o injektáži závislostí v rozhraní .NET MAUI najdete v tématu Injektáž závislostí.

Otestování aplikace

Aplikaci můžete otestovat odesláním nabízených oznámení do aplikace pomocí back-endové služby nebo webu Azure Portal.

Simulátor iOS podporuje vzdálená oznámení v iOSu 16+ při spuštění v macOS 13+ na počítačích Mac s procesory Apple silicon nebo T2. Pokud tyto hardwarové požadavky nesplňujete, budete muset otestovat aplikaci pro iOS na fyzickém zařízení. Na Androidu můžete aplikaci otestovat na odemknutém fyzickém zařízení vývojáře nebo emulátoru.

Android a iOS zobrazují nabízená oznámení jménem aplikace, když běží na pozadí. Pokud je aplikace spuštěná v popředí při přijetí oznámení, kód aplikace určuje chování. Můžete například aktualizovat rozhraní aplikace tak, aby odráželo nové informace obsažené v oznámení.

Testování pomocí back-endové služby

Odeslání testovacího nabízeného oznámení do aplikace prostřednictvím back-endové služby publikované do služby Aplikace Azure Service:

V sadě Visual Studio spusťte aplikaci PushNotificationsDemo v Androidu nebo iOSu a vyberte tlačítko Zaregistrovat .

Poznámka:

Pokud testujete na Androidu, ujistěte se, že nepoužíváte konfiguraci ladění. Případně pokud byla aplikace dříve nasazená, ujistěte se, že byla vynucená zavřená, a pak ji znovu spusťte ze spouštěče.

V nástrojích REST podle vašeho výběru odešlete POST požadavek na následující adresu:

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

Ujistěte se, že nakonfigurujete hlavičky požadavku tak, aby zahrnovaly klíč apikey a jeho hodnotu, nastavte text na nezpracovaný a použijte následující obsah JSON:

{
    "text": "Message from REST tooling!",
    "action": "action_a"
}

Celkový požadavek by měl být podobný následujícímu příkladu:

POST /api/notifications/requests HTTP/1.1
Host: https://<app_name>.azurewebsites.net
apikey: <your_api_key>
Content-Type: application/json

{
    "text": "Message from REST tooling!",
    "action": "action_a"
}

V nástrojích REST podle vašeho výběru ověřte, že obdržíte odpověď 200 OK .
V aplikaci v Androidu nebo iOSu by se měla zobrazit výstraha zobrazující přijatou akci ActionA.

Testování pomocí webu Azure Portal

Azure Notification Hubs umožňuje zkontrolovat, jestli vaše aplikace může přijímat nabízená oznámení.

Odeslání testovacího nabízeného oznámení do aplikace prostřednictvím webu Azure Portal:

V sadě Visual Studio spusťte aplikaci PushNotificationsDemo v Androidu nebo iOSu a vyberte tlačítko Zaregistrovat .

Poznámka:

Pokud testujete na Androidu, ujistěte se, že nepoužíváte konfiguraci ladění. Případně pokud byla aplikace dříve nasazená, ujistěte se, že byla vynucená zavřená, a pak ji znovu spusťte ze spouštěče.
Na webu Azure Portal přejděte do centra oznámení a v okně Přehled vyberte tlačítko Testovací odeslání.
V okně Testovací odeslání vyberte požadovanou platformu a upravte datovou část.

Pro Apple použijte následující datovou část:
```
{
  "aps": {
    "alert": "Message from Notification Hub!"
  },
  "action": "action_a"
}
```
Pro Android použijte následující datovou část:
```
{
  "message": {
    "notification": {
      "title": "PushDemo",
      "body": "Message from Notification Hub!"
    },
    "data": {
      "action": "action_a"
    }
  }
}
```
Na webu Azure Portal by mělo být uvedeno, že se oznámení úspěšně odeslalo.

Informace o formátu zpráv Firebase Cloud Messaging naleznete v tématu Informace o zprávách FCM na developer.android.com.
V aplikaci v Androidu nebo iOSu by se měla zobrazit výstraha zobrazující přijatou akci ActionA.

Řešení problému

V následujících částech jsou popsány běžné problémy, ke kterým dochází při pokusu o využívání nabízených oznámení v klientské aplikaci.

Žádná odpověď z back-endové služby

Při místním testování se ujistěte, že je back-endová služba spuštěná a že používá správný port.

Pokud testujete aplikaci Azure API, zkontrolujte, jestli je služba spuštěná a jestli je nasazená, a spustila se bez chyby.

Ujistěte se, že jste v nástrojích REST správně zadali základní adresu nebo v konfiguraci aplikace .NET MAUI. Základní adresa by měla být https://<api_name>.azurewebsites.net nebo https://localhost:7020 při místním testování.

Příjem stavového kódu 401 z back-endové služby

Ověřte, že správně nastavujete hlavičku apikey požadavku a že tato hodnota odpovídá té, kterou jste nakonfigurovali pro back-endovou službu.

Pokud se při místním testování zobrazí tato chyba, ujistěte se, že hodnota klíče, kterou jste definovali v aplikaci .NET MAUI, odpovídá Authentication:ApiKey hodnotě tajných kódů uživatelů, kterou používá back-endová služba.

Pokud testujete pomocí aplikace Azure API, ujistěte se, že hodnota klíče definovaná v aplikaci .NET MAUI odpovídá Authentication:ApiKey hodnotě nastavení aplikace definované na webu Azure Portal. Pokud jste vytvořili nebo změnili toto nastavení aplikace po nasazení back-endové služby, musíte službu restartovat, aby se hodnota projevila.

Příjem stavového kódu 404 z back-endové služby

Ověřte správnost koncového bodu a metody požadavku HTTP:

DÁT- https://<api_name>.azurewebsites.net/api/notifications/installations
VYMAZAT- https://<api_name>.azurewebsites.net/api/notifications/installations/<installation_id>
POST- https://<api_name>.azurewebsites.net/api/notifications/requests

Nebo při místním testování:

DÁT- https://localhost:7020/api/notifications/installations
VYMAZAT- https://localhost:7020/api/notifications/installations/<installation_id>
POST- https://localhost:7020/api/notifications/requests

Důležité

Při zadávání základní adresy v aplikaci .NET MAUI se ujistěte, že končí na /. Základní adresa by měla být https://<api_name>.azurewebsites.net nebo https://localhost:7020/ při místním testování.

Po spuštění nebo zastavení ladicí relace nepřicházejí oznámení v Androidu

Při každém spuštění ladicí relace se ujistěte, že se zaregistrujete. Ladicí program způsobí vygenerování nového tokenu Firebase, takže instalace centra oznámení musí být aktualizována.

Nejde zaregistrovat a zobrazí se chybová zpráva centra oznámení

Ověřte, že testovací zařízení má síťové připojení. Pak určete stavový kód odpovědi HTTP nastavením zarážky pro kontrolu StatusCode vlastnosti v objektu HttpResponse.

Projděte si předchozí návrhy řešení potíží, kde je to možné, na základě stavového kódu.

Nastavte zarážku na řádcích, které vracejí konkrétní stavové kódy pro příslušné rozhraní API. Pak zkuste při místním ladění volat back-endovou službu.

Ověřte, že back-endová služba funguje podle očekávání podle zvoleného nástroje REST, a použijte datovou část vytvořenou aplikací .NET MAUI pro zvolenou platformu.

Projděte si oddíly konfigurace specifické pro danou platformu a ujistěte se, že nebyly zmeškané žádné kroky. Zkontrolujte, jestli se pro vybranou platformu řeší InstallationId vhodné hodnoty a Token proměnné.

Nejde vyřešit ID zařízení s chybovou zprávou zařízení

Projděte si oddíly konfigurace specifické pro danou platformu a ujistěte se, že nebyly zmeškané žádné kroky.

Sdílet prostřednictvím

Kurz: Odesílání nabízených oznámení do aplikací .NET MAUI pomocí služby Azure Notification Hubs prostřednictvím back-endové služby

Požadavky

Nastavení služeb nabízených oznámení a Centra oznámení Azure

Vytvoření projektu Firebase

Registrace aplikace pro iOS pro nabízená oznámení

Vytvoření centra oznámení Azure

Konfigurace služby Firebase Cloud Messaging v centru oznámení

Konfigurace služby Apple Push Notification Service v centru oznámení

Možnost 1 – Použití certifikátu push .p12

Možnost 2 – Použití ověřování založeného na tokenech

Vytvoření back-endové aplikace webového rozhraní API ASP.NET Core

Vytvoření projektu webového rozhraní API

Ověřování klientů pomocí klíče rozhraní API

Přidání a konfigurace služeb

Vytvoření rozhraní REST API pro oznámení

Vytvoření aplikace API

Publikování back-endové služby

Ověření publikovaného rozhraní API

Vytvoření aplikace .NET MAUI

Vytvoření uživatelského rozhraní

Konfigurace aplikace pro Android

Konfigurace aplikace pro iOS

Registrace typů pomocí kontejneru injektáže závislostí aplikace

Otestování aplikace

Testování pomocí back-endové služby

Testování pomocí webu Azure Portal

Řešení problému

Žádná odpověď z back-endové služby

Příjem stavového kódu 401 z back-endové služby

Příjem stavového kódu 404 z back-endové služby

Po spuštění nebo zastavení ladicí relace nepřicházejí oznámení v Androidu

Nejde zaregistrovat a zobrazí se chybová zpráva centra oznámení

Nejde vyřešit ID zařízení s chybovou zprávou zařízení

Další materiály