public void SetAlarm(List <JadwalItem> jadwal)
{
var currentContext = Android.App.Application.Context;
AlarmManager alarmManager = currentContext.GetSystemService(Context.AlarmService) as AlarmManager;
foreach (var item in jadwal)
{
var Now = DateTime.Now;
TimeSpan interval = Now.AddDays(7) - Now;
var start = GetStart(item.Hari, item.Mulai.ToShortTimeString());
/* Util.Calendar calendar = Util.Calendar.GetInstance(Util.TimeZone.GetTimeZone("GMT+9:00"));
* calendar.Set(Util.CalendarField.DayOfWeek, GetDayOfWeek(item.Hari));
* calendar.Set(Util.CalendarField.HourOfDay, item.Mulai.Hour);
* calendar.Set(Util.CalendarField.Minute, item.Mulai.Minute);
* var day = calendar.Get(Util.CalendarField.DayOfWeek);
*/
var alarmIntent = new Intent(currentContext, typeof(AlarmReciever));
alarmIntent.PutExtra("waktu", $"Jam {item.Mulai.ToShortTimeString()}");
alarmIntent.PutExtra("matakuliah", $"{item.NamaMataKuliah}");
alarmIntent.PutExtra("jadwalId", $"{item.JadwalId}");
var pending = PendingIntent.GetBroadcast(currentContext, item.JadwalId, alarmIntent, PendingIntentFlags.UpdateCurrent);
var currentime = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
alarmManager.SetRepeating(AlarmType.RtcWakeup, currentime + (long)start.TotalMilliseconds, (long)interval.TotalMilliseconds, pending);
}
}
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);
}
}
}
private void switch_itemSelected(object sender, CompoundButton.CheckedChangeEventArgs e, Context context, int position)
{
AlarmManager manager = (AlarmManager)context.GetSystemService(Context.AlarmService);
Intent myIntent = new Intent(context, typeof(ReminderNotification));
if (e.IsChecked)
{
//set data
var valuesForActivity = new Bundle();
valuesForActivity.PutString("MESSAGE", riwayatReminder[position].Message);
myIntent.PutExtras(valuesForActivity);
DateTime date = riwayatReminder[position].Time;
string dateString = $"{date.Month}/{date.Day}/{date.Year} {date.Hour}:{date.Minute}:{date.Second} {date.ToString("tt")}";
DateTimeOffset dateOffsetValue = DateTimeOffset.Parse(dateString);
var millisec = dateOffsetValue.ToUnixTimeMilliseconds();
// set alarm
PendingIntent pendingIntent = PendingIntent.GetBroadcast(context, (int)millisec, myIntent, 0);
manager.SetRepeating(AlarmType.Rtc, millisec, AlarmManager.IntervalDay, pendingIntent);
}
else
{
// cancel alarm
PendingIntent pendingIntent = PendingIntent.GetBroadcast(context, riwayatReminder[position].NotificationID, myIntent, 0);
manager.Cancel(pendingIntent);
}
ReminderHelper.SwitchRiwayatReminder(riwayatReminder[position].Id, e.IsChecked);
}
public override void OnReceive(Context context, Intent intent)
{
AlarmManager alarmManager = (AlarmManager)context.GetSystemService(Context.AlarmService);
PendingIntent alarmIntent = GetStartPendingIntent(context);
alarmManager.SetRepeating(AlarmType.RtcWakeup, Java.Lang.JavaSystem.CurrentTimeMillis(), 60000, alarmIntent);
}
public void SetAlarm(Context context)
{
System.Diagnostics.Debug.WriteLine("SET ALARM");
Calendar alarmTime = Calendar.GetInstance(Java.Util.TimeZone.Default);
//alarmTime.Set(CalendarField.DayOfMonth, 1);
//alarmTime.Set(CalendarField.Month, 11);
//alarmTime.Set(CalendarField.Year, 2014);
alarmTime.Set(CalendarField.Hour, 07);
alarmTime.Set(CalendarField.Minute, 05);
alarmTime.Set(CalendarField.Second, 0);
alarmTime.Set(CalendarField.Millisecond, 0);
alarmTime.Set(CalendarField.AmPm, 0);
am = (AlarmManager)context.GetSystemService(Context.AlarmService);
Intent intent = new Intent(context, typeof(SampleAlarmReceiver));
//intent.PutExtra (ALARM_ACTION, true);
pi = PendingIntent.GetBroadcast(context, 0, intent, 0);
//PendingIntentFlags.UpdateCurrent
am.SetRepeating(AlarmType.RtcWakeup, alarmTime.TimeInMillis, AlarmManager.IntervalHour, pi);
Console.WriteLine(alarmTime);
// Enable {@code SampleBootReceiver} to automatically restart the alarm when the
// device is rebooted.
ComponentName receiver = new ComponentName(context, Java.Lang.Class.FromType(typeof(SampleBootReceiver)));
PackageManager pm = context.PackageManager;
pm.SetComponentEnabledSetting(receiver,
ComponentEnabledState.Enabled,
ComponentEnableOption.DontKillApp);
}
protected override void OnCreate(Bundle savedInstanceState)
{
GetReadStoragePermission();
CreateWallpaperImagesFolder();
// It seems that minimum interval is 60000 ms == 1 min
var interval = 30000;
var intent = new Intent(ApplicationContext, typeof(BackgroundActivity));
var pendingIntent = PendingIntent.GetBroadcast(ApplicationContext, 0, intent, 0);
AlarmManager alarm = (AlarmManager)ApplicationContext.GetSystemService(Context.AlarmService);
alarm.SetRepeating(AlarmType.RtcWakeup, Java.Lang.JavaSystem.CurrentTimeMillis(), interval, pendingIntent);
TabLayoutResource = Resource.Layout.Tabbar;
ToolbarResource = Resource.Layout.Toolbar;
base.OnCreate(savedInstanceState);
global::Xamarin.Forms.Forms.SetFlags("Shell_Experimental", "Visual_Experimental", "CollectionView_Experimental", "FastRenderers_Experimental");
Xamarin.Essentials.Platform.Init(this, savedInstanceState);
global::Xamarin.Forms.Forms.Init(this, savedInstanceState);
LoadApplication(new App());
}
public void startTask()
{
if (Build.VERSION.SdkInt <= BuildVersionCodes.Kitkat)
{
AlarmManager alarmManager = (AlarmManager)GetSystemService(Context.AlarmService);
Intent intent = new Intent(this, typeof(RepeatingAlarm));
PendingIntent sender = PendingIntent.GetBroadcast(this, 0, intent, 0);
// Schedule the alarm!
alarmManager.SetRepeating(AlarmType.RtcWakeup, SystemClock.ElapsedRealtime(), 5 * 1000, sender);
}
else
{
JobScheduler scheduler = (JobScheduler)GetSystemService(Context.JobSchedulerService);
if (isJobPollServiceOn())
{
}
else
{
JobInfo jobInfo = new JobInfo.Builder(1,
new ComponentName(this, Java.Lang.Class.FromType(typeof(JobSchedulerService))))
.SetPeriodic(JobInfo.MinPeriodMillis)
.Build();
scheduler.Schedule(jobInfo);
}
}
}
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();
}
}
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);
}
}
public int setAlarm(DateTime d)
{
AlarmManager manager = (AlarmManager)Android.App.Application.Context.GetSystemService(Context.AlarmService);
Intent intent;
PendingIntent pendingIntent;
// trying to set multiple alarms on non-consecutive days, e.g. M, W, F
intent = new Intent(Android.App.Application.Context, typeof(AlarmReceiver));
pendingIntent = PendingIntent.GetBroadcast(Android.App.Application.Context, 0, intent, 0);
//manager.SetExact(AlarmType.RtcWakeup, SystemClock.ElapsedRealtime() + 3000, pendingIntent);
//manager.SetExact(AlarmType.RtcWakeup, new DateTimeOffset(d).ToUnixTimeMilliseconds(), pendingIntent);
manager.SetRepeating(AlarmType.RtcWakeup, new DateTimeOffset(d).ToUnixTimeMilliseconds(), 60000, pendingIntent);
manager.SetRepeating(AlarmType.RtcWakeup, new DateTimeOffset(d).ToUnixTimeMilliseconds() + 5000, 60000, pendingIntent);
manager.SetRepeating(AlarmType.RtcWakeup, new DateTimeOffset(d).ToUnixTimeMilliseconds() + 10000, 60000, pendingIntent);
return(d.Date.Minute);
}
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 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 void StartPeriodicBackgroundWorkUsingAlarmManager()
{
PendingIntent pendingIntent = PendingIntent.GetBroadcast(Application.Context, 0, new Intent(Application.Context, typeof(PeriodicAlarmReceiver)), PendingIntentFlags.UpdateCurrent);
AlarmManager alarmManager = (AlarmManager)Application.Context.GetSystemService(Context.AlarmService);
alarmManager.SetRepeating(AlarmType.ElapsedRealtimeWakeup, SystemClock.ElapsedRealtime() + 1000, 10 * 1000, pendingIntent);
}
public void RegisterAlarmManager()
{
if (!IsAlarmSet())
{
alarm = (AlarmManager)Ctx.GetSystemService(Context.AlarmService);
pendingServiceIntent = PendingIntent.GetService(Ctx, 0, timerServiceIntent, PendingIntentFlags.CancelCurrent);
alarm.SetRepeating(AlarmType.Rtc, 0, (1000 * 60 * IntervalMinutes), pendingServiceIntent);
}
}
protected override void ScheduleRepeatingCallback(string callbackId, int initialDelayMS, int repeatDelayMS, string userNotificationMessage)
{
long initialTimeMS = Java.Lang.JavaSystem.CurrentTimeMillis() + initialDelayMS;
Logger.Log("Callback " + callbackId + " scheduled for " + (new DateTimeOffset(1970, 1, 1, 0, 0, 0, new TimeSpan()).AddMilliseconds(initialTimeMS)) + " (repeating).", LoggingLevel.Normal, GetType());
AlarmManager alarmManager = _service.GetSystemService(Context.AlarmService) as AlarmManager;
alarmManager.SetRepeating(AlarmType.RtcWakeup, initialTimeMS, repeatDelayMS, GetCallbackIntent(callbackId, true));
}
public override void OnStart(Intent intent, int startId)
{
Intent alarmIntent = new Intent(this, typeof(RepeatingAlarm));
var source = PendingIntent.GetBroadcast(this, 0, alarmIntent, 0);
AlarmManager alarmManager = GetSystemService(AlarmService).JavaCast <AlarmManager>();
// SetRepeating([GeneratedEnum] AlarmType type, long triggerAtMillis, long intervalMillis, PendingIntent operation);
alarmManager.SetRepeating(AlarmType.Rtc, SystemClock.CurrentThreadTimeMillis(), 500, source);
//alarmManager.SetExact(AlarmType.Rtc, SystemClock.CurrentThreadTimeMillis(), source);
}
// Schedule location updates using alarm
private async Task ScheduleLocationUpdate(int interval)
{
Intent intent = new Intent(this, typeof(LocationReceiver));
DateTime dateTime = DateTime.Now;
long startTime = dateTime.Millisecond;
Log.Debug("Location", "Requested after " + interval + " minutes");
_pendingIntent = PendingIntent.GetBroadcast(this, 0, intent, 0);
_alarmManager.SetRepeating(AlarmType.Rtc, startTime, interval * 60 * interval, _pendingIntent);
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
SetContentView(Resource.Layout.Alarm);
Intent it = new Intent(ApplicationContext, typeof(AlarmReciver));
pndIntent = PendingIntent.GetBroadcast(ApplicationContext, 0, it, PendingIntentFlags.UpdateCurrent);
edtData = FindViewById <EditText>(Resource.Id.main_edt_data);
edtHorario = FindViewById <EditText>(Resource.Id.main_edt_tempo);
btnSalvar = FindViewById <Button>(Resource.Id.main_btn_salvar);
btnCancelar = FindViewById <Button>(Resource.Id.main_btn_cancelar);
//all.SetAlarm(ApplicationContext, 3);
almManager = (AlarmManager)ApplicationContext.GetSystemService(Context.AlarmService);
almManager.SetRepeating(AlarmType.ElapsedRealtimeWakeup, Java.Lang.JavaSystem.CurrentTimeMillis(), 2000, pndIntent);
btnSalvar.Click += delegate
{
int minuto = 0, hora = 0, segundo = 0;
string[] horario = new string[3];
//horario = edtHorario.Text.Split(':');
//hora = int.Parse(horario[0]);
//minuto = int.Parse(horario[1]);
//segundo = int.Parse(horario[2]);
//almManager.Set(AlarmType.ElapsedRealtime, Java.Lang.JavaSystem.CurrentTimeMillis(), pndIntent);
almManager.SetRepeating(AlarmType.RtcWakeup, Java.Lang.JavaSystem.CurrentTimeMillis(), 1000, pndIntent);
};
btnCancelar.Click += delegate {
if (almManager != null)
{
almManager.Cancel(pndIntent);
}
};
}
/// <summary>
/// Updates notifications based on the delivered appointments.
/// </summary>
/// <param name="context">the application context for the alarm/notification.</param>
/// <param name="appointments">an Enumerable of Appointments which had their notification configuration changed.</param>
public static void UpdateAlarms(Context context, IEnumerable <Appointment> appointments)
{
AlarmManager alarmManager = (AlarmManager)context.GetSystemService(Context.AlarmService);
PendingIntent alarmIntent = GetStartPendingIntent(context, appointments);
Console.WriteLine(GetTriggerAt(DateTime.UtcNow));
alarmManager.SetRepeating(AlarmType.RtcWakeup,
GetTriggerAt(DateTime.UtcNow),
NOTIFICATIONS_INTERVAL_IN_HOURS * AlarmManager.IntervalHour,
alarmIntent);
}
private void SetTimer()
{
TimeSpan ts = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc));
long millis = (long)ts.TotalMilliseconds;
Intent intentAlarm = new Intent(Manager.context, typeof(ToastBroadcast));
AlarmManager alarmManager = (AlarmManager)Manager.activity.GetSystemService(Context.AlarmService);
int interval = 5000;
alarmManager.SetRepeating(AlarmType.RtcWakeup, millis, interval, PendingIntent.GetBroadcast(Manager.context, 1, intentAlarm, PendingIntentFlags.UpdateCurrent));
}
void ScheduleStockUpdates()
{
if (!IsAlarmSet())
{
AlarmManager alarm = (AlarmManager)GetSystemService(AlarmService);
PendingIntent pendingServiceIntent = PendingIntent.GetService(this, 0, _stockServiceIntent,
PendingIntentFlags.CancelCurrent);
alarm.SetRepeating(AlarmType.Rtc, 0, 15000, pendingServiceIntent);
}
}
public void Remind(DateTime dateTime, string title, string message, int interval)
{
Intent alarmIntent = new Intent(_context, typeof(MainScreen));
alarmIntent.PutExtra("message", message);
alarmIntent.PutExtra("title", title);
PendingIntent pendingIntent = PendingIntent.GetBroadcast(_context, 0, alarmIntent, PendingIntentFlags.UpdateCurrent);
AlarmManager alarmManager = (AlarmManager)_context.GetSystemService(Context.AlarmService);
alarmManager.SetRepeating(AlarmType.ElapsedRealtimeWakeup, interval, interval /*2 * 60 * 60*/, pendingIntent);
}
private void createNotification(string message, DateTime date)
{
PendingIntent pendingIntent;
AlarmManager manager = (AlarmManager)GetSystemService(Context.AlarmService);
Intent myIntent = new Intent(this, typeof(ReminderNotification));
//bundling
var valuesForActivity = new Bundle();
valuesForActivity.PutString("MESSAGE", message);
myIntent.PutExtras(valuesForActivity);
//convert
string dateString = $"{date.Month}/{date.Day}/{date.Year} {date.Hour}:{date.Minute}:{date.Second} {date.ToString("tt")}";
DateTimeOffset dateOffsetValue = DateTimeOffset.Parse(dateString);
var millisec = dateOffsetValue.ToUnixTimeMilliseconds();
if (Mode == "EDIT")
{
Log.Debug("set", "edit");
// cancel alarm
pendingIntent = PendingIntent.GetBroadcast(this, NotificationId, myIntent, 0);
manager.Cancel(pendingIntent);
// set new alarm
pendingIntent = PendingIntent.GetBroadcast(this, (int)millisec, myIntent, 0);
manager.SetRepeating(AlarmType.Rtc, millisec, AlarmManager.IntervalDay, pendingIntent);
ReminderHelper.UpdateRiwayatReminder(Id, (int)millisec, date, message, true);
}
else
{
Log.Debug("set", "add");
pendingIntent = PendingIntent.GetBroadcast(this, (int)millisec, myIntent, 0);
manager.SetRepeating(AlarmType.Rtc, millisec, AlarmManager.IntervalDay, pendingIntent);
ReminderHelper.SaveRiwayatReminder((int)millisec, date, message);
}
Log.Debug("set", "ok");
Finish();
}
// Runs on adding first instance of widget
public override void OnEnabled(Context context)
{
// Make intent with action to update all widgets
Intent intent = new Intent(context, typeof(ReittiWidget));
intent.SetAction(UpdateAllWidgets);
PendingIntent pIntent = PendingIntent.GetBroadcast(context, 0, intent, 0);
// Schedule intent every 3 minutes
AlarmManager alarmManager = (AlarmManager)context.GetSystemService(Context.AlarmService);
alarmManager.SetRepeating(AlarmType.Rtc, DateTime.Now.Millisecond, 180000, pIntent); //180000
}
public static void CheckAlarm(Context context)
{
var savedSettings = Application.Context.GetSharedPreferences("SavedSettings", FileCreationMode.Private);
var savedSettingsEdit = savedSettings.Edit();
int hour = savedSettings.GetInt("hour", 20);
int minute = savedSettings.GetInt("minute", 30);
bool alarmUp = (PendingIntent.GetBroadcast(context, 0,
new Intent(context, typeof(AlarmNotificationReceiver)),
PendingIntentFlags.NoCreate) != null);
bool alarmNeedsUpdate = savedSettings.GetBoolean("alarmNeedsUpdate", false);
AlarmManager manager = (AlarmManager)context.ApplicationContext.GetSystemService(Context.AlarmService);
Intent myIntent;
PendingIntent pendingIntent;
myIntent = new Intent(context, typeof(AlarmNotificationReceiver));
pendingIntent = PendingIntent.GetBroadcast(context, 0, myIntent, 0);
if (!alarmUp)
{
Java.Util.Calendar calendar = Java.Util.Calendar.Instance;
calendar.Set(Java.Util.CalendarField.HourOfDay, hour);
calendar.Set(Java.Util.CalendarField.Minute, minute);
manager.SetRepeating(AlarmType.RtcWakeup, calendar.TimeInMillis, AlarmManager.IntervalDay, pendingIntent);
}
if (alarmNeedsUpdate)
{
manager.Cancel(pendingIntent);
myIntent = new Intent(context, typeof(AlarmNotificationReceiver));
pendingIntent = PendingIntent.GetBroadcast(context, 0, myIntent, 0);
Java.Util.Calendar calendar = Java.Util.Calendar.Instance;
calendar.Set(Java.Util.CalendarField.HourOfDay, hour);
calendar.Set(Java.Util.CalendarField.Minute, minute);
manager.SetRepeating(AlarmType.RtcWakeup, calendar.TimeInMillis, AlarmManager.IntervalDay, pendingIntent);
savedSettingsEdit.PutBoolean("alarmNeedsUpdate", false);
savedSettingsEdit.Commit();
}
}
public override StartCommandResult OnStartCommand(Intent intent, StartCommandFlags flags, int startId)
{
AlarmManager am = (AlarmManager)GetSystemService(Context.AlarmService);
Intent alarmIntent;
PendingIntent alarmPendingIntent;
alarmIntent = new Intent(this, typeof(AlarmManagerOverRepeat));
alarmPendingIntent = PendingIntent.GetBroadcast(this, 0, alarmIntent, 0);
am.SetRepeating(AlarmType.RtcWakeup, SystemClock.ElapsedRealtime() + 10 * 1000, 60 * 1000, alarmPendingIntent);
// This tells Android to restart the service if it is killed to reclaim resources.
return(StartCommandResult.Sticky);
}
public void SetAlarm(Context context, int hh, int mm)
{
Intent intent = new Intent(context, this.Class);
PendingIntent pi = PendingIntent.GetBroadcast(context, 0, intent, 0);
Java.Util.Calendar calendar = Java.Util.Calendar.Instance;
calendar.Set(Java.Util.CalendarField.HourOfDay, hh);
calendar.Set(Java.Util.CalendarField.Minute, mm);
calendar.Set(Java.Util.CalendarField.Second, 0);
AlarmManager am = (AlarmManager)context.GetSystemService(Context.AlarmService);
am.SetRepeating(AlarmType.RtcWakeup, calendar.TimeInMillis, AlarmManager.IntervalDay, pi);
}
public void AgendaNotificacaoPeriodica(Periodo periodo, string titulo, string conteudo)
{
Intent alarmIntent = new Intent(Forms.Context, typeof(AlarmReceiver));
alarmIntent.PutExtra("titulo", titulo);
alarmIntent.PutExtra("mensagem", conteudo);
PendingIntent pendingIntent = PendingIntent.GetBroadcast(Forms.Context, 0, alarmIntent, PendingIntentFlags.UpdateCurrent);
AlarmManager alarmManager = (AlarmManager)Forms.Context.GetSystemService(Context.AlarmService);
long intervaloEmMilisegundos = Convert.ToInt64(periodo.ToMiliseconds());
var dataInicialEmMilisegundos = SystemClock.ElapsedRealtime() + intervaloEmMilisegundos;
alarmManager.SetRepeating(AlarmType.ElapsedRealtime, dataInicialEmMilisegundos, intervaloEmMilisegundos, pendingIntent);
}
public void SetAlarm()
{
//Java.Util.Calendar calendar = Java.Util.Calendar.Instance;
//calendar.Set(Java.Util.CalendarField.HourOfDay, 20);
//calendar.Set(Java.Util.CalendarField.Minute, 00);
//calendar.Set(Java.Util.CalendarField.Second, 0);
alarmIntent.PutExtra("title", "Título da Mensagem");
alarmIntent.PutExtra("message", "Mensagem");
alarmIntent.SetFlags(ActivityFlags.IncludeStoppedPackages);
var pendingIntent = PendingIntent.GetBroadcast(Forms.Context, 0, alarmIntent, PendingIntentFlags.UpdateCurrent);
//Envia a mensagem e repe a cada 1 minuto (60000)
alarmManager.SetRepeating(AlarmType.RtcWakeup, Java.Lang.JavaSystem.CurrentTimeMillis(), 60000, pendingIntent);
}
public override void OnStart(Intent intent, int startId)
{
var updateViews = new RemoteViews(this.PackageName, Resource.Layout.widget_main);
updateViews.SetTextViewText(Resource.Id.test, DateTime.Now.ToString());
ComponentName thisWidget = new ComponentName(this, Java.Lang.Class.FromType(typeof(SimpleWidget)).Name);
AppWidgetManager manager = AppWidgetManager.GetInstance(this);
manager.UpdateAppWidget(thisWidget, updateViews);
Intent alarmIntent = new Intent(this, typeof(RepeatingAlarm));
var source = PendingIntent.GetBroadcast(this, 0, alarmIntent, 0);
AlarmManager alarmManager = GetSystemService(AlarmService).JavaCast <AlarmManager>();
alarmManager.SetRepeating(AlarmType.ElapsedRealtimeWakeup, SystemClock.CurrentThreadTimeMillis(), 10000, source);
}
