içinde yerel bildirimler Xamarin.Forms

Örneği indirme

Yerel bildirimler, mobil cihazda yüklü uygulamalar tarafından gönderilen uyarılardır. Yerel bildirimler genellikle şunlar gibi özellikler için kullanılır:

• Takvim etkinlikleri
• Anımsatıcılar
• Konum tabanlı tetikleyiciler

Her platform yerel bildirimlerin oluşturulmasını, görüntülemesi ve tüketimini farklı şekilde ele alır. Bu makalede, ile yerel bildirimler göndermek, zamanlamayı ve almak için platformlar arası soyutlama oluşturma Xamarin.Forms açıklanmıştır.

Platformlar arası arabirim oluşturma

Uygulama, Xamarin.Forms temel platform uygulamalarıyla ilgili endişeye gerek kalmadan bildirimler oluşturmalı ve tüketir. Aşağıdaki arabirim paylaşılan kod kitaplığında uygulanır ve uygulamanın bildirimlerle etkileşim kurmak için kullanabileceği INotificationManager platformlar arası bir API tanımlar:

public interface INotificationManager
{
    event EventHandler NotificationReceived;
    void Initialize();
    void SendNotification(string title, string message, DateTime? notifyTime = null);
    void ReceiveNotification(string title, string message);
}

Bu arabirim her platform projesinde uygulanacaktır. Olay, NotificationReceived uygulamanın gelen bildirimleri işlemesi için izin verir. yöntemi, Initialize bildirim sistemini hazırlamak için gereken tüm yerel platform mantığını gerçekleştireblir. yöntemi, SendNotification isteğe bağlı olarak bir bildirim göndereblir. DateTime ReceiveNotificationYöntemin, bir ileti alınarak temel alınan platform tarafından çağrılsı gerekir.

arabirimini Xamarin.Forms

Bir arabirim oluşturulduktan sonra, platform uygulamaları henüz oluşturulmamış olsa bile Xamarin.Forms paylaşılan projede kullanılabilir. Örnek uygulama aşağıdaki ContentPage içeriğe sahip ContentPage adlı bir dosya içerir:

<StackLayout Margin="0,35,0,0"
             x:Name="stackLayout">
    <Label Text="Click the button below to create a local notification."
           TextColor="Red"
           HorizontalOptions="Center"
           VerticalOptions="Start" />
    <Button Text="Create Notification"
            HorizontalOptions="Center"
            VerticalOptions="Start"
            Clicked="OnSendClick" />
    <Label Text="Click the button below to schedule a local notification for in 10 seconds time."
           TextColor="Red"
           HorizontalOptions="Center"
           VerticalOptions="Start" />
    <Button Text="Create Notification"
            HorizontalOptions="Center"
            VerticalOptions="Start"
            Clicked="OnScheduleClick" />
</StackLayout>

Düzen, Label yönergeleri açıklayan öğeleri ve tapped Button olduğunda bildirim gönderen veya zamanlayacak öğeleri içerir.

Arka MainPage alınan sınıf kodu bildirimlerin gönderilmesini ve alınarak işleme alır:

public partial class MainPage : ContentPage
{
    INotificationManager notificationManager;
    int notificationNumber = 0;

    public MainPage()
    {
        InitializeComponent();

        notificationManager = DependencyService.Get<INotificationManager>();
        notificationManager.NotificationReceived += (sender, eventArgs) =>
        {
            var evtData = (NotificationEventArgs)eventArgs;
            ShowNotification(evtData.Title, evtData.Message);
        };
    }

    void OnSendClick(object sender, EventArgs e)
    {
        notificationNumber++;
        string title = $"Local Notification #{notificationNumber}";
        string message = $"You have now received {notificationNumber} notifications!";
        notificationManager.SendNotification(title, message);
    }

    void OnScheduleClick(object sender, EventArgs e)
    {
        notificationNumber++;
        string title = $"Local Notification #{notificationNumber}";
        string message = $"You have now received {notificationNumber} notifications!";
        notificationManager.SendNotification(title, message, DateTime.Now.AddSeconds(10));
    }

    void ShowNotification(string title, string message)
    {
        Device.BeginInvokeOnMainThread(() =>
        {
            var msg = new Label()
            {
                Text = $"Notification Received:\nTitle: {title}\nMessage: {message}"
            };
            stackLayout.Children.Add(msg);
        });
    }
}

Sınıf MainPage oluşturucusu, Xamarin.FormsDependencyService platforma özgü bir örneğini almak için INotificationManager kullanır. ve OnSendClickOnScheduleClicked yöntemleri, yeni bildirimler INotificationManager göndermek ve zamanlaması için örneğini kullanır. yöntemi, olayına eklenmiş olay işleyicisi tarafından çağrılır ve olay çağrıldığında ShowNotificationNotificationReceived sayfaya yeni bir Label ekler.

Olay NotificationReceived işleyicisi, olay bağımsız değişkenlerini olarak NotificationEventArgs atlar. Bu tür paylaşılan projede Xamarin.Forms tanımlanır:

public class NotificationEventArgs : EventArgs
{
    public string Title { get; set; }
    public string Message { get; set; }
}

hakkında daha fazla bilgi için Xamarin.FormsDependencyServiceXamarin.Forms DependencyService bkz. .

Android arabirimi uygulamasını oluşturma

Uygulamanın Xamarin.Forms Android'de bildirim gönder ve al için, uygulamanın arabiriminin bir uygulamasını sağlaması INotificationManager gerekir.

AndroidNotificationManager sınıfını oluşturma

sınıfı AndroidNotificationManager arabirimini INotificationManager uygulayan:

using System;
using Android.App;
using Android.Content;
using Android.Graphics;
using Android.OS;
using AndroidX.Core.App;
using Xamarin.Forms;
using AndroidApp = Android.App.Application;

[assembly: Dependency(typeof(LocalNotifications.Droid.AndroidNotificationManager))]
namespace LocalNotifications.Droid
{
    public class AndroidNotificationManager : INotificationManager
    {
        const string channelId = "default";
        const string channelName = "Default";
        const string channelDescription = "The default channel for notifications.";

        public const string TitleKey = "title";
        public const string MessageKey = "message";

        bool channelInitialized = false;
        int messageId = 0;
        int pendingIntentId = 0;

        NotificationManager manager;

        public event EventHandler NotificationReceived;

        public static AndroidNotificationManager Instance { get; private set; }

        public AndroidNotificationManager() => Initialize();

        public void Initialize()
        {
            if (Instance == null)
            {
                CreateNotificationChannel();
                Instance = this;
            }
        }

        public void SendNotification(string title, string message, DateTime? notifyTime = null)
        {
            if (!channelInitialized)
            {
                CreateNotificationChannel();
            }

            if (notifyTime != null)
            {
                Intent intent = new Intent(AndroidApp.Context, typeof(AlarmHandler));
                intent.PutExtra(TitleKey, title);
                intent.PutExtra(MessageKey, message);

                PendingIntent pendingIntent = PendingIntent.GetBroadcast(AndroidApp.Context, pendingIntentId++, intent, PendingIntentFlags.CancelCurrent);
                long triggerTime = GetNotifyTime(notifyTime.Value);
                AlarmManager alarmManager = AndroidApp.Context.GetSystemService(Context.AlarmService) as AlarmManager;
                alarmManager.Set(AlarmType.RtcWakeup, triggerTime, pendingIntent);
            }
            else
            {
                Show(title, message);
            }
        }

        public void ReceiveNotification(string title, string message)
        {
            var args = new NotificationEventArgs()
            {
                Title = title,
                Message = message,
            };
            NotificationReceived?.Invoke(null, args);
        }

        public void Show(string title, string message)
        {
            Intent intent = new Intent(AndroidApp.Context, typeof(MainActivity));
            intent.PutExtra(TitleKey, title);
            intent.PutExtra(MessageKey, message);

            PendingIntent pendingIntent = PendingIntent.GetActivity(AndroidApp.Context, pendingIntentId++, intent, PendingIntentFlags.UpdateCurrent);

            NotificationCompat.Builder builder = new NotificationCompat.Builder(AndroidApp.Context, channelId)
                .SetContentIntent(pendingIntent)
                .SetContentTitle(title)
                .SetContentText(message)
                .SetLargeIcon(BitmapFactory.DecodeResource(AndroidApp.Context.Resources, Resource.Drawable.xamagonBlue))
                .SetSmallIcon(Resource.Drawable.xamagonBlue)
                .SetDefaults((int)NotificationDefaults.Sound | (int)NotificationDefaults.Vibrate);

            Notification notification = builder.Build();
            manager.Notify(messageId++, notification);
        }

        void CreateNotificationChannel()
        {
            manager = (NotificationManager)AndroidApp.Context.GetSystemService(AndroidApp.NotificationService);

            if (Build.VERSION.SdkInt >= BuildVersionCodes.O)
            {
                var channelNameJava = new Java.Lang.String(channelName);
                var channel = new NotificationChannel(channelId, channelNameJava, NotificationImportance.Default)
                {
                    Description = channelDescription
                };
                manager.CreateNotificationChannel(channel);
            }

            channelInitialized = true;
        }

        long GetNotifyTime(DateTime notifyTime)
        {
            DateTime utcTime = TimeZoneInfo.ConvertTimeToUtc(notifyTime);
            double epochDiff = (new DateTime(1970, 1, 1) - DateTime.MinValue).TotalSeconds;
            long utcAlarmTime = utcTime.AddSeconds(-epochDiff).Ticks / 10000;
            return utcAlarmTime; // milliseconds
        }
    }
}

Ad assembly alanının üzerindeki özniteliği, arabirim uygulamasını ile INotificationManager kaydettirmektedir. DependencyService

Android, uygulamaların bildirimler için birden çok kanal tanımlamalarını sağlar. yöntemi, Initialize örnek uygulamanın bildirim göndermek için kullandığı temel bir kanal oluşturur. yöntemi, SendNotification bildirim oluşturmak ve göndermek için gereken platforma özgü mantığı tanımlar. yöntemi, ReceiveNotification bir ileti alınca Android işletim sistemi tarafından çağrılır ve olay işleyicisini çağırır.

yöntemi SendNotification hemen veya tam olarak bir yerel bildirim DateTime oluşturur. Bir bildirim, sınıfı kullanılarak tam olarak zamanlanmış olabilir ve bildirim sınıfından DateTimeAlarmManager türetilen bir nesne tarafından BroadcastReceiver alınmıştır:

[BroadcastReceiver(Enabled = true, Label = "Local Notifications Broadcast Receiver")]
public class AlarmHandler : BroadcastReceiver
{
    public override void OnReceive(Context context, Intent intent)
    {
        if (intent?.Extras != null)
        {
            string title = intent.GetStringExtra(AndroidNotificationManager.TitleKey);
            string message = intent.GetStringExtra(AndroidNotificationManager.MessageKey);

            AndroidNotificationManager manager = AndroidNotificationManager.Instance ?? new AndroidNotificationManager();
            manager.Show(title, message);
        }
    }
}

Yayın alıcıları hakkında daha fazla bilgi için bkz. Xamarin.Android'de Yayın Alıcıları.

Android'de gelen bildirimleri işleme

sınıfının MainActivity gelen bildirimleri algılaması ve örneği bilgilendirmesi AndroidNotificationManager gerekir. sınıfındaki Activity özniteliği MainActivity bir değeri LaunchModeLaunchMode.SingleTop belirtsin:

[Activity(
        //...
        LaunchMode = LaunchMode.SingleTop]
    public class MainActivity : global::Xamarin.Forms.Platform.Android.FormsAppCompatActivity
    {
        // ...
    }

Mod, uygulama ön plandayken bir SingleTopActivity örneğinin birden çok örneğinin başlamasını ön planda sağlar. Bu, LaunchMode daha karmaşık bildirim senaryolarında birden çok etkinlik başlatan uygulamalar için uygun olabilir. Numaralama değerleri hakkında LaunchMode daha fazla bilgi için bkz. Android Activity LaunchMode.

sınıfında, MainActivity gelen bildirimleri alacak şekilde değiştirilir:

protected override void OnCreate(Bundle savedInstanceState)
{
    // ...

    global::Xamarin.Forms.Forms.Init(this, savedInstanceState);
    LoadApplication(new App());
    CreateNotificationFromIntent(Intent);
}

protected override void OnNewIntent(Intent intent)
{
    CreateNotificationFromIntent(intent);
}

void CreateNotificationFromIntent(Intent intent)
{
    if (intent?.Extras != null)
    {
        string title = intent.GetStringExtra(AndroidNotificationManager.TitleKey);
        string message = intent.GetStringExtra(AndroidNotificationManager.MessageKey);
        DependencyService.Get<INotificationManager>().ReceiveNotification(title, message);
    }
}

yöntemi, CreateNotificationFromIntent bağımsız değişkenden bildirim intent verilerini ayıklar ve yöntemini kullanarak AndroidNotificationManager yöntemine ReceiveNotification sağlar. yöntemi CreateNotificationFromIntent hem yönteminden hem de OnCreate yönteminden OnNewIntent çağrılır:

• Uygulama bildirim verileriyle başlatılana Intent kadar veriler yöntemine OnCreate geçiri.
• Uygulama zaten ön planda yer alıyorsa, Intent veriler yöntemine OnNewIntent geçirtir.

Android, bildirimler için birçok gelişmiş seçenek sunar. Daha fazla bilgi için bkz. Xamarin.Android'de Bildirimler.

iOS arabirimi uygulamasını oluşturma

Uygulamanın Xamarin.Forms iOS'ta bildirim gönder ve al için uygulamanın bir uygulaması sağlaması INotificationManager gerekir.

iOSNotificationManager sınıfını oluşturma

sınıfı iOSNotificationManager arabirimini INotificationManager uygulayan:

using System;
using Foundation;
using UserNotifications;
using Xamarin.Forms;

[assembly: Dependency(typeof(LocalNotifications.iOS.iOSNotificationManager))]
namespace LocalNotifications.iOS
{
    public class iOSNotificationManager : INotificationManager
    {
        int messageId = 0;
        bool hasNotificationsPermission;
        public event EventHandler NotificationReceived;

        public void Initialize()
        {
            // request the permission to use local notifications
            UNUserNotificationCenter.Current.RequestAuthorization(UNAuthorizationOptions.Alert, (approved, err) =>
            {
                hasNotificationsPermission = approved;
            });
        }

        public void SendNotification(string title, string message, DateTime? notifyTime = null)
        {
            // EARLY OUT: app doesn't have permissions
            if (!hasNotificationsPermission)
            {
                return;
            }

            messageId++;

            var content = new UNMutableNotificationContent()
            {
                Title = title,
                Subtitle = "",
                Body = message,
                Badge = 1
            };            

            UNNotificationTrigger trigger;
            if (notifyTime != null)
            {
                // Create a calendar-based trigger.
                trigger = UNCalendarNotificationTrigger.CreateTrigger(GetNSDateComponents(notifyTime.Value), false);
            }
            else
            {
                // Create a time-based trigger, interval is in seconds and must be greater than 0.
                trigger = UNTimeIntervalNotificationTrigger.CreateTrigger(0.25, false);
            }                      

            var request = UNNotificationRequest.FromIdentifier(messageId.ToString(), content, trigger);
            UNUserNotificationCenter.Current.AddNotificationRequest(request, (err) =>
            {
                if (err != null)
                {
                    throw new Exception($"Failed to schedule notification: {err}");
                }
            });
        }

        public void ReceiveNotification(string title, string message)
        {
            var args = new NotificationEventArgs()
            {
                Title = title,
                Message = message
            };
            NotificationReceived?.Invoke(null, args);
        }

        NSDateComponents GetNSDateComponents(DateTime dateTime)
        {
            return new NSDateComponents
            {
                Month = dateTime.Month,
                Day = dateTime.Day,
                Year = dateTime.Year,
                Hour = dateTime.Hour,
                Minute = dateTime.Minute,
                Second = dateTime.Second
            };
        }
    }
}

Ad assembly alanının üzerindeki özniteliği, arabirim uygulamasını ile INotificationManager kaydettirmektedir. DependencyService

iOS'ta, bir bildirim zamanlamayı denemeden önce bildirimleri kullanmak için izin isteğiniz gerekir. yöntemi, Initialize yerel bildirimleri kullanmak için yetkilendirme isteğinde bulundu. yöntemi, SendNotification bildirim oluşturmak ve göndermek için gereken mantığı tanımlar. Yöntemi, ReceiveNotification bir ileti alınca iOS tarafından çağrılır ve olay işleyicisini çağırır.

iOS'ta gelen bildirimleri işleme

iOS'ta, gelen iletileri işlemek için alt sınıflara sahip bir UNUserNotificationCenterDelegate temsilci oluşturmanız gerekir. Örnek uygulama bir sınıf iOSNotificationReceiver tanımlar:

public class iOSNotificationReceiver : UNUserNotificationCenterDelegate
{
    public override void WillPresentNotification(UNUserNotificationCenter center, UNNotification notification, Action<UNNotificationPresentationOptions> completionHandler)
    {
        ProcessNotification(notification);
        completionHandler(UNNotificationPresentationOptions.Alert);
    }

    void ProcessNotification(UNNotification notification)
    {
        string title = notification.Request.Content.Title;
        string message = notification.Request.Content.Body;

        DependencyService.Get<INotificationManager>().ReceiveNotification(title, message);
    }    
}

Bu sınıf, DependencyService sınıfının bir örneğini almak için kullanır ve iOSNotificationManager yöntemine gelen bildirim verilerini ReceiveNotification sağlar.

sınıf, AppDelegate uygulama başlatma sırasında bir nesneyi temsilci olarak iOSNotificationReceiverUNUserNotificationCenter belirtmektedir. Bu, yönteminde FinishedLaunching gerçekleşir:

public override bool FinishedLaunching(UIApplication app, NSDictionary options)
{
    global::Xamarin.Forms.Forms.Init();

    UNUserNotificationCenter.Current.Delegate = new iOSNotificationReceiver();

    LoadApplication(new App());
    return base.FinishedLaunching(app, options);
}

iOS, bildirimler için birçok gelişmiş seçenek sunar. Daha fazla bilgi için bkz. Xamarin.iOS'ta Bildirimler.

Uygulamayı test edin

Platform projeleri arabirimin kayıtlı bir uygulamasını INotificationManager içerdiğinde, uygulama her iki platformda da test edilebilir. Uygulamayı çalıştırın ve bildirim oluşturmak için Bildirim Oluştur düğmelerden herhangi bir'e tıklayın.

Android'de bildirimler bildirim alanında görünür. Bildirime eşlenen uygulama bildirimi alır ve bir ileti görüntüler:

iOS'ta gelen bildirimler, kullanıcı girişi gerektirmeden uygulama tarafından otomatik olarak alır. Uygulama bildirimi alır ve bir ileti görüntüler:

İlgili bağlantılar

• Örnek proje
• Xamarin.Android'de Bildirimler
• Xamarin.Android'de Alıcıları Yayınlama
• Xamarin.iOS'ta Bildirimler
• Xamarin.Forms DependencyService