Eğitim: Arka uçta bir hizmet aracılığıyla Azure Notification Hubs kullanarak .NET MAUI uygulamalarına push bildirimleri gönderme

2025-02-25

Anında iletme bildirimleri, bir arka uç sisteminden istemci uygulamasına bilgi sağlar. Apple, Google ve diğer platformların her birinin kendi Anında İletme Bildirimi Hizmeti (PNS) vardır. Azure Notification Hubs, arka uç uygulamanızın tek bir hub ile iletişim kurabilmesi için bildirimleri platformlar arasında merkezi hale getirebilmenizi sağlar ve bu sayede her PNS'ye bildirim dağıtımıyla ilgilenir.

Azure Notification Hubs, uygulamaların hub'a kaydolmasını ve isteğe bağlı olarak şablonları tanımlamasını ve/veya etiketlere abone olmasını gerektirir:

Cihaz yüklemesi gerçekleştirmek, PNS tutamacını Azure Notification Hub'daki bir tanımlayıcıya bağlar. Kayıtlar hakkında daha fazla bilgi için bkz . Kayıt yönetimi.
Şablonlar, cihazların parametreli ileti şablonlarını belirtmesine olanak tanır. Gelen iletiler cihaz başına özelleştirilebilir. Daha fazla bilgi için bkz . Bildirim hub'ları şablonları.
Etiketler haber, spor ve hava durumu gibi ileti kategorilerine abone olmak için kullanılabilir. Daha fazla bilgi için bkz . Yönlendirme ve etiket ifadeleri.

Bu öğreticide, Android ve iOS'yi hedefleyen bir .NET Çok Platformlu Uygulama Kullanıcı Arabirimi (.NET MAUI) uygulamasına anında iletme bildirimleri göndermek için Azure Notification Hubs'ı kullanacaksınız. İstemcinin cihaz kaydını işlemek ve anında iletme bildirimi başlatmak için ASP.NET Core Web API arka ucu kullanılır. Bu işlemler Microsoft.Azure.NotificationHubs NuGet paketi kullanılarak işlenir. Genel yaklaşım hakkında daha fazla bilgi için bkz: Arka uçtan kayıt yönetimi.

Bu öğreticide şunları yapacaksınız:

Anında iletme bildirimi hizmetlerini ve Azure Notification Hub'ı ayarlayın.
ASP.NET Core WebAPI arka uç uygulaması oluşturun.
.NET MAUI uygulaması oluşturun.
Android uygulamasını anında iletme bildirimleri için yapılandırın.
iOS uygulamasını anında iletme bildirimleri için yapılandırın.
Uygulamayı test etme.
Tüm kurulum ve yapılandırma sorunlarını giderin.

Önkoşullar

Bu öğreticiyi tamamlamak için şunlara ihtiyacınız olacak:

Etkin aboneliği olan bir Azure hesabı.
.NET Çok Platformlu Uygulama Kullanıcı Arabirimi geliştirme iş yükü ve ASP.NET ve web geliştirme iş yüklerinin yüklü olduğu Visual Studio/Visual Studio Code'un en son sürümünü çalıştıran bir PC veya Mac.

Android için sahip olmanız gerekenler:

API 26+ çalıştıran ve Google Play Hizmetleri yüklü olan bir geliştirici fiziksel cihazı veya öykünücünün kilidini açtı.

iOS için sahip olmanız gerekenler:

Etkin bir Apple geliştirici hesabı.
Anahtar zincirinize yüklenmiş geçerli bir geliştirici sertifikasının yanı sıra Xcode çalıştıran bir Mac.

Ardından, iOS'ta aşağıdakilerden birini yapmalısınız:

Apple silikon veya T2 işlemcili Mac bilgisayarlarda macOS 13+ sürümünde çalışan bir iOS 16+ simülatörü.

VEYA
Geliştirici hesabınıza kayıtlı fiziksel bir iOS cihazı (iOS 13.0+ çalıştıran).
Fiziksel cihazınız Apple geliştirici hesabınıza kayıtlı ve sertifikanızla ilişkilendirilmiş.

Önemli

Bu öğreticiyi takip etmek için şu konuda bilgi sahibi olmanız gerekir:

Bu öğretici Visual Studio'yu hedeflese de, PC veya Mac'te Visual Studio Code kullanarak bunu takip etmek mümkündür. Ancak, mutabakat gerektiren bazı farklılıklar olacaktır. Örneğin, kullanıcı arabiriminin ve iş akışlarının, şablon adlarının ve ortam yapılandırmasının açıklamaları.

Anında iletme bildirimi hizmetlerini ve Azure Notification Hub'ı ayarlama

Bu bölümde Firebase Cloud Messaging ve Apple Anında İletme Bildirim Hizmetleri'ni (APNS) kuracaksınız. Ardından bu hizmetlerle çalışmak için bir Azure Notification Hub oluşturup yapılandıracaksınız.

Firebase projesi oluşturma

Firebase projesi oluşturmak için:

Web tarayıcısında Firebase konsolunda oturum açın.
Firebase konsolunda Proje ekle düğmesini seçin ve proje adı olarak PushDemo girerek yeni bir Firebase projesi oluşturun.

Not

Sizin için benzersiz bir ad oluşturulur. Varsayılan olarak bu, sağladığınız adın küçük harfli bir değişkenini ve tireyle ayrılmış olarak oluşturulan bir sayıyı içerir. Düzenlemelerinizin hala genel olarak benzersiz olması koşuluyla, isterseniz bunu değiştirebilirsiniz.
Projeniz oluşturulduktan sonra Bir Android uygulamasına Firebase eklemek için Android logosunu seçin:
Android uygulamanıza Firebase ekle sayfasında paketiniz için isteğe bağlı olarak bir uygulama takma adı girin ve Uygulamayı kaydet düğmesini seçin:
Android uygulamanıza Firebase ekle sayfasında, İndir google-services.json düğmesini seçin ve İleri düğmesini seçmeden önce dosyayı yerel bir klasöre kaydedin:
Android uygulamanıza Firebase ekle sayfasında İleri düğmesini seçin.
Android uygulamanıza Firebase ekle sayfasında Konsola devam et düğmesini seçin.
Firebase konsolunda Projeye Genel Bakış simgesini ve ardından Proje ayarları'nı seçin:
Proje ayarlarında Bulut Mesajlaşması sekmesini seçin. Firebase Cloud Messaging API'sini (V1) etkinleştirmiş olduğunu göreceksiniz:
Proje ayarlarında Hizmet hesapları sekmesini ve ardından Yeni özel anahtar oluştur düğmesini seçin.
Yeni özel anahtar oluştur iletişim kutusunda Anahtar oluştur düğmesini seçin:

Azure Notification Hub'ınıza gireceğiniz değerleri içeren bir JSON dosyası indirilir.

iOS uygulamanızı anında iletme bildirimleri için kaydetme

Bir iOS uygulamasına anında iletme bildirimleri göndermek için uygulamanızı Apple'a kaydetmeniz ve anında iletme bildirimlerine kaydolmanız gerekir. Bu, aşağıdaki Azure Notification Hub belgelerindeki adımlar gerçekleştirilerek gerçekleştirilebilir:

Fiziksel bir cihazda anında bildirimler almak istiyorsanız, bir sağlama profili de oluşturmanız gerekir.

Önemli

iOS'ta arka plan bildirimleri almak için uygulamanıza uzak bildirimler arka plan modunu eklemeniz gerekir. Daha fazla bilgi için developer.apple.com adresindeki Uzaktan Bildirimler özelliğini etkinleştirme'ye bakın.

Azure Notification Hub oluşturma

Azure portalında bildirim hub'ı oluşturmak için:

Web tarayıcısında Azure portalında oturum açın.
Azure portalında Kaynak oluştur düğmesine tıklayın ve oluştur düğmesini seçmeden önce Bildirim Hub'ını arayıp seçin.
Bildirim Hub'ı sayfasında aşağıdaki adımları gerçekleştirin:
1. Abonelik alanında, kullanmak istediğiniz Azure aboneliğinin adını seçin ve ardından mevcut bir kaynak grubunu seçin veya yeni bir kaynak grubu oluşturun.
2. Ad Alanı Ayrıntıları alanına yeni ad alanı için benzersiz bir ad girin.
3. Bildirim Hub'ı Ayrıntıları alanına bildirim hub'ı için bir ad yazın. Ad alanı bir veya daha fazla bildirim hub'ı içerdiği için bu gereklidir.
4. Konum açılan listesinde, bildirim hub'ını oluşturmak istediğiniz konumu belirten bir değer seçin.
5. Kullanılabilirlik Alanları seçeneğini gözden geçirin. Kullanılabilirlik alanları olan bir bölge seçtiyseniz, onay kutusu varsayılan olarak seçilidir.
  
  Not
  
  Kullanılabilirlik alanları ücretli bir özellik olduğundan katmanınıza ek ücret eklenir.
6. Olağanüstü durum kurtarma seçeneğini belirleyin: yok, eşleştirilmiş kurtarma bölgesi veya esnek kurtarma bölgesi. Eşleştirilmiş kurtarma bölgesi'ni seçerseniz, yük devretme bölgesi görüntülenir. Esnek kurtarma bölgesi'ni seçerseniz, kurtarma bölgeleri listesinden seçim yapmak için açılan listeyi kullanın.
7. Oluştur düğmesini seçin. Bildirim hub'ı oluşturulur.
Azure portalında yeni oluşturduğunuz bildirim hub'ınıza ve ardından Erişim İlkelerini Yönet > dikey penceresine gidin.
Erişim İlkeleri dikey penceresinde, DefaultFullSharedAccessSignature ilkesinin bağlantı dizesini kaydedin. Bunu daha sonra bildirim hub'ınızla iletişim kuran bir arka uç hizmeti oluştururken gerekecektir.

Bildirim hub'ı oluşturma hakkında daha fazla bilgi için bkz . Azure portalında Azure bildirim hub'ı oluşturma.

Bildirim hub'ında Firebase Cloud Messaging'i yapılandırma

Bildirim hub'ınızı Firebase Cloud Messaging ile iletişim kuracak şekilde yapılandırmak için:

Azure portalında bildirim hub'ınıza göz atın ve Ayarlar > Google (FCM v1) dikey penceresini seçin.

Google (FCM v1) dikey penceresinde Özel Anahtar, İstemci E-postası ve Proje Kimliği alanlarının değerlerini girin. Bu değerler Firebase Cloud Messaging'ten indirdiğiniz özel anahtar JSON dosyasında bulunabilir:

Azure alanı	JSON anahtarı	JSON değeri örneği
Özel Anahtar	`private_key`	Bu değer ile `-----BEGIN PRIVATE KEY-----\n` başlayıp ile `-----END PRIVATE KEY-----\n`bitmelidir.
İstemci E-postası	`client_email`	`firebase-adminsdk-55sfg@pushdemo-d6ab2.iam.gserviceaccount.com`
Proje kodu	`project_id`	`pushdemo-d6ab2`

Google (FCM v1) dikey penceresinde Kaydet düğmesini seçin.

Bildirim hub'ında Apple Anında İletme Bildirimi Hizmetini yapılandırma

Azure portalında bildirim hub'ınıza göz atın ve Ayarlar > Apple (APNS) dikey penceresini seçin. Ardından, bildirim hub'ı için bir sertifika oluştururken daha önce seçtiğiniz yaklaşıma göre uygun adımları izleyin.

Önemli

Uygulama Modu'nu ayarlarken, yalnızca uygulamanızı mağazadan satın alan kullanıcılara anında iletme bildirimleri göndermek istiyorsanız Üretim'i seçin.

Seçenek 1 - .p12 anında iletme sertifikası kullanma

Apple (APNS) dikey penceresinde Sertifika kimlik doğrulama modunu seçin.
Apple (APNS) bıçağında, Sertifikayı Karşıya Yükle alanının yanındaki dosya simgesini seçin. Ardından daha önce dışarı aktardığınız .p12 dosyasını seçin ve karşıya yükleyin.
Apple (APNS) dikey penceresinde, gerekirse Parola alanına sertifika parolasını girin.
Apple (APNS) dikey penceresinde Sandbox uygulama modunu seçin.
Apple (APNS) dikey penceresinde Kaydet düğmesini seçin.

Seçenek 2 - Belirteç tabanlı kimlik doğrulamayı kullanma

Apple (APNS) dikey penceresinde Belirteç kimlik doğrulama modunu seçin.
Apple (APNS) dikey penceresinde, daha önce aldığınız Anahtar Kimliği, Paket Kimliği, Ekip Kimliği ve Belirteç değerlerini girin.
Apple (APNS) dikey penceresinde Sandbox uygulama modunu seçin.
Apple (APNS) dikey penceresinde Kaydet düğmesini seçin.

ASP.NET Core Web API arka uç uygulaması oluşturma

Bu bölümde, cihaz yüklemesini işlemek ve .NET MAUI uygulamasına bildirim göndermek için bir ASP.NET Core Web API arka ucu oluşturacaksınız.

Web API'si projesi oluşturma

Web API'si projesi oluşturmak için:

Visual Studio'da bir ASP.NET Core Web API'si projesi oluşturun:
Yeni projenizi yapılandırın iletişim kutusunda projeyi PushNotificationsAPI olarak adlandırın.
Ek bilgiler iletişim kutusunda HTTPS için yapılandır ve Denetleyicileri kullan onay kutularının etkinleştirildiğinden emin olun:
Proje oluşturulduktan sonra F5 tuşuna basarak projeyi çalıştırın.

Uygulama şu anda WeatherForecastController öğesini launchUrl olarak kullanacak şekilde Properties\launchSettings.json dosyasında yapılandırılmıştır. Uygulama bir web tarayıcısında başlatılır ve bazı JSON verilerini görüntüler.

Önemli

HTTPS kullanan bir ASP.NET Core projesi çalıştırdığınızda Visual Studio, ASP.NET Core HTTPS geliştirme sertifikasının yerel kullanıcı sertifika deponuza yüklenip yüklenmediğini algılar ve eksikse yüklemeyi ve güvenmeyi önerir.
Web tarayıcısını kapatın.
Çözüm Gezgini Denetleyiciler klasörünü genişletin ve WeatherForecastController.cs silin.
Çözüm Gezgini'nde, projenin kökünde, WeatherForecast.cs'yi silin.

Bir komut penceresi açın ve proje dosyasını içeren dizine gidin. Sonra şu komutları çalıştırın:

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

Yer tutucu değerlerini kendi Azure Notification Hub adınızla ve bağlantı dizesi değerleriyle değiştirin. Bunlar Azure Notification Hub'ınızın aşağıdaki konumlarında bulunabilir:

Yapılandırma değeri	Konum
`NotificationHub:Name`	Ad bölümüne Temel Bilgiler özetinde, Genel Bakış sayfasının üst kısmında bakın.
`NotificationHub:ConnectionString`	Erişim İlkeleri sayfasında DefaultFullSharedAccessSignature* bölümüne bakın.

Bu, Gizli Dizi Yöneticisi aracını kullanarak yerel yapılandırma değerlerini ayarlar. Bu, Azure Notification Hub gizli dizilerinizi Visual Studio çözümünden ayrıştırarak bunların kaynak denetimine dahil olmamasını sağlar.

İpucu

Üretim senaryolarında, bağlantı dizesi güvenli bir şekilde depolamak için Azure KeyVault gibi bir hizmeti göz önünde bulundurun.

API anahtarıyla istemcilerin kimliğini doğrulama

İstemcilerin kimliğini bir API anahtarıyla doğrulamak için:

Bir komut penceresi açın ve proje dosyasını içeren dizine gidin. Sonra şu komutları çalıştırın:
```
dotnet user-secrets set "Authentication:ApiKey" <value>
```
Yer tutucu değerini HERHANGI bir değer olabilecek API anahtarınız ile değiştirin.

Visual Studio'da projenize Authentication adlı yeni bir klasör ekleyin ve ardından AuthenticationApiKeyAuthOptionsadlı yeni bir sınıf ekleyin ve kodunu aşağıdaki kodla değiştirin:

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

Visual Studio'da, AuthenticationApiKeyAuthHandleradlı yeni bir sınıf ekleyin ve kodunu aşağıdaki kodla değiştirin:

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

Kimlik doğrulama işleyicisi, bir düzenin davranışını uygulayan bir türdür ve bu durumda özel bir API anahtar düzenidir.

Visual Studio'da, AuthenticationAuthenticationBuilderExtensionsadlı yeni bir sınıf ekleyin ve kodunu aşağıdaki kodla değiştirin:

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

Bu uzantı yöntemi, Program.cs ara yazılım yapılandırma kodunu basitleştirmek için kullanılır.

Visual Studio'da Program.cs dosyasını açın ve builder.Services.AddControllers yönteminin çağrısının altındaki API anahtarı kimlik doğrulaması için kodu güncelleyin.

using PushNotificationsAPI.Authentication;

builder.Services.AddControllers();

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

Program.cs dosyasındaki yorumun altındaki kodu güncelleyerek UseRouting, UseAuthentication ve MapControllers uzantı metotlarını çağırın.
```
// Configure the HTTP request pipeline.

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

app.Run();
```
uzantı yöntemi, UseAuthentication önceden kaydedilmiş kimlik doğrulama düzenini kullanan ara yazılımı kaydeder. UseAuthentication kullanıcıların kimliğinin doğrulanmasını gerektiren herhangi bir ara yazılımdan önce çağrılmalıdır.

Not

Bir API anahtarı belirteç kadar güvenli olmasa da, bu öğretici için yeterlidir ve ASP.NET Ara Yazılımı aracılığıyla kolayca yapılandırılabilir.

Hizmet ekleme ve yapılandırma

Web API arka uç uygulamanıza hizmet eklemek ve yapılandırmak için:

Visual Studio'da Microsoft.Azure.NotificationHubs NuGet paketini projenize ekleyin. Bu NuGet paketi, bir hizmet içinde kapsüllenmiş bildirim hub'ınıza erişmek için kullanılır.

Visual Studio'da projenize Models adlı yeni bir klasör ekleyin, ardından ModelsPushTemplatesadlı yeni bir sınıf ekleyin ve kodunu aşağıdaki kodla değiştirin:

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

PushTemplates sınıfı, genel ve sessiz anında iletme bildirimleri için parçalanmış bildirim yüklerini içerir. Bu yükler, hizmet aracılığıyla mevcut yüklemeleri güncelleştirmek zorunda kalmadan denemelere izin vermek için yüklemenin dışında tanımlanır. Yüklemelerdeki değişiklikleri bu şekilde işlemek, bu makalenin kapsamı dışındadır. Ürün senaryolarında özel şablonlar kullanmayı göz önünde bulundurun.

Visual Studio'da ModelsDeviceInstallationadlı yeni bir sınıf ekleyin ve kodunu aşağıdaki kodla değiştirin:

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

Visual Studio'da ModelsNotificationRequestadlı yeni bir sınıf ekleyin ve kodunu aşağıdaki kodla değiştirin:

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

Visual Studio'da ModelsNotificationHubOptionsadlı yeni bir sınıf ekleyin ve kodunu aşağıdaki kodla değiştirin:

using System.ComponentModel.DataAnnotations;

namespace PushNotificationsAPI.Models;

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

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

Visual Studio'da projenize Services adlı yeni bir klasör ekleyin ve ardından ServicesINotificationServiceadlı yeni bir arabirim ekleyin ve kodunu aşağıdaki kodla değiştirin:

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

Visual Studio'da ServicesNotificationHubServiceadlı yeni bir sınıf ekleyin ve kodunu aşağıdaki kodla değiştirin:

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

yöntemine SendTemplateNotificationsAsync sağlanan etiket ifadesi, yalnızca OR'ler içeriyorsa 20 etiketle sınırlıdır. Aksi takdirde 6 etiketle sınırlıdır. Daha fazla bilgi için bkz . Yönlendirme ve Etiket İfadeleri.

Visual Studio'da Program.cs dosyasını açın ve NotificationHubService'yi builder.Services.AddAuthentication yönteminin çağrısının altına INotificationService'nin bir singleton uygulaması olarak eklemek için kodu güncelleyin.

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

Bildirimler REST API'sini oluşturma

Bildirimler REST API'sini oluşturmak için:

Visual Studio'da Controllers klasörüne adlı NotificationsController yeni bir Denetleyici ekleyin.

İpucu

Okuma/yazma eylemleriyle API Denetleyicisi şablonunu seçin.

NotificationsController.cs dosyasında, dosyanın en üstüne aşağıdaki using deyimleri ekleyin:

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

NotificationsController.cs dosyasında, NotificationsController sınıfına Authorize özelliğini ekleyin:

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

NotificationsController.cs dosyasında oluşturucuyuNotificationsContoller, kayıtlı örneğini INotificationService bağımsız değişken olarak kabul etmek üzere güncelleştirin ve salt okunur bir üyeye atayın:
```
readonly INotificationService _notificationService;

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

NotificationsContoller.cs dosyasında, tüm yöntemleri aşağıdaki kodla değiştirin:

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

Özellikler/launchSettings.json dosyasında, her profil için launchUrl özelliğini weatherforecast'den api/notifications'e değiştirin.

API uygulaması oluşturma

Şimdi arka uç hizmetinizi barındırmak için Azure Uygulaması Hizmeti'ndebir API uygulaması oluşturacaksınız. Bu doğrudan Visual Studio veya Visual Studio Code'dan, Azure CLI, Azure PowerShell, Azure Geliştirici CLI ile ve Azure Portal aracılığıyla gerçekleştirilebilir. Daha fazla bilgi için bkz . Web uygulamanızı yayımlama.

Azure portalında api uygulaması oluşturmak için:

Web tarayıcısında Azure portalında oturum açın.
Azure portalında Kaynak oluştur düğmesine tıklayın ve oluştur düğmesini seçmeden önce API Uygulaması'nı arayıp seçin.

API Uygulaması Oluştur sayfasında Oluştur düğmesini seçmeden önce aşağıdaki alanları güncelleştirin:

Alan	Eylem
Abonelik	Bildirim hub'ını oluşturduğunuz hedef aboneliği seçin.
Kaynak Grubu	Bildirim hub'ını oluşturduğunuz kaynak grubunu seçin.
İsim	Genel olarak benzersiz bir ad girin.
Çalışma zamanı yığını	.NET'in en son sürümünün seçildiğinden emin olun.

API Uygulaması sağlandıktan sonra kaynağa gidin.
Genel Bakış sayfasında, varsayılan etki alanı değerini not edin. Bu URL, .NET MAUI uygulamanız tarafından kullanılacak olan arka uç noktanızdır. URL, biçimiyle https://<app_name>.azurewebsites.netbelirttiğiniz API uygulama adını kullanır.

Azure portalında Ayarlar > Ortam değişkenleri dikey penceresine gidin ve Uygulama ayarları sekmesinin seçili olduğundan emin olun. Ardından Ekle düğmesini kullanarak aşağıdaki ayarları ekleyin:

İsim	Değer
Kimlik Doğrulaması:ApiKey	<api_key_value>
NotificationHub:Name	<hub_name_value>
NotificationHub:BağlantıDizesi	<hub_connection_string_value>

Önemli

Uygulamanın basitleştirilmesi için Authentication:ApiKey ayarı eklendi. Üretim senaryolarında, bağlantı dizesi güvenli bir şekilde depolamak için Azure KeyVault gibi bir hizmeti göz önünde bulundurun.

Bu ayarların tümü girildikten sonra Uygula düğmesini ve ardından Onayladüğmesini seçin.

Arka uç hizmetini yayımlama

Arka uç hizmetinizi Azure Uygulaması Hizmeti'ne yayımlamak için:

Visual Studio'da projenize sağ tıklayın ve Yayımla'yı seçin.
Yayımla sihirbazında Azure'ı ve ardından İleri düğmesini seçin.
Yayımla sihirbazında Azure Uygulaması Hizmeti (Windows) ve ardından İleri düğmesini seçin.
Yayımla sihirbazında, Visual Studio'yu Azure aboneliğinize bağlamak ve uygulamayı yayımlamak için kimlik doğrulama akışını izleyin.

Visual Studio uygulamayı oluşturur, paketler ve Azure'da yayımlar ve ardından uygulamayı varsayılan tarayıcınızda başlatır. Daha fazla bilgi için bkz . ASP.NET web uygulaması yayımlama.

İpucu

Azure portalındaki API uygulamanızın Genel Bakış dikey penceresinden uygulamanız için bir yayımlama profili indirebilir ve ardından visual studio'daki profili kullanarak uygulamanızı yayımlayabilirsiniz.

Yayımlanan API'yi doğrulama

API uygulamasının doğru yayımlandığını denetlemek için, aşağıdaki adrese istek POST göndermek için tercih ettiğiniz REST araçlarını kullanmanız gerekir:

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

Not

Temel adres şeklindedir https://<app_name>.azurewebsites.net.

İstek üst bilgilerini anahtarı apikey ve değerini içerecek şekilde yapılandırdığınızdan, gövdeyi ham olarak ayarladığınızdan ve aşağıdaki yer tutucu JSON içeriğini kullandığınızdan emin olun:

{}

Hizmetten bir 400 Bad Request yanıt almanız gerekir.

Not

Bu işlem .NET MAUI uygulamasından platforma özgü bilgiler gerektireceğinden, geçerli istek verilerini kullanarak API'yi test etmek henüz mümkün değildir.

REST API'lerini çağırma hakkında daha fazla bilgi için bkz . Visual Studio'da .http dosyalarını kullanma ve Http Repl ile web API'lerini test edin. Visual Studio Code'da REST İstemcisi, REST API'lerini test etmek için kullanılabilir.

.NET MAUI uygulaması oluşturma

Bu bölümde, arka uç hizmeti aracılığıyla bir bildirim hub'ından anında iletme bildirimleri almak üzere kaydolmanızı ve kaydını kaldırmanızı sağlayan bir .NET Çok Platformlu Uygulama Kullanıcı Arabirimi (.NET MAUI) uygulaması oluşturacaksınız.

.NET MAUI uygulamanızı oluşturmak için:

Visual Studio'da.NET MAUI Uygulaması proje şablonunu kullanarak PushNotificationsDemo adlı yeni bir .NET MAUI uygulaması oluşturun.

Visual Studio'da. .NET MAUI projesine Models adlı yeni bir klasör ekleyin ve ardından Models klasörüne adlı DeviceInstallation yeni bir sınıf ekleyin ve kodunu aşağıdaki kodla değiştirin:

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

Visual Studio'da ModelsPushDemoActionadlı bir numaralandırma ekleyin ve kodunu aşağıdaki kodla değiştirin:
```
namespace PushNotificationsDemo.Models;

public enum PushDemoAction
{
    ActionA,
    ActionB
}
```
Visual Studio'da. .NET MAUI projesine Services adlı yeni bir klasör ekleyin, ardından Services klasörüne adlı IDeviceInstallationServiceyeni bir arabirim ekleyin ve kodunu aşağıdaki kodla değiştirin:
```
using PushNotificationsDemo.Models;

namespace PushNotificationsDemo.Services;

public interface IDeviceInstallationService
{
    string Token { get; set; }
    bool NotificationsSupported { get; }
    string GetDeviceId();
    DeviceInstallation GetDeviceInstallation(params string[] tags);
}
```
Bu arabirim, arka uç hizmetinin gerektirdiği bilgileri sağlamak DeviceInstallation için daha sonra her platformda uygulanacaktır.

Visual Studio'da ServicesINotificationRegistrationServiceadlı bir arabirim ekleyin ve kodunu aşağıdaki kodla değiştirin:

namespace PushNotificationsDemo.Services;

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

Bu arabirim, istemci ile arka uç hizmeti arasındaki etkileşimi işler.

Visual Studio'da ServicesINotificationActionServiceadlı bir arabirim ekleyin ve kodunu aşağıdaki kodla değiştirin:
```
namespace PushNotificationsDemo.Services;

public interface INotificationActionService
{
    void TriggerAction(string action);
}
```
Bu arabirim, bildirim eylemlerinin işlenmesini merkezileştirmek için basit bir mekanizma olarak kullanılacaktır.
Visual Studio'da ServicesIPushDemoNotificationActionServiceadlı bir arabirim ekleyin ve kodunu aşağıdaki kodla değiştirin:
```
using PushNotificationsDemo.Models;

namespace PushNotificationsDemo.Services;

public interface IPushDemoNotificationActionService : INotificationActionService
{
    event EventHandler<PushDemoAction> ActionTriggered;
}
```
IPushDemoNotificationActionService türü bu uygulamaya özgüdür ve tetiklenen eylemi güçlü bir şekilde yazılmış bir yaklaşım kullanarak tanımlamak için PushDemoAction numaralandırmasını kullanır.

Visual Studio'da ServicesNotificationRegistrationServiceadlı bir sınıf ekleyin ve kodunu aşağıdaki kodla değiştirin:

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

Visual Studio'da ServicesPushDemoNotificationActionServiceadlı bir sınıf ekleyin ve kodunu aşağıdaki kodla değiştirin:

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

Visual Studio'da, projenin köküne adlı Config bir sınıf ekleyin ve kodunu aşağıdaki kodla değiştirin:
```
namespace PushNotificationsDemo;

public static partial class Config
{
    public static string ApiKey = "API_KEY";
    public static string BackendServiceEndpoint = "BACKEND_SERVICE_ENDPOINT";
}
```
Config sınıfı, gizli dizilerinizi kaynak denetiminden uzak tutmak için basit bir yol olarak kullanılır. Bu değerleri otomatik bir derlemenin parçası olarak değiştirebilir veya yerel bir kısmi sınıf kullanarak geçersiz kılabilirsiniz.

Önemli

.NET MAUI uygulamasında temel adresi belirtirken, bu adresin / ile sona erdiğinden emin olun.
Visual Studio'da, projenin köküne adlı Config.local_secrets bir sınıf ekleyin. Ardından Config.local_secrets.cs dosyasındaki kodu aşağıdaki kodla değiştirin:
```
namespace PushNotificationsDemo;

public static partial class Config
{
    static Config()
    {
        ApiKey = "<your_api_key>";
        BackendServiceEndpoint = "<your_api_app_url>";
    }
}
```
Yer tutucu değerlerini arka uç hizmetini oluştururken seçtiğiniz değerlerle değiştirin. BackendServiceEndpoint URL biçimini https://<api_app_name>.azurewebsites.net/kullanmalıdır.

İpucu

Kaynak denetimine bu dosyanın gönderilmesini önlemek için *.local_secrets.* dosyanıza .gitignore eklemeyi unutmayın.

Kullanıcı arabirimini oluşturma

Uygulamanın kullanıcı arabirimini oluşturmak için:

Visual Studio'da MainPage.xaml dosyasını açın ve VerticalStackLayout ve alt öğelerini aşağıdaki XAML ile değiştirin.

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

Visual Studio'da MainPage.xaml.cs'yi açın ve using ad alanı için bir PushNotificationsDemo.Services deyimi ekleyin.
```
using PushNotificationsDemo.Services;
```
MainPage.xaml.cs dosyasında, readonly uygulamanın INotificationRegistrationService implementasyonuna referans depolamak için bir yedekleme alanı ekleyin:
```
readonly INotificationRegistrationService _notificationRegistrationService;
```
Oluşturucuda MainPage uygulamayı çözümleyin INotificationRegistrationService ve yedekleme alanına atayın _notificationRegistrationService :
```
public MainPage(INotificationRegistrationService service)
{
    InitializeComponent();

    _notificationRegistrationService = service;
}
```

MainPage sınıfında, OnRegisterButtonClicked ve OnDeregisterButtonClicked olay işleyicilerini uygulayarak, INotificationRegistrationService nesnesi üzerinde karşılık gelen kayıt ve kayıt silme yöntemlerini çağırın:

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

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(() =>
    {
        DisplayAlertAsync("Push notifications demo", message, "OK")
            .ContinueWith((task) =>
            {
                if (task.IsFaulted)
                    throw task.Exception;
            });
    });
}

Önemli

Uygulamada, bu işlevselliğin daha kolay keşfedilmesine ve test edilmesine izin vermek için kullanıcı girişine yanıt olarak kayıt ve kayıt kaldırma gerçekleştirilir. Üretim uygulamasında genellikle kayıt ve kayıt kaldırma eylemlerini uygulama yaşam döngüsünde uygun bir noktada, açık kullanıcı girişi gerektirmeden gerçekleştirirsiniz.

Visual Studio'da App.xaml.cs açın ve aşağıdaki using deyimleri ekleyin:

using PushNotificationsDemo.Models;
using PushNotificationsDemo.Services;

App.xaml.cs'da, readonly implementasyonuna referans depolamak için IPushDemoNotificationActionService bir arka plan alanı ekleyin:
```
readonly IPushDemoNotificationActionService _actionService;
```

Oluşturucuda App uygulamasını çözümleyip _actionService yedekleme alanına atayın ve IPushDemoNotificationActionService.ActionTriggered olayına abone olun:

public App(IPushDemoNotificationActionService service)
{
    InitializeComponent();

    _actionService = service;
    _actionService.ActionTriggered += NotificationActionTriggered;

    MainPage = new AppShell();
}

Oluşturucuda IPushDemoNotificationActionService uygulamayı çözümleyip, _actionService yedekleme alanına atayın ve IPushDemoNotificationActionService.ActionTriggered olaya abone olun.

public App(IPushDemoNotificationActionService service)
{
    InitializeComponent();

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

App sınıfında, olay için olay işleyicisini IPushDemoNotificationActionService.ActionTriggered uygulayın:

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

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

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

Olay işleyicisi ActionTriggered olayı, push bildirimi eylemlerinin alınmasını ve yayılmasını gösterir. Bunlar genellikle sessizce işlenir, örneğin belirli bir görünüme gitmek veya bir uyarı görüntülemek yerine bazı verileri yenilemek.

Android uygulamasını yapılandırma

Android üzerinde .NET MAUI uygulamanızı anında iletme bildirimleri alacak ve işleyecek şekilde yapılandırmak için:

Visual Studio'da Xamarin.Firebase.Messaging NuGet paketini .NET MAUI uygulama projenize ekleyin.
Visual Studio'da google-services.json dosyanızı .NET MAUI uygulama projenizin Platforms/Android klasörüne ekleyin. Dosya projenize eklendikten sonra derleme eylemiyle GoogleServicesJsoneklenmelidir:
```
<ItemGroup Condition="'$(TargetFramework)' == 'net8.0-android'">
  <GoogleServicesJson Include="Platforms\Android\google-services.json" />
</ItemGroup>
```
İpucu

Bu dosyanın kaynak denetimine beyan edilmesini önlemek için dosyanıza google-services.json eklemeyi unutmayın .gitignore.
Visual Studio'da proje dosyasını (*.csproj) düzenleyin ve Android için değerini 26.0 olarak ayarlayın SupportedOSPlatformVersion :
```
<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'android'">26.0</SupportedOSPlatformVersion>
```
Google, API 26'da Android bildirim kanallarında değişiklikler yaptı. Daha fazla bilgi için bkz . developer.android.com bildirim kanalları .

Projenin Platforms/Android klasörüne adlı DeviceInstallationService yeni bir sınıf ekleyin ve kodunu aşağıdaki kodla değiştirin:

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

Bu sınıf, Secure.AndroidId değerini ve bildirim hub'ı kayıt yükünü kullanarak benzersiz bir kimlik vermektedir.

Projenin Platforms/Android klasörüne adlı PushNotificationFirebaseMessagingService yeni bir sınıf ekleyin ve kodunu aşağıdaki kodla değiştirin:

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

Bu sınıf, filtreyi içeren bir IntentFilter özniteliğine com.google.firebase.MESSAGING_EVENT sahiptir. Bu filtre, Android'in işlenmek üzere gelen iletileri bu sınıfa geçirmesini sağlar.

Firebase Cloud Messaging mesaj formatı hakkında bilgi için developer.android.com'daki FCM mesajları hakkında bölümüne bakın.

Visual Studio'da Platformlar/Android klasöründe MainActivity.cs dosyasını açın ve aşağıdaki using deyimleri ekleyin:

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

MainActivity sınıfında, LaunchMode öğesini SingleTop olarak ayarlayın, böylece MainActivity açıldığında yeniden oluşturulmaz.

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

MainActivity sınıfında, IPushDemoNotificationActionService ve IDeviceInstallationService uygulamalarına başvuruları depolamak için arkaplan alanları ekleyin.
```
IPushDemoNotificationActionService _notificationActionService;
IDeviceInstallationService _deviceInstallationService;
```

MainActivity sınıfında, uygulamanın bağımlılık enjeksiyonu kapsayıcısından somut uygulamalarını alan NotificationActionServiceDeviceInstallationService özel özellikleri ekleyin.

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

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

MainActivity sınıfında Firebase belirtecini edinip depolamak için Android.Gms.Tasks.IOnSuccessListener arabirimi uygulayın.

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

MainActivity sınıfına, belirli bir Intent'nin action adlı ek bir değere sahip olup olmadığını kontrol edecek ProcessNotificationActions yöntemini ekleyin ve daha sonra IPushDemoNotificationActionService uygulamasını kullanarak action'yü koşullu olarak tetikleyin.

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 sınıfında OnNewIntent yöntemini, ProcessNotificationActions yöntemini çağıracak şekilde geçersiz kılın.
```
protected override void OnNewIntent(Intent? intent)
{
    base.OnNewIntent(intent);
    ProcessNotificationsAction(intent);
}
```
LaunchMode için Activity, SingleTop olarak ayarlandığından, Intent üstü yazılarak mevcut Activity örneğine bir OnCreate gönderilecektir, OnNewIntent yöntemi yerine. Bu nedenle, hem OnNewIntent hem de OnCreate içinde gelen bir niyeti işlemeniz gerekir.
MainActivity sınıfında yöntemini geçersiz kılarak OnCreate yöntemini çağırın ProcessNotificationActions ve firebase'den belirteci almak için öğesini olarak MainActivityekleyinIOnSuccessListener:
```
protected override void OnCreate(Bundle? savedInstanceState)
{
    base.OnCreate(savedInstanceState);

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

    ProcessNotificationsAction(Intent);
}
```
Not

Anında iletme bildirimleri almaya devam etmek için uygulamanın her çalıştırdığınızda yeniden kaydedilmesi ve hata ayıklama oturumundan durdurulması gerekir.
Visual Studio'da, Platformlar/AndroidPOST_NOTIFICATIONSAndroidManifest.xml dosyasına izni ekleyin:
```
<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
```
Bu izin hakkında daha fazla bilgi için developer.android.com sitesinde Bildirim çalışma zamanı izni bölümüne bakın.
Visual Studio'da MainPage.xaml.cs açın ve sınıfına MainPage aşağıdaki kodu ekleyin:
```
#if ANDROID
        protected override async void OnAppearing()
        {
            base.OnAppearing();

            PermissionStatus status = await Permissions.RequestAsync<Permissions.PostNotifications>();
        }
#endif
```
Android'de MainPage göründüğünde bu kod çalışır ve kullanıcıdan POST_NOTIFICATIONS izni vermesini ister. .NET MAUI izinleri hakkında daha fazla bilgi için bkz . İzinler.

iOS uygulamasını yapılandırma

iOS simülatörü, Apple silikon veya T2 işlemcili Mac bilgisayarlarda macOS 13+ sürümünde çalışırken iOS 16+'da uzaktan bildirimleri destekler. Her simülatör, bu simülatörün ve üzerinde çalıştığı Mac donanımının birleşimine özgü kayıt belirteçleri oluşturur.

Önemli

Simülatör, Apple Anında Bildirim Servisi test ortamını destekler.

Aşağıdaki yönergelerde, bir iOS simülatöründe uzak bildirimleri almayı destekleyen bir donanım kullandığınız varsayılır. Bu durum böyle değilse, iOS uygulamasını fiziksel bir cihazda çalıştırmanız gerekecektir, bu da Anında İletme Bildirimleri özelliğini içeren bir sağlama profili oluşturmanızı gerektirir. Ardından uygulamanızın sertifikanız ve sağlama profiliniz kullanılarak derlendiğinden emin olmanız gerekir. Bunun nasıl yapılacağı hakkında daha fazla bilgi için iOS uygulamanızı Azure Notification Hubs ile çalışacak şekilde ayarlama sayfasına bakın ve ardından aşağıdaki yönergeleri izleyin.

iOS'ta .NET MAUI uygulamanızı push bildirimlerini alacak ve işleyecek şekilde yapılandırmak için:

Visual Studio'da proje dosyasını (*.csproj) düzenleyin ve iOS için değerini 13.0 olarak ayarlayın SupportedOSPlatformVersion :
```
<SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'ios'">13.0</SupportedOSPlatformVersion>
```
Apple, iOS 13'teki gönderim servisinde değişiklikler yaptı. Daha fazla bilgi için bkz . iOS 13 için Azure Notification Hubs güncelleştirmeleri.
Visual Studio'da projenin Platforms/iOS klasörüne bir Entitlements.plist dosyası ekleyin ve dosyaya aşağıdaki XML'yi ekleyin:
```
<?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>
```
Bu, APS ortam yetkilendirmesini ayarlar ve Apple Geliştirme Bildirim hizmeti ortamını kullanmayı belirtir. Üretim uygulamalarında bu yetkilendirme değeri olarak productionayarlanmalıdır. Bu yetkilendirme hakkında daha fazla bilgi için, developer.apple.com üzerindeki APS Ortam Yetkilendirmesi'ne bakın.

Yetkilendirme dosyası ekleme hakkında daha fazla bilgi için bkz . iOS yetkilendirmeleri.

Visual Studio'da, projenin Platforms/iOS klasörüne adlı DeviceInstallationServiceyeni bir sınıf ekleyin ve dosyaya aşağıdaki kodu ekleyin:

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

Bu sınıf, UIDevice.IdentifierForVendor değerini ve bildirim hub'ı kayıt yükünü kullanarak benzersiz bir kimlik sağlar.

Visual Studio'da, projenin Platforms/iOS klasörüne adlı NSDataExtensionsyeni bir sınıf ekleyin ve dosyaya aşağıdaki kodu ekleyin:

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

ToHexString uzantı yöntemi, aldığınız cihaz belirtecini ayrıştıracak olan ekleyceğiniz kod tarafından kullanılacaktır.

Visual Studio'da Platformlar/iOS klasöründe AppDelegate.cs dosyasını açın ve aşağıdaki using deyimleri ekleyin:

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

AppDelegate sınıfında, IPushDemoNotificationActionService, INotificationRegistrationService ve IDeviceInstallationService uygulamalarına başvuruları depolamak üzere arka plan alanları ekleyin.
```
IPushDemoNotificationActionService _notificationActionService;
INotificationRegistrationService _notificationRegistrationService;
IDeviceInstallationService _deviceInstallationService;
```

AppDelegate sınıfında, uygulamanın bağımlılık ekleme kapsayıcısından somut uygulamalarını getiren NotificationActionService, NotificationRegistrationService ve DeviceInstallationService özel özellikler ekleyin:

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 sınıfında IDeviceInstallationService.Token özelliğinin değerini ayarlamak için CompleteRegistrationAsync yöntemini ekleyin.
```
Task CompleteRegistrationAsync(NSData deviceToken)
{
    DeviceInstallationService.Token = deviceToken.ToHexString();
    return NotificationRegistrationService.RefreshRegistrationAsync();
}
```
Bu yöntem ayrıca kaydı yeniler ve cihaz belirtecini son depolandığından beri güncelleştirildiyse önbelleğe alır.

AppDelegate sınıfında, bildirim verilerini işlemek ve koşullu olarak NotificationActionService.TriggerAction çağırmak için ProcessNotificationActions yöntemini ekleyin:

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 sınıfında CompleteRegistrationAsync metoduna deviceToken argümanını geçirerek RegisteredForRemoteNotifications metodunu ekleyin.

[Export("application:didRegisterForRemoteNotificationsWithDeviceToken:")]
public void RegisteredForRemoteNotifications(UIApplication application, NSData deviceToken)
{
    CompleteRegistrationAsync(deviceToken)
        .ContinueWith((task) =>
        {
            if (task.IsFaulted)
                throw task.Exception;
        });
}

Bu yöntem, uygulama uzaktan bildirim almak üzere kaydedildiğinde çağrılır ve cihazdaki uygulamanızın adresi olan benzersiz cihaz belirtecini istemek için kullanılır.

AppDelegate sınıfında, userInfo bağımsız değişkenini ProcessNotificationActions yöntemine geçirerek ReceivedRemoteNotification yöntemini ekleyin.
```
[Export("application:didReceiveRemoteNotification:")]
public void ReceivedRemoteNotification(UIApplication application, NSDictionary userInfo)
{
    ProcessNotificationActions(userInfo);
}
```
Bu yöntem, uygulama bir uzak bildirim aldığında çağrılır ve bildirimi işlemek için kullanılır.
AppDelegate sınıfında, hataları günlüğe kaydetmek için FailedToRegisterForRemoteNotifications yöntemini ekleyin:
```
[Export("application:didFailToRegisterForRemoteNotificationsWithError:")]
public void FailedToRegisterForRemoteNotifications(UIApplication application, NSError error)
{
    Debug.WriteLine(error.Description);
}
```
Uygulama uzak bildirimleri almak için kaydolmakta başarısız olduğunda bu yöntem çağrılır. Cihaz ağa bağlı değilse, APNS sunucusuna ulaşılamıyorsa veya uygulama yanlış yapılandırılmışsa kayıt başarısız olabilir.

Not

Üretim senaryoları için, FailedToRegisterForRemoteNotifications yönteminde düzgün bir şekilde günlük tutma ve hata işleme uygulamak isteyeceksiniz.

AppDelegate sınıfında, bildirimleri kullanmak ve uzak bildirimlere kaydolmak için koşullu olarak izin isteme yöntemi ekleyin FinishedLaunching.

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

Bildirimleri kullanmak için izin isteme hakkında bilgi için Bildirimleri Kullanmak için İzin İsteme başlığına developer.apple.com adresinden bakın.

iOS'taki bildirimler hakkında bilgi için bkz . developer.apple.com'de Kullanıcı Bildirimleri .

Uygulamanın bağımlılık ekleme kapsayıcısına türleri kaydetme

Visual Studio'da MauiProgram.cs dosyasını açın ve ad alanı için bir usingPushNotificationsDemo.Services deyimi ekleyin:
```
using PushNotificationsDemo.Services;
```

MauiProgram sınıfında, her platformda DeviceInstallationService'yi kaydeden ve çapraz platform PushDemoNotificationActionService ve NotificationRegistrationService hizmetlerini kaydeden RegisterServices uzantı yöntemi için kod ekleyin ve bir MauiAppBuilder nesnesi döndürün:

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 sınıfında, RegisterViews uzantı yöntemi için kod ekleyin, bu yöntem MainPage türünü tekil olarak kaydeder ve bir MauiAppBuilder nesnesi döndürür.
```
public static MauiAppBuilder RegisterViews(this MauiAppBuilder builder)
{
    builder.Services.AddSingleton<MainPage>();
    return builder;
}
```
Tür MainPage , bağımlılık INotificationRegistrationService gerektirdiğinden ve bağımlılık gerektiren tüm türlerin bağımlılık ekleme kapsayıcısıyla kaydedilmesi gerektiğinden kaydedilir.

MauiProgram sınıfında, CreateMauiApp yöntemini RegisterServices ve RegisterViews uzantı yöntemlerini çağıracak şekilde değiştirin.

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

.NET MAUI'de bağımlılık ekleme hakkında daha fazla bilgi için bkz . Bağımlılık ekleme.

Uygulamayı test etme

Arka uç hizmetini kullanarak veya Azure portalı aracılığıyla uygulamaya anında iletme bildirimleri göndererek uygulamanızı test edebilirsiniz.

iOS simülatörü, Apple silikon veya T2 işlemcili Mac bilgisayarlarda macOS 13+ sürümünde çalışırken iOS 16+'da uzaktan bildirimleri destekler. Bu donanım gereksinimlerini karşılamıyorsanız iOS uygulamanızı fiziksel bir cihazda test etmek zorunda olursunuz. Android'de uygulamanızı geliştirici kilidi açılmış bir fiziksel cihazda veya öykünücüde test edebilirsiniz.

Android ve iOS, arka planda çalışırken uygulama adına anında iletme bildirimleri görüntüler. Bildirim alındığında uygulama ön planda çalışıyorsa, davranışı uygulama kodu belirler. Örneğin, uygulamanızın arabirimini bildirimde yer alan yeni bilgileri yansıtacak şekilde güncelleştirebilirsiniz.

Arka uç hizmetini kullanarak test edin

Azure Uygulama Hizmeti'ne yayımlanan arka uç hizmeti aracılığıyla uygulamanıza bir test bildirimi göndermek için:

Visual Studio'da Android veya iOS'ta PushNotificationsDemo uygulamasını çalıştırın ve Kaydet düğmesini seçin.

Not

Android'de test ediyorsanız hata ayıklama yapılandırmasını kullanarak çalışmadığınızdan emin olun. Alternatif olarak, uygulama daha önce dağıtıldıysa zorla kapatıldığından emin olun ve ardından başlatıcıdan yeniden başlatın.

Seçtiğiniz REST aracında aşağıdaki adrese bir POST istek gönderin:

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

İstek üst bilgilerini anahtarı apikey ve değerini içerecek şekilde yapılandırdığınızdan, gövdeyi ham olarak ayarladığınızdan ve aşağıdaki JSON içeriğini kullandığınızdan emin olun:

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

Genel istek aşağıdaki örneğe benzer olmalıdır:

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

Seçtiğiniz REST araçlarında 200 Tamam yanıtı aldığınızı doğrulayın.
Android veya iOS'taki uygulamada, alınan ActionA eylemini gösteren bir uyarı görünmelidir.

Azure portalını kullanarak test edin

Azure Notification Hubs, uygulamanızın anında iletme bildirimleri alıp almadığını denetlemenizi sağlar.

Azure portalı aracılığıyla uygulamanıza test anında iletme bildirimi göndermek için:

Visual Studio'da Android veya iOS'ta PushNotificationsDemo uygulamasını çalıştırın ve Kaydet düğmesini seçin.

Not

Android'de test ediyorsanız hata ayıklama yapılandırmasını kullanarak çalışmadığınızdan emin olun. Alternatif olarak, uygulama daha önce dağıtıldıysa zorla kapatıldığından emin olun ve ardından başlatıcıdan yeniden başlatın.
Azure portalında bildirim hub'ınıza göz atın ve Genel Bakış dikey penceresinde Göndermeyi Sına düğmesini seçin.
Test Gönder dikey penceresinde, gerekli Platform'u seçin ve yükü değiştirin.

Apple için aşağıdaki yükü kullanın:
```
{
  "aps": {
    "alert": "Message from Notification Hub!"
  },
  "action": "action_a"
}
```
Android için aşağıdaki yükü kullanın:
```
{
  "message": {
    "notification": {
      "title": "PushDemo",
      "body": "Message from Notification Hub!"
    },
    "data": {
      "action": "action_a"
    }
  }
}
```
Azure portalı, bildirimin başarıyla gönderildiğini belirtmelidir.

Firebase Cloud Messaging mesaj formatı hakkında bilgi için developer.android.com'da FCM iletileri hakkında bölümüne bakın.
Android veya iOS'taki uygulamada, alınan ActionA eylemini gösteren bir uyarı görünmelidir.

Sorun giderme

Aşağıdaki bölümlerde, istemci uygulamasında bildirimler alınırken karşılaşılan yaygın sorunlar açıklanmıştır.

Arka uç hizmetinden yanıt yok

Yerel olarak test ederken arka uç hizmetinin çalıştığından ve doğru bağlantı noktasını kullandığından emin olun.

Azure API uygulamasıyla test ediyorsanız hizmetin çalışıp çalışmadığını ve dağıtıldığını ve hatasız olarak başlatıldığını denetleyin.

REST araçlarınızda veya .NET MAUI uygulama yapılandırmanızda temel adresi doğru belirttiğinizden emin olun. Temel adres, yerel olarak test ederken https://<api_name>.azurewebsites.net veya https://localhost:7020 olmalıdır.

Arka uç hizmetinden 401 durum kodu alma

İstek üst bilgisini doğru ayarladığınızı apikey ve bu değerin arka uç hizmeti için yapılandırdığınız değerle eşleşip eşleşmediğini doğrulayın.

Yerel olarak test ederken bu hatayı alırsanız, .NET MAUI uygulamanızda tanımladığınız anahtar değerinin Authentication:ApiKey arka uç hizmeti tarafından kullanılan kullanıcı gizli dizileri değeriyle eşleştiğinden emin olun.

Bir Azure API uygulamasıyla test ediyorsanız.NET MAUI uygulamanızda tanımlanan anahtar değerinin Authentication:ApiKey Azure portalında tanımlanan uygulama ayarı değeriyle eşleştiğinden emin olun. Arka uç hizmetini dağıttıktan sonra bu uygulama ayarını oluşturduysanız veya değiştirdiyseniz, değerin geçerli olması için hizmeti yeniden başlatmanız gerekir.

Arka uç hizmetinden 404 durum kodu alma

Uç nokta ve HTTP istek yönteminin doğru olduğunu doğrulayın:

KOYMAK- https://<api_name>.azurewebsites.net/api/notifications/installations
SİLMEK- https://<api_name>.azurewebsites.net/api/notifications/installations/<installation_id>
YAYINLA- https://<api_name>.azurewebsites.net/api/notifications/requests

Veya yerel olarak test ederken:

KOYMAK- https://localhost:7020/api/notifications/installations
SİL - https://localhost:7020/api/notifications/installations/<installation_id>
YAYINLA- https://localhost:7020/api/notifications/requests

Önemli

.NET MAUI uygulamasında temel adresi belirtirken, adresin "/" ile sona erdiğinden emin olun. Taban adresi, yerel olarak test ederken https://<api_name>.azurewebsites.net veya https://localhost:7020/ olmalı.

Hata ayıklama oturumunu başlattıktan veya durdurduktan sonra Android'de bildirim alınmıyor

Her hata ayıklama oturumu başlatırken kayıt olduğunuzdan emin olun. Hata ayıklayıcı yeni bir Firebase belirtecinin oluşturulmasına neden olur ve bu nedenle bildirim hub'ı yüklemesinin güncelleştirilmesi gerekir.

Kayıt yapılamıyor ve bir bildirim hub'ının hata iletisi görüntüleniyor.

Test cihazının ağ bağlantısı olduğunu doğrulayın. Ardından, StatusCode içindeki HttpResponse özelliğini incelemek için bir kesme noktası ayarlayarak HTTP yanıt durum kodunu belirleyin.

Durum koduna bağlı olarak, uygun olduğunda önceki sorun giderme önerilerini gözden geçirin.

İlgili API için belirli durum kodları döndüren satırlarda bir kesme noktası ayarlayın. Ardından yerel olarak hata ayıklarken arka uç hizmetini çağırmayı deneyin.

Arka uç hizmetinin seçtiğiniz REST araçları tarafından beklendiği gibi çalıştığını doğrulayın ve seçtiğiniz platform için .NET MAUI uygulaması tarafından oluşturulan yükü kullanın.

Hiçbir adımın kaçırılmadığından emin olmak için platforma özgü yapılandırma bölümlerini gözden geçirin. Seçtiğiniz platform için ve InstallationId değişkenleri için Token uygun değerlerin çözümlenip çözümlenmediğini denetleyin.

Cihaz için bir kimlik çözümlenemiyor, cihaz hata iletisi

Hiçbir adımın kaçırılmadığından emin olmak için platforma özgü yapılandırma bölümlerini gözden geçirin.

Aracılığıyla paylaş

Eğitim: Arka uçta bir hizmet aracılığıyla Azure Notification Hubs kullanarak .NET MAUI uygulamalarına push bildirimleri gönderme

Önkoşullar

Anında iletme bildirimi hizmetlerini ve Azure Notification Hub'ı ayarlama

Firebase projesi oluşturma

iOS uygulamanızı anında iletme bildirimleri için kaydetme

Azure Notification Hub oluşturma

Bildirim hub'ında Firebase Cloud Messaging'i yapılandırma

Bildirim hub'ında Apple Anında İletme Bildirimi Hizmetini yapılandırma

Seçenek 1 - .p12 anında iletme sertifikası kullanma

Seçenek 2 - Belirteç tabanlı kimlik doğrulamayı kullanma

ASP.NET Core Web API arka uç uygulaması oluşturma

Web API'si projesi oluşturma

API anahtarıyla istemcilerin kimliğini doğrulama

Hizmet ekleme ve yapılandırma

Bildirimler REST API'sini oluşturma

API uygulaması oluşturma

Arka uç hizmetini yayımlama

Yayımlanan API'yi doğrulama

.NET MAUI uygulaması oluşturma

Kullanıcı arabirimini oluşturma

Android uygulamasını yapılandırma

iOS uygulamasını yapılandırma

Uygulamanın bağımlılık ekleme kapsayıcısına türleri kaydetme

Uygulamayı test etme

Arka uç hizmetini kullanarak test edin

Azure portalını kullanarak test edin

Sorun giderme

Arka uç hizmetinden yanıt yok

Arka uç hizmetinden 401 durum kodu alma

Arka uç hizmetinden 404 durum kodu alma

Hata ayıklama oturumunu başlattıktan veya durdurduktan sonra Android'de bildirim alınmıyor

Kayıt yapılamıyor ve bir bildirim hub'ının hata iletisi görüntüleniyor.

Cihaz için bir kimlik çözümlenemiyor, cihaz hata iletisi

Geri Bildirim

Ek kaynaklar