How To Send Local Notification With A Repeat Interval (Day/Minute/Hour etc.)

Introduction

In this article, we will learn how to send Local Notifications for a particular date and time at a repeated interval (Day/Minute/Hour etc.,) using the DependencyService concept in Xamarin.Forms.

Requirements

• This article's source code is prepared by using Visual Studio. It is better to install the latest Visual Studio updates from here.
• This article is prepared on a MAC machine.
• This sample project is in Xamarin.Forms of PCL project.
• This sample app is targeted for Android, iOS. And tested for Android & iOS.

Description

Let's start.

Step 1

First, follow the below steps to create the new Xamarin.Forms project.

1. Open Visual Studio for Mac.
2. Click on the File menu and select New Solution.
3. In the left pane of the dialog, let's select the type of templates to display. Multiplatform > App > Xamarin.Forms > Blank Forms App and click "Next".
4. Next, enter your app name (Ex: LocalNotificationDemo). At the bottom, select target platforms to Android & iOS and shared code to Portable Class Library and click the "Next" button.
5. Then, choose project location with the help of Browse button and click "Create".

Now, the project structure will be created like below.

• LocalNotificationDemo
  It is for Shared Code

• LocalNotificationDemo.Droid
  It is for Android.
  
  
• LocalNotificationDemo.iOS
  It is for iOS.

Step 2

Local notifications will helpful to send application-related data at some time through notifications.

In this article we will do the below steps for getting local notification with repeat at an interval.

• Taking Switch for notifications on or off.
• Taking TimePicker and DatePicker for scheduling local notification.
• Converting TimePicker selected time, DatePicker selectedDate to DateTime type and passing datetime to DependencyService.
• Taking Editor and passing editor text as a notification message.
• Save button. In this, we are checking if notification is on or off. If notification switch is on then we call Dependency Service to schedule notification.
• In Platform specific, we are scheduling notification and giving repeat interval time like Day/Minute/Hour etc,.

Portable class library(PCL)

Views

Create your own XAML page named LocalNotificationPage.xaml inside the Views folder. And here, we are taking inputs from users like notification On/Off, date, time and message text.

LocalNotificationPage.xaml

Save this link to your bookmarks to access the best free online web developer tools and use them every day: html-css-js.com.

<?xml version="1.0" encoding="UTF-8"?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
    x:Class="LocalNotificationDemo.Views.LocalNotificationPage"
    Title="Local Notification"
    BackgroundColor="#533F95">
    <ContentPage.Content>
        <Grid VerticalOptions="FillAndExpand" Padding="25,40,25,30" RowSpacing="20">
            <Grid.RowDefinitions>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
            </Grid.RowDefinitions>
            <Grid Grid.Row="0">
                <StackLayout HorizontalOptions="FillAndExpand" Orientation="Horizontal">
                    <Label Text="Notifications ON/OFF" TextColor="White" FontSize="16" HorizontalOptions="StartAndExpand" VerticalOptions="Center"/>
                    <Switch IsToggled=" {Binding NotificationONOFF}" HorizontalOptions="EndAndExpand" VerticalOptions="Center"/>
                </StackLayout>
            </Grid>
            <Grid Grid.Row="1">
                <StackLayout HorizontalOptions="FillAndExpand" Orientation="Horizontal">
                <Label Text="SET TIME" HorizontalOptions="StartAndExpand" FontSize="15" TextColor="White" VerticalOptions="Center"/>
                <TimePicker HorizontalOptions="EndAndExpand" Time=" {Binding SelectedTime}" TextColor="White" BackgroundColor="Transparent" Format="t"/>
                </StackLayout>
            </Grid>
            <Grid Grid.Row="2">
                 <StackLayout HorizontalOptions="FillAndExpand" Orientation="Horizontal">
                <Label Text="SET DATE" TextColor="White" FontSize="15" VerticalOptions="Center" HorizontalOptions="StartAndExpand"/>
                 <DatePicker HorizontalOptions="EndAndExpand" Date=" {Binding SelectedDate}" TextColor="White"  BackgroundColor="Transparent" Format="MM-dd-yyyy"/>
                </StackLayout>
            </Grid>
            <Grid Grid.Row="3">
                <StackLayout HorizontalOptions="FillAndExpand" Spacing="10">
                 <Label Text="Enter Message" FontSize="15" HorizontalOptions="StartAndExpand" TextColor="White" VerticalOptions="Center"/>
                 <Editor HeightRequest="120" Text=" {Binding MessageText}" TextColor="Purple" BackgroundColor="White" HorizontalOptions="FillAndExpand"/>
                </StackLayout>
            </Grid>
            <Grid Grid.Row="4">
                <Button Text="Save" Command="{Binding SaveCommand}" FontSize="15" TextColor="White" BackgroundColor="Purple"  HorizontalOptions="FillAndExpand" BorderRadius="15"/>
            </Grid>
        </Grid>
    </ContentPage.Content>
</ContentPage>

LocalNotificationPage.xaml.cs

Make BindingContext in code behind with LocalNotificationPageViewModel.

using LocalNotifcationDemo.ViewModels;
using Xamarin.Forms;
namespace LocalNotifcationDemo.Views {
    public partial class LocalNotificationPage: ContentPage {
        public LocalNotificationPage() {
            InitializeComponent();
            BindingContext = new LocalNotificationPageViewModel();
        }
    }
}

ViewModels

LocalNotificationPageViewModel.cs

In this ViewModel, we are calling DependencyService and passing the selected date, time and message text to the service.

Properties

• NotificationONOFF
• SelectedDate
• SelectedTime
• MessageText

Commands

• SaveCommand  

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Runtime.CompilerServices;
using LocalNotificationDemo.DependencyServices;
using Xamarin.Forms;
namespace LocalNotificationDemo.ViewModels {
    public class LocalNotificationPageViewModel: INotifyPropertyChanged {
        Command _saveCommand;
        public Command SaveCommand {
            get {
                return _saveCommand;
            }
            set {
                SetProperty(ref _saveCommand, value);
            }
        }
        bool _notificationONOFF;
        public bool NotificationONOFF {
            get {
                return _notificationONOFF;
            }
            set {
                SetProperty(ref _notificationONOFF, value);
                Switch_Toggled();
            }
        }
        void Switch_Toggled() {
            if (NotificationONOFF == false) {
                MessageText = string.Empty;
                SelectedTime = DateTime.Now.TimeOfDay;
                SelectedDate = DateTime.Today;
                DependencyService.Get<ILocalNotificationService>().Cancel(0);
            }
        }
        DateTime _selectedDate = DateTime.Today;
        public DateTime SelectedDate {
            get {
                return _selectedDate;
            }
            set {
                SetProperty(ref _selectedDate, value);
            }
        }
        TimeSpan _selectedTime = DateTime.Now.TimeOfDay;
        public TimeSpan SelectedTime {
            get {
                return _selectedTime;
            }
            set {
                SetProperty(ref _selectedTime, value);
            }
        }
        string _messageText;
        public string MessageText {
            get {
                return _messageText;
            }
            set {
                SetProperty(ref _messageText, value);
            }
        }
        public LocalNotificationPageViewModel() {
            SaveCommand = new Command(() => SaveLocalNotification());
        }
        void SaveLocalNotification() {
            if (NotificationONOFF == true) {
                var date = (SelectedDate.Date.Month.ToString("00") + "-" + SelectedDate.Date.Day.ToString("00") + "-" + SelectedDate.Date.Year.ToString());
                var time = Convert.ToDateTime(SelectedTime.ToString()).ToString("HH:mm");
                var dateTime = date + " " + time;
                var selectedDateTime = DateTime.ParseExact(dateTime, "MM-dd-yyyy HH:mm", CultureInfo.InvariantCulture);
                if (!string.IsNullOrEmpty(MessageText)) {
                    DependencyService.Get<ILocalNotificationService>().Cancel(0);
    DependencyService.Get<ILocalNotificationService().LocalNotification("Local Notification", MessageText, 0, selectedDateTime);
                    App.Current.MainPage.DisplayAlert("LocalNotificationDemo", "Notification details saved successfully ", "Ok");
                } else {
                    App.Current.MainPage.DisplayAlert("LocalNotificationDemo", "Please enter meassage", "OK");
                }
            } else {
                App.Current.MainPage.DisplayAlert("LocalNotificationDemo", "Please switch on notification", "OK");
            }
        }
        protected bool SetProperty<T> (ref T backingStore, T value, [CallerMemberName] string propertyName = "", Action onChanged = null) {
            if (EqualityComparer<T>.Default.Equals(backingStore, value))
                 return false;
            backingStore = value;
            onChanged?.Invoke();
            OnPropertyChanged(propertyName);
            return true;
        }
        public event PropertyChangedEventHandler PropertyChanged;
        protected void OnPropertyChanged([CallerMemberName] string propertyName = "") {
            var changed = PropertyChanged;
            if (changed == null)
                 return;
            changed.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}

Step 3

 

Portable class library (PCL)

Create an interface ILocalNotificationService inside the DependencyServices folder that has the methods declaration of LocalNotification and Cancel.

ILocalNotificationService.cs

using System;

namespace LocalNotificationDemo.DependencyServices
{
    public interface ILocalNotificationService
    {
        void LocalNotification(string title, string body, int id, DateTime notifyTime);
        void Cancel(int id);
    }
}

Models

In models, we need to create the below class with Title, Body, ID, IconId and NotifyTime. It will be useful to pass a local notification data to BroadcastReceiver receiver for repeating in Android.

LocalNotification.cs

using System;
namespace LocalNotificationDemo.Models{

    public class LocalNotification{

        public string Title { get; set; }

        public string Body { get; set; }

        public int Id { get; set; }

        public int IconId { get; set; }

        public DateTime NotifyTime { get; set; }
    }
}

Step 4

Xamarin.Android

Create a class LocalNotificationService and we need to implement LocalNotification and Cancel methods like below. In this, we have created BroadcastReceiver for repeating notification.

LocalNotificationService.cs

using System;
using System.IO;
using System.Xml.Serialization;
using Android.App;
using Android.Content;
using Android.Media;
using Android.Support.V4.App;
using Java.Lang;
using LocalNotificationDemo.DependencyServices.Droid;
using LocalNotificationDemo.Droid;
using LocalNotificationDemo.Models;

[assembly: Xamarin.Forms.Dependency(typeof(LocalNotificationService))]

namespace LocalNotificationDemo.DependencyServices.Droid{

    public class LocalNotificationService : ILocalNotificationService
    {
        int _notificationIconId { get; set; }
        readonly DateTime _jan1st1970 = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
        internal string _randomNumber;

        public void LocalNotification(string title, string body, int id, DateTime notifyTime){

            //long repeateDay = 1000 * 60 * 60 * 24;
            long repeateForMinute = 60000; // In milliseconds
            long totalMilliSeconds = (long)(notifyTime.ToUniversalTime() - _jan1st1970).TotalMilliseconds;
            if (totalMilliSeconds < JavaSystem.CurrentTimeMillis()){
                totalMilliSeconds = totalMilliSeconds + repeateForMinute;
            }

            var intent = CreateIntent(id);
            var localNotification = new LocalNotification();
            localNotification.Title = title;
            localNotification.Body = body;
            localNotification.Id = id;
            localNotification.NotifyTime = notifyTime;

            if (_notificationIconId != 0){
                localNotification.IconId = _notificationIconId;
            }
            else{
                localNotification.IconId = Resource.Drawable.notificationgrey;
            }

            var serializedNotification = SerializeNotification(localNotification);
            intent.PutExtra(ScheduledAlarmHandler.LocalNotificationKey, serializedNotification);

            Random generator = new Random();
            _randomNumber = generator.Next(100000, 999999).ToString("D6");

            var pendingIntent = PendingIntent.GetBroadcast(Application.Context, Convert.ToInt32(_randomNumber), intent, PendingIntentFlags.Immutable);
            var alarmManager = GetAlarmManager();
            alarmManager.SetRepeating(AlarmType.RtcWakeup, totalMilliSeconds, repeateForMinute, pendingIntent);
        }

        public void Cancel(int id){

            var intent = CreateIntent(id);
            var pendingIntent = PendingIntent.GetBroadcast(Application.Context, Convert.ToInt32(_randomNumber), intent, PendingIntentFlags.Immutable);
            var alarmManager = GetAlarmManager();
            alarmManager.Cancel(pendingIntent);
            var notificationManager = NotificationManagerCompat.From(Application.Context);
            notificationManager.CancelAll();
            notificationManager.Cancel(id);
        }

        public static Intent GetLauncherActivity(){

            var packageName = Application.Context.PackageName;
            return Application.Context.PackageManager.GetLaunchIntentForPackage(packageName);
        }


        private Intent CreateIntent(int id){

            return new Intent(Application.Context, typeof(ScheduledAlarmHandler))
                .SetAction("LocalNotifierIntent" + id);
        }

        private AlarmManager GetAlarmManager(){

            var alarmManager = Application.Context.GetSystemService(Context.AlarmService) as AlarmManager;
            return alarmManager;
        }

        private string SerializeNotification(LocalNotification notification){

            var xmlSerializer = new XmlSerializer(notification.GetType());

            using (var stringWriter = new StringWriter()){
                xmlSerializer.Serialize(stringWriter, notification);
                return stringWriter.ToString();
            }
        }
    }

    [BroadcastReceiver(Enabled = true, Label = "Local Notifications Broadcast Receiver")]
    public class ScheduledAlarmHandler : BroadcastReceiver{

        public const string LocalNotificationKey = "LocalNotification";

        public override void OnReceive(Context context, Intent intent){
            var extra = intent.GetStringExtra(LocalNotificationKey);
            var notification = DeserializeNotification(extra);
            //Generating notification
            var builder = new NotificationCompat.Builder(Application.Context)
                .SetContentTitle(notification.Title)
                .SetContentText(notification.Body)
                .SetSmallIcon(notification.IconId)
                .SetSound(RingtoneManager.GetDefaultUri(RingtoneType.Ringtone))
                .SetAutoCancel(true);

            var resultIntent = LocalNotificationService.GetLauncherActivity();
            resultIntent.SetFlags(ActivityFlags.NewTask | ActivityFlags.ClearTask);
            var stackBuilder = Android.Support.V4.App.TaskStackBuilder.Create(Application.Context);
            stackBuilder.AddNextIntent(resultIntent);

            Random random = new Random();
            int randomNumber = random.Next(9999 - 1000) + 1000;

            var resultPendingIntent =
                stackBuilder.GetPendingIntent(randomNumber, (int)PendingIntentFlags.Immutable);
            builder.SetContentIntent(resultPendingIntent);
            // Sending notification
            var notificationManager = NotificationManagerCompat.From(Application.Context);
            notificationManager.Notify(randomNumber, builder.Build());
        }

        private LocalNotification DeserializeNotification(string notificationString){

            var xmlSerializer = new XmlSerializer(typeof(LocalNotification));
            using (var stringReader = new StringReader(notificationString))
            {
                var notification = (LocalNotification)xmlSerializer.Deserialize(stringReader);
                return notification;
            }
        }
    }
}

Note

In Android, we are using AlarmManger for repeating location notifications.

Step 5

Xamarin.iOS

Now, create a class LocalNotificationService and implement LocalNotification and cancel the method like below.

LocalNotificationService.cs

using System;
using UIKit;
using Foundation;
using System.Linq;
using Xamarin.Forms;
using LocalNotificationDemo.iOS;
using LocalNotificationDemo.DependencyServices;

[assembly: Dependency(typeof(LocalNotificationService))]
namespace LocalNotificationDemo.iOS{

    public class LocalNotificationService : ILocalNotificationService{

        const string NotificationKey = "LocalNotificationKey";

        public void LocalNotification(string title, string body, int id, DateTime notifyTime){

            var notification = new UILocalNotification{

                AlertTitle = title,
                AlertBody = body,
                SoundName = UILocalNotification.DefaultSoundName,
                FireDate = notifyTime.ToNSDate(),
                RepeatInterval = NSCalendarUnit.Minute,

                UserInfo = NSDictionary.FromObjectAndKey(NSObject.FromObject(id), NSObject.FromObject(NotificationKey))
            };
            UIApplication.SharedApplication.ScheduleLocalNotification(notification);
        }

        public void Cancel(int id){

            var notifications = UIApplication.SharedApplication.ScheduledLocalNotifications;
            var notification = notifications.Where(n => n.UserInfo.ContainsKey(NSObject.FromObject(NotificationKey)))
                .FirstOrDefault(n => n.UserInfo[NotificationKey].Equals(NSObject.FromObject(id)));
            UIApplication.SharedApplication.CancelAllLocalNotifications();
            if (notification != null){
                UIApplication.SharedApplication.CancelLocalNotification(notification);
                UIApplication.SharedApplication.CancelAllLocalNotifications();
            }
        }
    }

    public static class DateTimeExtensions{

        static DateTime nsUtcRef = new DateTime(2001, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
        // last zero is milliseconds

        public static double SecondsSinceNSRefenceDate(this DateTime dt){
            return (dt.ToUniversalTime() - nsUtcRef).TotalSeconds;
        }

        public static NSDate ToNSDate(this DateTime dt){
            return NSDate.FromTimeIntervalSinceReferenceDate(dt.SecondsSinceNSRefenceDate());
        }
    }
}

Note

In iOS, UILocationNotification is having RepeatIntervel property. It will be useful to repeat the notification by Day/Minute.

AppDelegate.cs

In AppDelegate.cs, first, add the following code to the FinishedLaunching method. We have checked to see if the device is running iOS 8. If so, we are required to ask for the user's permission to receive notifications.

// We have checked to see if the device is running iOS 8, if so we are required to ask for the user's permission to receive notifications
            if (UIDevice.CurrentDevice.CheckSystemVersion(8, 0)){
                var notificationSettings = UIUserNotificationSettings.GetSettingsForTypes(
                    UIUserNotificationType.Alert | UIUserNotificationType.Badge | UIUserNotificationType.Sound, null
                );

                app.RegisterUserNotificationSettings(notificationSettings);
            }

Still, in AppDelegate.cs, add the following method which will be called when a notification is received.

public override void ReceivedLocalNotification(UIApplication application, UILocalNotification notification){

            UIAlertController okayAlertController = UIAlertController.Create(notification.AlertAction, notification.AlertBody, UIAlertControllerStyle.Alert);
            okayAlertController.AddAction(UIAlertAction.Create("OK", UIAlertActionStyle.Default, null));
            UIApplication.SharedApplication.ApplicationIconBadgeNumber = 0;
        }

We need to handle the case where the notification was launched because of a local notification. Edit the method FinishedLaunching in the AppDelegate to include the following snippet of code.

// check for a notification
            if (options != null){
                if (options.ContainsKey(UIApplication.LaunchOptionsLocalNotificationKey)){
                    UILocalNotification localNotification = options[UIApplication.LaunchOptionsLocalNotificationKey] as UILocalNotification;
                    if (localNotification != null){
                        new UIAlertView(localNotification.AlertAction, localNotification.AlertBody, null, "OK", null).Show();
                        // reset our badge
                        UIApplication.SharedApplication.ApplicationIconBadgeNumber = 0;
                    }
           }
}

 On iOS 8 we will be prompted to allow notifications like below.

 

Output

Please download the source code from here.