private void OnTripSaveComplete(bool success)
{
activity.sendGaEvent("ui_action", "save trip", "save trip", Convert.ToInt16(success));
if (success)
{
Intent alarmIntent = new Intent(activity, typeof(LocationAlarmReceiver));
PendingIntent pi = PendingIntent.GetBroadcast(activity.ApplicationContext, 0, alarmIntent, 0);
DateTime dtNow = DateTime.Now.ToLocalTime();
DateTime dtStart = this.itinerary.GetStartDate().ToLocalTime();
TimeSpan diffTS = dtStart - dtNow;
long ms = (long)diffTS.TotalMilliseconds;
if (((int)Build.VERSION.SdkInt) >= 19)
{
mAlarmManager.SetExact(AlarmType.ElapsedRealtimeWakeup, ms, pi);
}
else
{
mAlarmManager.Set(AlarmType.ElapsedRealtimeWakeup, ms, pi);
}
view.OnSaveComplete();
activity.SetResult(Result.Ok);
activity.Finish();
}
else
{
view.OnSaveError();
activity.SetResult(Result.Canceled);
}
}
private void StartAlarm(bool isNotification, bool isRepeating)
{
AlarmManager manager = (AlarmManager)GetSystemService(Context.AlarmService);
Intent myIntent;
PendingIntent pendingIntent;
if (!isNotification)
{
myIntent = new Intent(this, typeof(AlarmToastReceiver));
pendingIntent = PendingIntent.GetBroadcast(this, 0, myIntent, 0);
}
else
{
myIntent = new Intent(this, typeof(AlarmNotificationReceiver));
pendingIntent = PendingIntent.GetBroadcast(this, 0, myIntent, 0);
}
if (!isRepeating)
{
manager.Set(AlarmType.RtcWakeup, SystemClock.ElapsedRealtime() + 3000, pendingIntent);
}
else
{
manager.SetRepeating(AlarmType.RtcWakeup, SystemClock.ElapsedRealtime() + 3000, 60 * 1000, pendingIntent);
}
}
private void SetRepeatingAlarm(ICollection <string> numbers, bool isTest)
{
Intent receiverIntent = new Intent(this, typeof(AlarmReceiver));
AlarmManager alarmManager = (AlarmManager)GetSystemService(AlarmService);
if (isTest)
{
PendingIntent pendingIntent = PendingIntent.GetBroadcast(this, 0, receiverIntent, PendingIntentFlags.CancelCurrent);
int seconds = 5;
alarmManager.Set(AlarmType.RtcWakeup, JavaSystem.CurrentTimeMillis() + (seconds * 1000), pendingIntent);
myTextViewOutput.Text = $"Test Alarm set in {seconds} seconds.";
}
else
{
PendingIntent pendingIntent = PendingIntent.GetBroadcast(this, 1, receiverIntent, PendingIntentFlags.CancelCurrent);
Java.Util.Calendar calendar = Java.Util.Calendar.Instance;
calendar.TimeInMillis = (JavaSystem.CurrentTimeMillis());
calendar.Set(Java.Util.CalendarField.HourOfDay, 9);
calendar.Set(Java.Util.CalendarField.Minute, 0);
calendar.Set(Java.Util.CalendarField.Second, 0);
alarmManager.SetRepeating(AlarmType.RtcWakeup, calendar.TimeInMillis, AlarmManager.IntervalDay, pendingIntent);
myTextViewOutput.Text = "Repeating daily Alarm set. Begin at: " + calendar.Time.ToString();
}
}
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);
}
}
/// <summary>
/// Creates the alarm to wake the app, to set the notification.
/// </summary>
/// <param name="dateTime"></param>
/// <param name="title"></param>
/// <param name="message"></param>
public void Remind(DateTime notificationTime, string title, string message, long requestId)
{
Intent alarmIntent = new Intent(Forms.Context, typeof(ImageImprov.Droid.Notifications)); // this class is the intent as well! :)
alarmIntent.PutExtra("message", message);
alarmIntent.PutExtra("title", title);
PendingIntent pendingIntent = PendingIntent.GetBroadcast(Forms.Context, (int)requestId, alarmIntent, PendingIntentFlags.OneShot);
requestCode++;
AlarmManager alarmManager = (AlarmManager)Forms.Context.GetSystemService(Context.AlarmService);
long launchTime = GlobalSingletonHelpers.GetMillisecondsSinceUnixEpoch(notificationTime);
alarmManager.Set(AlarmType.RtcWakeup, launchTime, pendingIntent);
/*
* // sanity check. Turns out I'm sane.
* long now = Java.Lang.JavaSystem.CurrentTimeMillis();
* System.Diagnostics.Debug.WriteLine("DHB:Droid:Notifications:Remind launch time is:" + launchTime);
* System.Diagnostics.Debug.WriteLine("DHB:Droid:Notifications:Remind droid time is:" + now);
*/
// don't understand the purpose of this line...
//PendingIntent pendingIntent2 = PendingIntent.GetBroadcast(context, requestCode, alarmIntent, 0); this crashes the system, but then requestCode is wrong...
//PendingIntent pendingIntent2 = PendingIntent.GetBroadcast(context, (requestCode-1), alarmIntent, 0);
}
public void Remind(DateTime dateTime, string title, string message)
{
// create alarm intent
Intent alarmIntent = new Intent(Application.Context, typeof(AlarmReceiver));
alarmIntent.PutExtra("message", message);
alarmIntent.PutExtra("title", title);
// specify the broadcast receiver
PendingIntent pendingIntent = PendingIntent.GetBroadcast(Application.Context, 0, alarmIntent, PendingIntentFlags.UpdateCurrent);
AlarmManager alarmManager = (AlarmManager)Application.Context.GetSystemService(Context.AlarmService);
// set the time when app is woken up
// todo: this is where time is adjusted
//alarmManager.SetInexactRepeating(AlarmType.ElapsedRealtimeWakeup, SystemClock.ElapsedRealtime() + 5* 1000, 1000, pendingIntent);
alarmManager.Set(AlarmType.ElapsedRealtimeWakeup, SystemClock.ElapsedRealtime() + 1 * 1000, pendingIntent);
////Intent alarmIntent = new Intent(this, typeof(AlarmReceiver));
////PendingIntent pendingIntent = PendingIntent.GetBroadcast(this, 0, alarmIntent, PendingIntentFlags.UpdateCurrent);
////AlarmManager alarmManager = (AlarmManager)GetSystemService(Context.AlarmService);
//var tomorrowMorningTime = new DateTime(DateTime.Now.AddDays(1).Year, DateTime.Now.AddDays(1).Month, DateTime.Now.AddDays(1).Day, 0, 0, 1);
//var timeDifference = tomorrowMorningTime – DateTime.Now;
//var millisecondsInOneDay = 86400000;
//alarmManager.SetInexactRepeating(AlarmType.ElapsedRealtimeWakeup, SystemClock.ElapsedRealtime() + (long)timeDifference.TotalMilliseconds, (long)millisecondsInOneDay, pendingIntent);
}
public void AddNotification(int identifier, string title, string message, DateTime scheduledDateTime)
{
if (Notifications.ContainsKey(identifier))
{
RemoveNotification(identifier);
}
Intent alarmIntent = new Intent(Forms.Context, typeof(AlarmReceiver));
alarmIntent.PutExtra("message", message);
alarmIntent.PutExtra("title", title);
PendingIntent pendingIntent = PendingIntent.GetBroadcast(Forms.Context, 0, alarmIntent,
PendingIntentFlags.UpdateCurrent);
AlarmManager alarmManager = (AlarmManager)Forms.Context.GetSystemService(Context.AlarmService);
Calendar calendarScheduled = Calendar.GetInstance(Locale.German);
calendarScheduled.Set(scheduledDateTime.Year, scheduledDateTime.Month,
scheduledDateTime.Day, scheduledDateTime.Hour, scheduledDateTime.Minute,
scheduledDateTime.Second);
Calendar calendarNow = Calendar.GetInstance(Locale.German);
var now = DateTime.Now;
calendarNow.Set(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second);
long alertInMillisFromNow = calendarScheduled.TimeInMillis - calendarNow.TimeInMillis;
if (alertInMillisFromNow > 0)
{
alarmManager.Set(AlarmType.ElapsedRealtime, SystemClock.ElapsedRealtime() + alertInMillisFromNow, pendingIntent);
Notifications.Add(identifier, pendingIntent);
}
}
void IReminderNotification.AddNotification(DateTimeOffset maintenanceReminderStartDateTime, int dailyInterval, int maintenanceReminderRepetition,
string title, string body, bool isUnlimited)
{
pendingIntents = new List <PendingIntent>();
// time when the first notification should appear from now on (if time is in the past, the notification will be fired immediately).
TimeSpan reminderTime = maintenanceReminderStartDateTime - DateTimeOffset.Now;
int dailyMiliseconds = 86400000;
long intervalInMiliseconds = dailyMiliseconds * dailyInterval;
long currentReminderTime = SystemClock.ElapsedRealtime() + (long)reminderTime.TotalMilliseconds;
int countReminderRepetitions = 0;
//If a limit is set, add the planned amount of reminders to the scheduler
if (!isUnlimited)
{
while (countReminderRepetitions <= maintenanceReminderRepetition)
{
PendingIntent intent = createPendingIntent(title, body, countReminderRepetitions);
alarmManager.Set(AlarmType.ElapsedRealtimeWakeup, SystemClock.ElapsedRealtime() + (long)reminderTime.TotalMilliseconds + (countReminderRepetitions * intervalInMiliseconds), intent);
pendingIntents.Add(intent);
countReminderRepetitions++;
}
}
//if no limit is set, add a repeating alarm
else
{
PendingIntent intent = createPendingIntent(title, body, countReminderRepetitions);
alarmManager.SetRepeating(AlarmType.ElapsedRealtimeWakeup, SystemClock.ElapsedRealtime() + (long)reminderTime.TotalMilliseconds, (dailyMiliseconds * dailyInterval), intent);
pendingIntents.Add(intent);
}
}
void OneShotClick(object sender, EventArgs e)
{
// When the alarm goes off, we want to broadcast an Intent to our
// BroadcastReceiver. Here we make an Intent with an explicit class
// name to have our own receiver (which has been published in
// AndroidManifest.xml) instantiated and called, and then create an
// IntentSender to have the intent executed as a broadcast.
int timeHour = Convert.ToInt32(timeselector.Hour);
int timeMinutes = Convert.ToInt32(timeselector.Minute);
long q = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
AlarmManager am = (AlarmManager)GetSystemService(AlarmService);
Intent oneshotIntent = new Intent(this, typeof(OneShotAlarm));
PendingIntent source = PendingIntent.GetBroadcast(this, 0, oneshotIntent, 0);
vibro.Vibrate(500);
Java.Util.Calendar calendar = Java.Util.Calendar.Instance;
calendar.Set(CalendarField.HourOfDay, timeHour);
calendar.Set(CalendarField.Minute, timeMinutes);
am.Set(AlarmType.RtcWakeup, calendar.TimeInMillis, source);
// Tell the user about what we did.
if (repeating != null)
repeating.Cancel();
repeating = Toast.MakeText(this, Resource.String.one_shot_scheduled, ToastLength.Long);
repeating.Show();
}
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());
}
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.SetRepeating(AlarmType.RtcWakeup, triggerTime, 10000, pendingIntent);
alarmManager.Set(AlarmType.RtcWakeup, triggerTime, pendingIntent);
}
else
{
Show(title, message);
}
}
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 void IniciarAlarme(bool isNotificacao, bool isRepetirAlarme)
{
AlarmManager manager = (AlarmManager)GetSystemService(Context.AlarmService);
Intent minhaIntent;
PendingIntent pendingIntent;
if (!isNotificacao)
{
minhaIntent = new Intent(this, typeof(AlarmeMensagemReceiver));
pendingIntent = PendingIntent.GetBroadcast(this, 0, minhaIntent, 0);
}
else
{
minhaIntent = new Intent(this, typeof(AlarmeNotificacaoReceiver));
pendingIntent = PendingIntent.GetBroadcast(this, 0, minhaIntent, 0);
}
if (!isRepetirAlarme)
{
manager.Set(AlarmType.RtcWakeup, SystemClock.ElapsedRealtime() + 3000, pendingIntent);
}
else
{
manager.SetRepeating(AlarmType.RtcWakeup, SystemClock.ElapsedRealtime() + 3000, 60 * 1000, pendingIntent);
}
}
public static void LeavingApp(Context ctx)
{
ISharedPreferences prefs = PreferenceManager.GetDefaultSharedPreferences(ctx);
String sTimeout = prefs.GetString(ctx.GetString(Resource.String.app_timeout_key), ctx.GetString(Resource.String.clipboard_timeout_default));
long timeout;
if (!long.TryParse(sTimeout, out timeout))
{
timeout = DefaultTimeout;
}
if (timeout == -1)
{
// No timeout don't start timeout service
return;
}
//in addition to starting an alarm, check the time in the next resume. This might be required as alarms seems to be unrealiable in more recent android versions
App.Kp2a.TimeoutTime = DateTime.Now + TimeSpan.FromMilliseconds(timeout);
long triggerTime = Java.Lang.JavaSystem.CurrentTimeMillis() + timeout;
AlarmManager am = (AlarmManager)ctx.GetSystemService(Context.AlarmService);
Kp2aLog.Log("Timeout start");
am.Set(AlarmType.Rtc, triggerTime, BuildPendingBroadcastIntent(App.Context));
}
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
}
}
private void SetAlarm(Alarm alarm, AlarmManager alarmManager, Intent alarmIntent)
{
Calendar calendar = (Calendar)Calendar.Instance.Clone();
var Now = DateTime.Now;
int baseID = GetFirstID(alarm);
if (!alarm.IsRepeated)
{
for (int i = 0; i < alarm.AllTimes.Count; i++)
{
PendingIntent pendingIntent = PendingIntent.GetBroadcast(Android.App.Application.Context, baseID + i, alarmIntent, PendingIntentFlags.UpdateCurrent);
var alarmTime = alarm.AllTimes[i];
double millisecondsToAlarm = (alarmTime - DateTime.Now).TotalMilliseconds;
alarmManager.Set(AlarmType.RtcWakeup, calendar.TimeInMillis + (long)millisecondsToAlarm, pendingIntent);
}
}
else
{
for (int i = 0; i < alarm.AllTimes.Count; i++)
{
PendingIntent pendingIntent = PendingIntent.GetBroadcast(Android.App.Application.Context, baseID + i, alarmIntent, PendingIntentFlags.UpdateCurrent);
var alarmTime = alarm.AllTimes[i];
double millisecondsToAlarm = (alarmTime - DateTime.Now).TotalMilliseconds;
long millisecondsInWeek = 7 * 24 * 60 * 60 * 1000;
alarmManager.SetRepeating(AlarmType.RtcWakeup, calendar.TimeInMillis + (long)millisecondsToAlarm, millisecondsInWeek, pendingIntent);
}
}
}
public void RegisterSchudle(Schudle s, DayOfWeek dayofwaek)
{
AlarmManager alarm_mngr = (AlarmManager)context.GetSystemService(Context.AlarmService);
Intent intent = new Intent("DroidVigia.DroidVigia.DroidVigia.SchudledAlarm");
PendingIntent pintent = PendingIntent.GetBroadcast(context, 0, intent, PendingIntentFlags.OneShot);
var pref_model = Global.GetAppPreferences(context);
pref_model.Next_Schudle_Name = s.Label;
var schudled_time = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, s.Hour, s.Minute, 0);
int diff_days = 0;
if (dayofwaek > DateTime.Now.DayOfWeek)
{
diff_days = dayofwaek - DateTime.Now.DayOfWeek;
}
if (dayofwaek < DateTime.Now.DayOfWeek)
{
diff_days = (DayOfWeek.Saturday - DateTime.Now.DayOfWeek) + ((int)dayofwaek + 1);
}
schudled_time = schudled_time.AddDays(diff_days);
long millis = (long)(schudled_time - DateTime.Now).TotalMilliseconds;
//Calendar future= Calendar.GetInstance(Java.Util.TimeZone.Default);
//future.Add(Java.Util.CalendarField.Millisecond, (int)millis);
alarm_mngr.Set(AlarmType.ElapsedRealtimeWakeup, SystemClock.ElapsedRealtime() + millis, pintent);
}
private static void CreateAlarmManager(Context ctx, Notification notification, DateTime date, NotificationOption not, int sessionId)
{
DateTime dtBasis = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
AlarmManager alarmManager = (AlarmManager)ctx.GetSystemService(Context.AlarmService);
alarmManager.Set(AlarmType.RtcWakeup, (long)date.ToUniversalTime().Subtract(dtBasis).TotalMilliseconds, GetPendingIntent(ctx, notification, not, sessionId));
}
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 static void CrearAlarma()
{
Intent intencion = new Intent(Forms.Context, typeof(Receptor));
PendingIntent pendiente = PendingIntent.GetBroadcast(Forms.Context, 0, intencion, PendingIntentFlags.UpdateCurrent);
AlarmManager alarma = (AlarmManager)Forms.Context.GetSystemService(Context.AlarmService);
alarma.Set(AlarmType.ElapsedRealtime, SystemClock.ElapsedRealtime() + 60000, pendiente);
}
void RestartService()
{
var intent = new Intent(this, typeof(SmsBlipService));
var pendingIntent = PendingIntent.GetService(this, 0, intent, 0);
long now = new Date().Time;
AlarmManager.Set(AlarmType.RtcWakeup, now + OneSecond, pendingIntent);
}
public void NotifyMe(View view)
{
Intent i = new Intent(this, typeof(AlarmReceiver)).PutExtra(AlarmReceiver.EXTRA_TYPE, typeSpinner.SelectedItemPosition);
PendingIntent pendingIntent = PendingIntent.GetBroadcast(this, 0, i, PendingIntentFlags.UpdateCurrent);
AlarmManager manager = (AlarmManager)GetSystemService(Application.AlarmService);
manager.Set(AlarmType.ElapsedRealtimeWakeup, SystemClock.ElapsedRealtime() + (1000 * delaySeekBar.Progress), pendingIntent);
}
public void LocalNotify(int idNotificacao, string title, string message, Int32 diaDaSemanaAlarme, Int32 horaAlarme, Int32 minutoAlarme, bool repetir)
{
var context = Android.App.Application.Context;
Intent alarmIntent = new Intent(context, typeof(AlarmReceiver));
alarmIntent.PutExtra("message", message);
alarmIntent.PutExtra("title", title);
alarmIntent.PutExtra("id", Convert.ToString(idNotificacao));
PendingIntent pendingIntent = PendingIntent.GetBroadcast(context, idNotificacao, alarmIntent, PendingIntentFlags.UpdateCurrent);
AlarmManager alarmManager = (AlarmManager)context.GetSystemService(Context.AlarmService);
var hoje = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second);
var diaDaSemana = Convert.ToInt32(hoje.DayOfWeek);
var horaAtual = hoje.Hour;
var minutoAtual = hoje.Minute;
int diasAdicionar = 0;
if (diaDaSemana == diaDaSemanaAlarme)
{
if (horaAtual > horaAlarme)
{
diasAdicionar = 7;
diaDaSemana = diaDaSemanaAlarme;
}
else if (horaAtual == horaAlarme && minutoAtual >= minutoAlarme)
{
diasAdicionar = 7;
diaDaSemana = diaDaSemanaAlarme;
}
}
while (diaDaSemana != diaDaSemanaAlarme)
{
diasAdicionar++;
diaDaSemana++;
if (diaDaSemana == 7)
{
diaDaSemana = 0;
}
}
var tempoAlarme = new DateTime(DateTime.Now.AddDays(diasAdicionar).Year, DateTime.Now.AddDays(diasAdicionar).Month, DateTime.Now.AddDays(diasAdicionar).Day, horaAlarme, minutoAlarme, 0);
var diferencaTempo = tempoAlarme - hoje;
var tempoDisparo = (long)diferencaTempo.TotalMilliseconds;
if (repetir)
{
alarmManager.SetInexactRepeating(AlarmType.ElapsedRealtimeWakeup, SystemClock.ElapsedRealtime() + tempoDisparo, AlarmManager.IntervalDay * 7, pendingIntent);
}
else
{
alarmManager.Set(AlarmType.ElapsedRealtimeWakeup, SystemClock.ElapsedRealtime() + tempoDisparo, pendingIntent);
}
}
public void SetAlarm(Todo work)
{
myIntent.PutExtra("work", work.Title);
pendingIntent = PendingIntent.GetBroadcast(Android.App.Application.Context, work.ID, myIntent, PendingIntentFlags.UpdateCurrent);
TimeSpan span = work.From - DateTime.Now;
long schedule = (long)(Java.Lang.JavaSystem.CurrentTimeMillis() + span.TotalMilliseconds);
manager.Set(AlarmType.RtcWakeup, schedule, pendingIntent);
}
public void RegisterSchudleCall()
{
AlarmManager alarm_mngr = (AlarmManager)context.GetSystemService(Context.AlarmService);
Intent intent = new Intent("DroidVigia.DroidVigia.DroidVigia.SchudledCall");
PendingIntent pintent = PendingIntent.GetBroadcast(context, 0, intent, PendingIntentFlags.OneShot);
long millis = 20000;
alarm_mngr.Set(AlarmType.ElapsedRealtimeWakeup, SystemClock.ElapsedRealtime() + millis, pintent);
}
public void startrunservice()
{
Intent i = new Intent(this, typeof(Autostart));
PendingIntent pi = PendingIntent.GetBroadcast(
Application.Context, 0, i, 0);
AlarmManager am = (AlarmManager)GetSystemService(AlarmService);
am.Set(AlarmType.RtcWakeup, Java.Lang.JavaSystem.CurrentTimeMillis(), pi);
}
public void SendLocalNotification()
{
var sendAt = (Settings.NextNotification - DateTime.Now.Hour) % 24;
Intent AlarmIntent = new Intent(Application.Context, typeof(AlarmReceiver));
PendingIntent pendingIntent = PendingIntent.GetBroadcast(Application.Context, 0, AlarmIntent, PendingIntentFlags.UpdateCurrent);
AlarmManager alarmManager = Application.Context.GetSystemService(Context.AlarmService) as AlarmManager;
alarmManager.Set(AlarmType.ElapsedRealtime, SystemClock.ElapsedRealtime() + sendAt * 1000, pendingIntent);
}
/// <summary>
/// 设置定时任务
/// </summary>
/// <param name="context">上下文</param>
/// <param name="intent"></param>
/// <param name="time">间隔时间(秒)</param>
void AlarmTask(Context context, Intent intent, long time)
{
_alarmManager = (AlarmManager)context.GetSystemService(Context.AlarmService);
long triggerAtMills = SystemClock.ElapsedRealtime() + time;
PendingIntent pIntent = PendingIntent.GetBroadcast(Application.Context, 0, new Intent(Android.App.Application.Context, typeof(AlarmReceiver)), 0);
_alarmManager.Cancel(pIntent);
_alarmManager.Set(AlarmType.ElapsedRealtimeWakeup, triggerAtMills, pIntent);
}
public void SetAlarm()
{
//"this" is context, and "MyTestReceiver" the recipient of the intent - in total: name and address!)
Intent intent = new Intent(this, typeof(MyTestReceiver));
PendingIntent pendingIntent = PendingIntent.GetBroadcast(this, 0, intent, PendingIntentFlags.CancelCurrent);
AlarmManager alarmManager = (AlarmManager)this.GetSystemService(Context.AlarmService);
//see http://sangsoonam.github.io/2017/03/01/do-not-use-curenttimemillis-for-time-interval.html
alarmManager.Set(AlarmType.ElapsedRealtime, SystemClock.ElapsedRealtime() + 5 * 1000, pendingIntent);
}
static public void SetAppAlarmManager(Context context, int seconds = 300)
{
//Java.Util.Calendar calendar = Java.Util.Calendar.GetInstance(Java.Util.TimeZone.GetTimeZone("UTC"));
//calendar.TimeInMillis = Java.Lang.JavaSystem.CurrentTimeMillis();
Intent alarmIntent = new Intent(context, typeof(AppReceiverAlarm));
PendingIntent pendingIntent = PendingIntent.GetBroadcast(context, 0, alarmIntent, 0);
AlarmManager alarmManager = (AlarmManager)context.GetSystemService(Context.AlarmService);
alarmManager.Set(AlarmType.RtcWakeup, Java.Lang.JavaSystem.CurrentTimeMillis() + seconds * 1000, pendingIntent);
}
