private void ScheduleCallbackAlarm(ScheduledCallback callback, PendingIntent callbackPendingIntent)
{
AlarmManager alarmManager = _service.GetSystemService(global::Android.Content.Context.AlarmService) as AlarmManager;
// cancel the current alarm for this callback id. this deals with the situations where (1) sensus schedules callbacks
// and is subsequently restarted, or (2) a probe is restarted after scheduling callbacks (e.g., script runner). in
// these situations, the originally scheduled callbacks will remain in the alarm manager, and we'll begin piling up
// additional, duplicate alarms. we need to be careful to avoid duplicate alarms, and this is how we manage it.
alarmManager.Cancel(callbackPendingIntent);
long callbackTimeMS = callback.NextExecution.Value.ToJavaCurrentTimeMillis();
// see the Backwards Compatibility article for more information
#if __ANDROID_23__
if (Build.VERSION.SdkInt >= BuildVersionCodes.M)
{
alarmManager.SetExactAndAllowWhileIdle(AlarmType.RtcWakeup, callbackTimeMS, callbackPendingIntent); // API level 23 added "while idle" option, making things even tighter.
}
else if (Build.VERSION.SdkInt >= BuildVersionCodes.Kitkat)
{
alarmManager.SetExact(AlarmType.RtcWakeup, callbackTimeMS, callbackPendingIntent); // API level 19 differentiated Set (loose) from SetExact (tight)
}
else
#endif
{
alarmManager.Set(AlarmType.RtcWakeup, callbackTimeMS, callbackPendingIntent); // API 1-18 treats Set as a tight alarm
}
SensusServiceHelper.Get().Logger.Log("Alarm scheduled for callback " + callback.Id + " at " + callback.NextExecution.Value + ".", LoggingLevel.Normal, GetType());
}
static public void AddAlarmEvent(int seconds = 60)
{
DateTime alarmtime = DateTime.Now.AddSeconds(seconds);
Intent alarmIntent = new Intent(Android.App.Application.Context, typeof(AlarmReceiver));
PendingIntent pendingIntent = PendingIntent.GetBroadcast(Android.App.Application.Context, AlarmId++, alarmIntent, PendingIntentFlags.UpdateCurrent);
AlarmManager alarmManager = (AlarmManager)Android.App.Application.Context.GetSystemService(Context.AlarmService);
Java.Util.Calendar calendar = Java.Util.Calendar.Instance;
calendar.TimeInMillis = Java.Lang.JavaSystem.CurrentTimeMillis();
calendar.Set(alarmtime.Year, alarmtime.Month - 1, alarmtime.Day, alarmtime.Hour, alarmtime.Minute, alarmtime.Second);
if (Build.VERSION.SdkInt < Android.OS.BuildVersionCodes.M)
{
if (Build.VERSION.SdkInt >= Android.OS.BuildVersionCodes.Kitkat)
{
//API 19 이상 API 23미만
alarmManager.SetExact(AlarmType.RtcWakeup, calendar.TimeInMillis, pendingIntent);
}
else
{
//API 19미만
alarmManager.Set(AlarmType.RtcWakeup, calendar.TimeInMillis, pendingIntent);
}
}
else
{
//API 23 이상
alarmManager.SetExactAndAllowWhileIdle(AlarmType.RtcWakeup, calendar.TimeInMillis, pendingIntent);
}
}
public void SetAlarm(Context Activity, long miliseconds, PendingIntent pendingIntent)
{
AlarmManager alarmManager = (AlarmManager)Activity.GetSystemService(Context.AlarmService);
//Intent intent = new Intent(Activity, typeof(AlarmReceiver));
//intent.PutExtra("repeat", true);
//PendingIntent pendingIntent = PendingIntent.GetBroadcast(Activity, /*id de la alarma que sea unico */0, intent, PendingIntentFlags.CancelCurrent);
//alarmManager.SetInexactRepeating(AlarmType.RtcWakeup, miliseconds, AlarmManager.IntervalDay, pendingIntent);
//API19 NOt work https://stackoverflow.com/questions/27806336/alarmmanager-setinexactrepeating-not-working-in-android-4-1-2-works-on-android
if (Build.VERSION.SdkInt < BuildVersionCodes.Kitkat)
{
alarmManager.Set(AlarmType.RtcWakeup, miliseconds, pendingIntent);
}
else if (BuildVersionCodes.Kitkat <= Build.VERSION.SdkInt && Build.VERSION.SdkInt < BuildVersionCodes.M)
{
alarmManager.SetExact(AlarmType.RtcWakeup, miliseconds, pendingIntent);
}
else if (Build.VERSION.SdkInt >= BuildVersionCodes.M)
{
alarmManager.SetExactAndAllowWhileIdle(AlarmType.RtcWakeup, miliseconds, pendingIntent);
}
}
public void ScheduleCallbackAlarm(PendingIntent callbackPendingIntent, string callbackId, DateTime callbackTime)
{
lock (_callbackIdPendingIntent)
{
// update pending intent associated with the callback id. we'll need the updated pending intent if/when
// we which to unschedule the alarm.
_callbackIdPendingIntent[callbackId] = callbackPendingIntent;
AlarmManager alarmManager = _service.GetSystemService(global::Android.Content.Context.AlarmService) as AlarmManager;
long delayMS = (long)(callbackTime - DateTime.Now).TotalMilliseconds;
long callbackTimeMS = Java.Lang.JavaSystem.CurrentTimeMillis() + delayMS;
// https://github.com/predictive-technology-laboratory/sensus/wiki/Backwards-Compatibility
#if __ANDROID_23__
if (Build.VERSION.SdkInt >= BuildVersionCodes.M)
{
alarmManager.SetExactAndAllowWhileIdle(AlarmType.RtcWakeup, callbackTimeMS, callbackPendingIntent); // API level 23 added "while idle" option, making things even tighter.
}
else if (Build.VERSION.SdkInt >= BuildVersionCodes.Kitkat)
{
alarmManager.SetExact(AlarmType.RtcWakeup, callbackTimeMS, callbackPendingIntent); // API level 19 differentiated Set (loose) from SetExact (tight)
}
else
#endif
{
alarmManager.Set(AlarmType.RtcWakeup, callbackTimeMS, callbackPendingIntent); // API 1-18 treats Set as a tight alarm
}
}
}
private async Task SetAlarm(String name, String dosage, Notification notification, int id, NotificationOccurrence notificationOccurrence, Intent notificationIntent)
{
var firingCal = Java.Util.Calendar.Instance;
firingCal.Set(CalendarField.Year, notificationOccurrence.OccurrenceDateTime.Year);
firingCal.Set(CalendarField.Month, notificationOccurrence.OccurrenceDateTime.Month - 1);
firingCal.Set(CalendarField.DayOfMonth, notificationOccurrence.OccurrenceDateTime.Day);
firingCal.Set(CalendarField.HourOfDay, notificationOccurrence.OccurrenceDateTime.Hour);
firingCal.Set(CalendarField.Minute, notificationOccurrence.OccurrenceDateTime.Minute);
firingCal.Set(CalendarField.Second, notificationOccurrence.OccurrenceDateTime.Second);
var triggerTime = firingCal.TimeInMillis;
// for test purposes only
var dateFormat = new SimpleDateFormat("dd:MM:yy:HH:mm:ss");
var cal = dateFormat.Format(triggerTime);
notificationIntent.PutExtra(NotificationPublisher.NOTIFICATION_ID, notificationOccurrence.Id.Value);
notificationIntent.PutExtra(NotificationPublisher.MEDICATION_ID, id);
notificationIntent.PutExtra(NotificationPublisher.NOTIFICATION, notification);
notificationIntent.PutExtra(NotificationPublisher.NOTIFICATION_FIRE_TIME, triggerTime);
var requestId = notificationOccurrence.Id.Value;
PendingIntent pendingIntent = PendingIntent.GetBroadcast(this.ctx, requestId, notificationIntent, PendingIntentFlags.CancelCurrent);
AlarmManager alarmManager = (AlarmManager)this.ctx.GetSystemService(Context.AlarmService);
alarmManager.SetExactAndAllowWhileIdle(AlarmType.RtcWakeup, triggerTime, pendingIntent);
}
public void SetAlarmForNextReminder(Context context)
{
long?nextReminderMillisTimestamp = GetNextReminderMillisTimestamp();
if (nextReminderMillisTimestamp.HasValue && nextReminderMillisTimestamp.Value > 0)
{
// Alarm is started 5 seconds after notification time
// So, we have a better guarantee that it will be notified
long delay = 1000 * 5;
Intent reminderAlarmReceiver = new Intent(context, Java.Lang.Class.FromType(typeof(ReminderAlarmReceiver)));
PendingIntent pendingIntent = PendingIntent.GetBroadcast(context, 0, reminderAlarmReceiver, PendingIntentFlags.UpdateCurrent);
long triggerAtMillis = nextReminderMillisTimestamp.Value + delay;
AlarmManager alarmManager = context.GetSystemService(Context.AlarmService) as AlarmManager;
if (alarmManager != null)
{
// Method SetExactAndAllowWhileIdle() is for Doze mode, introduced in Android 6.0
if (Build.VERSION.SdkInt >= BuildVersionCodes.M)
{
alarmManager.SetExactAndAllowWhileIdle(AlarmType.RtcWakeup, triggerAtMillis, pendingIntent);
}
else
{
alarmManager.SetExact(AlarmType.RtcWakeup, triggerAtMillis, pendingIntent);
}
}
}
}
public void ScheduleTask(TimeSpan timeSpan, PendingIntent pendingIntent)
{
var triggerAtMillis = Java.Lang.JavaSystem.CurrentTimeMillis() + (long)timeSpan.TotalMilliseconds;
alarmManager.Cancel(pendingIntent);
alarmManager.SetExactAndAllowWhileIdle(AlarmType.RtcWakeup, triggerAtMillis, pendingIntent);
}
private void ScheduleCallbackAlarm(PendingIntent callbackPendingIntent, TimeSpan delay)
{
AlarmManager alarmManager = _service.GetSystemService(global::Android.Content.Context.AlarmService) as AlarmManager;
// cancel the current alarm for this callback id. this deals with the situations where (1) sensus schedules callbacks
// and is subsequently restarted, or (2) a probe is restarted after scheduling callbacks (e.g., script runner). in
// these situations, the originally scheduled callbacks will remain in the alarm manager, and we'll begin piling up
// additional, duplicate alarms. we need to be careful to avoid duplicate alarms, and this is how we manage it.
alarmManager.Cancel(callbackPendingIntent);
long callbackTimeMS = Java.Lang.JavaSystem.CurrentTimeMillis() + (long)delay.TotalMilliseconds;
// https://github.com/predictive-technology-laboratory/sensus/wiki/Backwards-Compatibility
#if __ANDROID_23__
if (Build.VERSION.SdkInt >= BuildVersionCodes.M)
{
alarmManager.SetExactAndAllowWhileIdle(AlarmType.RtcWakeup, callbackTimeMS, callbackPendingIntent); // API level 23 added "while idle" option, making things even tighter.
}
else if (Build.VERSION.SdkInt >= BuildVersionCodes.Kitkat)
{
alarmManager.SetExact(AlarmType.RtcWakeup, callbackTimeMS, callbackPendingIntent); // API level 19 differentiated Set (loose) from SetExact (tight)
}
else
#endif
{
alarmManager.Set(AlarmType.RtcWakeup, callbackTimeMS, callbackPendingIntent); // API 1-18 treats Set as a tight alarm
}
}
/// <summary>
/// Schedules an alarm.
/// </summary>
/// <param name="alarm">The alarm to be scheduled.</param>
public int ScheduleAlarm(Alarm alarm)
{
var scheduleTime = GetNextAlarmTime(alarm.Hour, alarm.Minute);
var utcTime = TimeZoneInfo.ConvertTimeToUtc(scheduleTime);
var epochDif = (new DateTime(1970, 1, 1) - DateTime.MinValue).TotalSeconds;
var notifyTimeInInMilliseconds = utcTime.AddSeconds(-epochDif).Ticks / 10000;
var intent = new Intent(context, typeof(AlarmIntentService));
intent.PutExtra("id", alarm.Id);
intent.PutExtra("year", alarm.Year);
intent.PutExtra("month", alarm.Month);
intent.PutExtra("day", alarm.Day);
intent.PutExtra("hour", alarm.Hour);
intent.PutExtra("minute", alarm.Minute);
intent.PutExtra("difficulty", alarm.Difficulty);
Android.Util.Log.Verbose("notifyFilter", $"register {alarm.Id}"); // adb logcat -s notifyFilter
PendingIntent pendingIntent;
if (Android.OS.Build.VERSION.SdkInt >= Android.OS.BuildVersionCodes.O)
{
pendingIntent = PendingIntent.GetForegroundService(context, alarm.Id, intent, PendingIntentFlags.UpdateCurrent);
}
else
{
pendingIntent = PendingIntent.GetService(context, alarm.Id, intent, PendingIntentFlags.UpdateCurrent);
}
// Set inexact repeating
alarmManager.SetExactAndAllowWhileIdle(AlarmType.RtcWakeup, notifyTimeInInMilliseconds, pendingIntent);
//alarmManager.SetRepeating(AlarmType.RtcWakeup, notifyTimeInInMilliseconds, AlarmManager.IntervalDay, pendingIntent);
return(alarm.Id);
}
//set our alarm with a datetime object
private void setAlarm(DateTime calendar)
{
// set my alarm (repeating function taken out)
Intent intent = new Intent(this, typeof(AlarmReceiver));
// add information to pending intent !!!
DateTime tmp = calendar;
tmp.AddMinutes(2.0);
intent.PutExtra(Intent.ExtraText, tmp.ToLongTimeString());
PendingIntent pendingIntent = PendingIntent.GetBroadcast(this, 14532, intent, 0);
AlarmManager alarmManager = (AlarmManager)GetSystemService(Context.AlarmService);
DateTime dtBasis = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
alarmManager.SetExactAndAllowWhileIdle(AlarmType.RtcWakeup, (long)(calendar.ToUniversalTime().Subtract(dtBasis).TotalMilliseconds), pendingIntent);
}
private void ScheduleNotification(Int64 whenDisplayNotificationInUtcUnixTime, String title,
String message, Int32 scheduleId, DateTime lessonDate, Int32 requestCode)
{
Int64 currentUtcUnixTime = GetDateTimeInUtcUnixTime(DateTime.UtcNow);
if (whenDisplayNotificationInUtcUnixTime <= currentUtcUnixTime)
{
return;
}
AlarmManager alarmManager = _context.GetSystemService(Context.AlarmService)
as AlarmManager;
Intent intent = new Intent(_context, typeof(LessonsRemindPublisher));
intent.PutExtra(
LessonsRemindPublisher.IntentNotificationScheduleIdKey,
scheduleId.ToString()
);
intent.PutExtra(
LessonsRemindPublisher.IntentNotificationLessonDateKey,
lessonDate.Ticks.ToString()
);
intent.PutExtra(LessonsRemindPublisher.IntentNotificationTitleKey, title);
intent.PutExtra(LessonsRemindPublisher.IntentNotificationMessageKey, message);
PendingIntent pendingIntent = PendingIntent.GetBroadcast(
_context,
requestCode,
intent,
PendingIntentFlags.UpdateCurrent
);
Int64 timeInMilliseconds = whenDisplayNotificationInUtcUnixTime * 1000;
if (Build.VERSION.SdkInt < BuildVersionCodes.M)
{
alarmManager.SetExact(AlarmType.RtcWakeup, timeInMilliseconds, pendingIntent);
}
else
{
alarmManager.SetExactAndAllowWhileIdle(AlarmType.RtcWakeup, timeInMilliseconds, pendingIntent);
}
}
public override void OnReceive(Context context, Intent intent)
{
//Toast.MakeText(context, "Received intent!", ToastLength.Short).Show();
AndroidRefreshes.Alarm = DateTime.Now;
// Launch BirdieLib ControlLoop in script mode. --Kris
try
{
Shared.BirdieLib.Start();
}
catch (Exception) { }
// Repeat in ~15 minutes. --Kris
PendingIntent pendingIntent = PendingIntent.GetBroadcast(context, 0, intent, PendingIntentFlags.UpdateCurrent);
AlarmManager alarmManager = (AlarmManager)Application.Context.GetSystemService(Context.AlarmService);
alarmManager.SetExactAndAllowWhileIdle(AlarmType.ElapsedRealtimeWakeup, SystemClock.ElapsedRealtime() + (15 * 1000 * 60), pendingIntent);
}
public override Result DoWork()
{
try
{
AndroidRefreshes.Worker = DateTime.Now;
// If the alarm is not yet active or hasn't refreshed in awhile, attempt to recreate it, then wait for it to fire. --Kris
if (!AlarmActive || !AlarmSet)
{
// Set the alarm. --Kris
PendingIntent pendingIntent = PendingIntent.GetBroadcast(Application.Context, 0, AlarmIntent, PendingIntentFlags.UpdateCurrent);
AlarmManager alarmManager = (AlarmManager)Application.Context.GetSystemService(Context.AlarmService);
alarmManager.SetExactAndAllowWhileIdle(AlarmType.ElapsedRealtimeWakeup, SystemClock.ElapsedRealtime() + 5000, pendingIntent);
// Wait for the alarm intent to execute. --Kris
DateTime start = DateTime.Now;
while (!AlarmActive &&
start.AddSeconds(30) > DateTime.Now)
{
Thread.Sleep(5000);
}
// If the alarm still hasn't refreshed, fire the script from here, instead. --Kris
if (!AlarmActive)
{
Shared.BirdieLib.Start();
}
}
// Otherwise, refresh data from the Birdie API for display purposes. --Kris
else
{
Shared.BirdieLib.InvokeStatsUpdate();
}
}
catch (Exception) { }
return(Result.InvokeSuccess());
}
public void ScheduleAlarm(Alarm alarm)
{
long millis = Android.OS.SystemClock.ElapsedRealtime() + 1000;
PendingIntent pendingIntent = CreatePendingIntent(Forms.Context, alarm);
AlarmManager alarmManager = (AlarmManager)Forms.Context.GetSystemService(Context.AlarmService);
if (Android.OS.Build.VERSION.SdkInt >= Android.OS.BuildVersionCodes.M)
{
alarmManager.SetExactAndAllowWhileIdle(AlarmType.ElapsedRealtimeWakeup, millis, pendingIntent);
}
else if (Android.OS.Build.VERSION.SdkInt >= Android.OS.BuildVersionCodes.Kitkat)
{
alarmManager.SetExact(AlarmType.ElapsedRealtimeWakeup, millis, pendingIntent);
}
else
{
alarmManager.Set(AlarmType.ElapsedRealtimeWakeup, millis, pendingIntent);
}
}
public bool CreateAlarm(Reminder reminder)
{
Context context = Android.App.Application.Context;
AlarmManager alarmManager = context.GetSystemService(Context.AlarmService) as AlarmManager;
Intent intent = new Intent(context, typeof(Services.RingtoneService));
intent.PutExtra("Title", reminder.Name);
intent.PutExtra("ReminderId", reminder.ReminderId);
intent.PutExtra("PlayOrEnd", true);
PendingIntent pendingIntent = PendingIntent.GetService(context, reminder.ReminderId, intent, PendingIntentFlags.UpdateCurrent);
DateTime now = DateTime.Now;
//Get Change in time
System.Diagnostics.Debug.WriteLine($"{reminder.Time.Hours}, {now.Hour}");
int diffHours = reminder.Time.Hours - now.Hour;
int diffMins = reminder.Time.Minutes - now.Minute;
int cHours = (diffHours < 0) ? (24 + diffHours) : diffHours;
int cMins = (diffMins < 0) ? (24 + diffMins) : diffMins;
#if DEBUG
long millis = 1000 * 5;
#else
//Test
long millis = ((cHours + reminder.Hours) * 1000 * 60 * 60) + (diffMins * 60 * 1000);
#endif
alarmManager.SetExactAndAllowWhileIdle(AlarmType.ElapsedRealtimeWakeup, millis, pendingIntent);
Toast.MakeText(context, $"Alarm Created {DateTime.Now.AddMilliseconds(millis)}", ToastLength.Short).Show();
//alarmManager.SetRepeating(AlarmType.Rtc, reminder.Hours* 1000, AlarmManager.IntervalDay, pendingIntent);
WriteLine($"Alarm Created {reminder.Name}, {reminder.ReminderId}");
return(true);
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
SetContentView(Resource.Layout.NotificationLayout);
this.notificationLabel = FindViewById <TextView>(Resource.Id.NotificationText);
this.btnAlarmManager = FindViewById <Button>(Resource.Id.btnAlarmManager);
this.btnJobScheduler = FindViewById <Button>(Resource.Id.btnJobScheduler);
notificationLabel.Text = Intent.GetStringExtra("main_message");
this.btnAlarmManager.Click += (sender, args) =>
{
Intent amIntent = new Intent(this, typeof(NotificationReceiver));
PendingIntent pendingAlarmIntent = PendingIntent.GetBroadcast(
this, 1, amIntent, PendingIntentFlags.UpdateCurrent);
AlarmManager alarmManager = (AlarmManager)GetSystemService(AlarmService);
DateTime dt = DateTime.Now.AddMilliseconds(100000);
alarmManager.SetExactAndAllowWhileIdle(
AlarmType.ElapsedRealtimeWakeup,
1000000000000000000,
pendingAlarmIntent);
};
btnJobScheduler.Click += (sender, args) =>
{
var builder = CreateBuilderJobSchedulerObject <ToastJobService>(this, 1);
var jobInfo = builder.Build();
var jobScheduler = GetSystemService(JobSchedulerService) as JobScheduler;
jobScheduler.Schedule(jobInfo);
};
var notificationManager = (NotificationManager)GetSystemService(NotificationService);
notificationManager.Cancel(1);
}
public AlarmActiveEventArgs StartBirdieLib()
{
AndroidRefreshes.Alarm = DateTime.Now;
// Set the alarm. --Kris
PendingIntent pendingIntent = PendingIntent.GetBroadcast(Application.Context, 0, AlarmIntent, PendingIntentFlags.UpdateCurrent);
AlarmManager alarmManager = (AlarmManager)Application.Context.GetSystemService(AlarmService);
alarmManager.SetExactAndAllowWhileIdle(AlarmType.ElapsedRealtimeWakeup, SystemClock.ElapsedRealtime() + 5000, pendingIntent);
// Start the WorkManager. --Kris
if (PeriodicWorkRequest == null)
{
PeriodicWorkRequest = PeriodicWorkRequest.Builder.From <BirdieWorker>(TimeSpan.FromMinutes(20)).Build();
}
PeriodicWorkRequest.Tags.Add("BirdieWorker");
WorkManager.Instance.Enqueue(PeriodicWorkRequest);
return(new AlarmActiveEventArgs
{
IsScheduled = true
});
}
public void SetAlarm(long crashCueMillis, string cueText)
{
Context context = Android.App.Application.Context;
Intent alarmIntent = new Intent(context, typeof(CrashAlarmReceiver));
alarmIntent.PutExtra("title", CueConstants.NotifTitle);
alarmIntent.PutExtra("message", CueConstants.NotifMessage + cueText);
alarmIntent.PutExtra("Id", CueConstants.UniqueId);
bool alreadyExists = (PendingIntent.GetBroadcast(context, CueConstants.UniqueId, alarmIntent, PendingIntentFlags.NoCreate) != null);
PendingIntent pendingIntent = PendingIntent.GetBroadcast(context, CueConstants.UniqueId, alarmIntent, PendingIntentFlags.UpdateCurrent);
AlarmManager alarmManager = (AlarmManager)context.GetSystemService(Context.AlarmService);
if (alreadyExists)
{
alarmManager.Cancel(pendingIntent);
}
if (Build.VERSION.SdkInt < Android.OS.BuildVersionCodes.M)
{
if (Build.VERSION.SdkInt >= Android.OS.BuildVersionCodes.Kitkat)
{
alarmManager.SetExact(AlarmType.RtcWakeup, crashCueMillis, pendingIntent);
}
else
{
alarmManager.Set(AlarmType.RtcWakeup, crashCueMillis, pendingIntent);
}
}
else
{
alarmManager.SetExactAndAllowWhileIdle(AlarmType.RtcWakeup, crashCueMillis, pendingIntent);
}
}
public static void ScheduleIntentExactAllowIdle(this AlarmManager manager, DateTime dateTime, PendingIntent intent) => manager.SetExactAndAllowWhileIdle(AlarmType.RtcWakeup, dateTime.ToUnix(), intent);
/// <summary>
///
/// </summary>
/// <param name="request"></param>
protected virtual bool ShowLater(NotificationRequest request)
{
if (request.Schedule.NotifyTime is null ||
request.Schedule.NotifyTime <= DateTime.Now) // To be consistent with iOS, Do not Schedule notification if NotifyTime is earlier than DateTime.Now
{
return(false);
}
var dictionaryRequest = NotificationCenter.GetRequestSerialize(request);
var intent = new Intent(Application.Context, typeof(ScheduledAlarmReceiver));
foreach (var item in dictionaryRequest)
{
intent.PutExtra(item.Key, item.Value);
}
var pendingIntent = PendingIntent.GetBroadcast(
Application.Context,
request.NotificationId,
intent,
PendingIntentFlags.UpdateCurrent
);
var utcAlarmTimeInMillis = (request.Schedule.NotifyTime.Value.ToUniversalTime() - DateTime.UtcNow).TotalMilliseconds;
var triggerTime = (long)utcAlarmTimeInMillis;
if (request.Schedule.RepeatType != NotificationRepeat.No)
{
TimeSpan?repeatInterval = null;
switch (request.Schedule.RepeatType)
{
case NotificationRepeat.Daily:
// To be consistent with iOS, Schedule notification next day same time.
repeatInterval = TimeSpan.FromDays(1);
break;
case NotificationRepeat.Weekly:
// To be consistent with iOS, Schedule notification next week same day same time.
repeatInterval = TimeSpan.FromDays(7);
break;
case NotificationRepeat.TimeInterval:
if (request.Schedule.NotifyRepeatInterval.HasValue)
{
repeatInterval = request.Schedule.NotifyRepeatInterval.Value;
}
break;
}
if (repeatInterval == null)
{
return(true);
}
var intervalTime = (long)repeatInterval.Value.TotalMilliseconds;
MyAlarmManager.SetInexactRepeating(AlarmType.ElapsedRealtime, SystemClock.ElapsedRealtime() + triggerTime, intervalTime, pendingIntent);
}
else
{
if (Build.VERSION.SdkInt >= BuildVersionCodes.M)
{
MyAlarmManager.SetExactAndAllowWhileIdle(AlarmType.ElapsedRealtime, SystemClock.ElapsedRealtime() + triggerTime, pendingIntent);
}
else
{
MyAlarmManager.SetExact(AlarmType.ElapsedRealtime, SystemClock.ElapsedRealtime() + triggerTime, pendingIntent);
}
}
AddPreferencesNotificationId(PreferencesPendingIdListKey, request.NotificationId);
return(true);
}
