public void Range()
{
TestRuntime.AssertSystemVersion(ApplePlatform.MacOSX, 10, 9, throwIfOtherPlatform: false);
#if NET
using var store = new EKEventStore();
using (var rem = EKReminder.Create(store)) {
#else
using (var rem = new EKReminder()) {
#endif
// priority is documented to have a range of 0-9 but there's no validation in ObjC
// this test is here to ensure Apple does not start throwing native exceptions at some points
rem.Priority = -1;
Assert.That(rem.Priority, Is.EqualTo((nint)(-1)), "-1");
rem.Priority = 10;
Assert.That(rem.Priority, Is.EqualTo((nint)10), "10");
// The following tests fail randomly.
// // at some point values are ?normalized? but no exception is thrown
// rem.Priority = nint.MinValue;
// Assert.That (rem.Priority, Is.EqualTo ((nint) 0), "MinValue");
// // exposed as an NSInteger but internal storage looks different
// rem.Priority = nint.MaxValue;
// Assert.That (rem.Priority, Is.EqualTo ((nint) (-1)), "MaxValue");
}
}
}
/// <summary>
/// Creates and saves a reminder to the default reminder calendar
/// </summary>
protected void CreateReminder()
{
// create a reminder using the EKReminder.Create method
EKReminder reminder = EKReminder.Create(App.Current.EventStore);
reminder.Title = "Do something awesome!";
reminder.Calendar = App.Current.EventStore.DefaultCalendarForNewReminders;
// save the reminder
NSError e;
App.Current.EventStore.SaveReminder(reminder, true, out e);
// if there was an error, show it
if (e != null)
{
new UIAlertView("err saving reminder", e.ToString(), null, "ok", null).Show();
return;
}
else
{
new UIAlertView("reminder saved", "ID: " + reminder.CalendarItemIdentifier, null, "ok", null).Show();
// to retrieve the reminder you can call GetCalendarItem
EKCalendarItem myReminder = App.Current.EventStore.GetCalendarItem(reminder.CalendarItemIdentifier);
Console.WriteLine("Retrieved Saved Reminder: " + myReminder.Title);
// to delete, note that once you remove the event, the reference will be null, so
// if you try to access it you'll get a null reference error.
App.Current.EventStore.RemoveReminder(myReminder as EKReminder, true, out e);
Console.WriteLine("Reminder Deleted.");
}
}
/*public void SaveEvent()
* {
* EKEvent newEvent = EKEvent.FromStore(eventStore);
* // set the alarm for 5 minutes from now
* newEvent.AddAlarm(EKAlarm.FromDate((NSDate)DateTime.Now.AddMinutes(1)));
* // make the event start 10 minutes from now and last 30 minutes
* newEvent.StartDate = (NSDate)DateTime.Now.AddMinutes(4);
* newEvent.EndDate = (NSDate)DateTime.Now.AddMinutes(8);
* newEvent.Title = "Appt. to do something Awesome!";
* newEvent.Notes = "Find a boulder, climb it. Find a river, swim it. Find an ocean, dive it.";
* newEvent.Calendar = eventStore.DefaultCalendarForNewEvents;
*
* // save the event
* NSError e;
* eventStore.SaveEvent(newEvent, EKSpan.ThisEvent, out e);
* if (e != null)
* {
* new UIAlertView("Err Saving Event", e.ToString(), null, "ok", null).Show();
* return;
* }
* else
* {
* new UIAlertView("Event Saved", "Event ID: " + newEvent.EventIdentifier, null, "ok", null).Show();
* Console.WriteLine("Event Saved, ID: " + newEvent.EventIdentifier);
* }
*
* // to retrieve the event you can call
* EKEvent mySavedEvent = eventStore.EventFromIdentifier(newEvent.EventIdentifier);
* Console.WriteLine("Retrieved Saved Event: " + mySavedEvent.Title);
* /-*
* // to delete, note that once you remove the event, the reference will be null, so
* // if you try to access it you'll get a null reference error.
* eventStore.RemoveEvent(mySavedEvent, EKSpan.ThisEvent, true, out e);
* Console.WriteLine("Event Deleted.");*-/
*
* }*/
public void CreateReminder()
{
EKReminder reminder = EKReminder.Create(eventStore);
reminder.Title = "first reminder";
reminder.Calendar = eventStore.DefaultCalendarForNewReminders;
NSError e;
eventStore.SaveReminder(reminder, true, out e);
if (e != null)
{
new UIAlertView("err saving reminder", e.ToString(), null, "ok", null).Show();
return;
}
else
{
new UIAlertView("reminder saved", "ID: " + reminder.CalendarItemIdentifier, null, "ok", null).Show();
}
/*
* //to retrieve the reminders
* EKCalendarItem myReminder = eventStore.GetCalendarItem(reminder.CalendarItemIdentifier);
* Console.WriteLine("Retrieved Saved Reminder: " + myReminder.Title);
*
* //to delete the reminders
* eventStore.RemoveReminder(myReminder as EKReminder, true, out e);
* Console.WriteLine("Reminder Deleted.");*/
}
public void SetReminder(string title)
{
EventKitUI.EKEventEditViewController eventController = new EventKitUI.EKEventEditViewController();
eventStore = new EKEventStore();
eventStore.RequestAccess(EKEntityType.Reminder,
(bool granted, NSError i) =>
{
if (granted)
{
accessGranted = true;
}
else
{
accessGranted = false;
}
});
eventController.EventStore = eventStore;
EKReminder reminder = EKReminder.Create(eventController.EventStore);
reminder.Title = title;
reminder.Calendar = eventController.EventStore.DefaultCalendarForNewReminders;
// save the reminder
NSError e;
eventController.EventStore.SaveReminder(reminder, true, out e);
}
/// <summary>
/// Creates and saves a reminder to the default reminder calendar
/// </summary>
private void CreateReminder()
{
// create a reminder using the EKReminder.Create method
var reminder = EKReminder.Create(EventStore);
reminder.Title = "Do something awesome!";
reminder.Calendar = EventStore.DefaultCalendarForNewReminders;
// save the reminder
EventStore.SaveReminder(reminder, true, out NSError error);
// if there was an error, show it
if (error != null)
{
var alert = UIAlertController.Create("Error", error.ToString(), UIAlertControllerStyle.Alert);
alert.AddAction(UIAlertAction.Create("OK", UIAlertActionStyle.Default, null));
base.PresentViewController(alert, true, null);
}
else
{
var alert = UIAlertController.Create("Reminder saved", $"ID: {reminder.CalendarItemIdentifier}", UIAlertControllerStyle.Alert);
alert.AddAction(UIAlertAction.Create("OK", UIAlertActionStyle.Default, null));
base.PresentViewController(alert, true, null);
// to retrieve the reminder you can call GetCalendarItem
var myReminder = EventStore.GetCalendarItem(reminder.CalendarItemIdentifier);
Console.WriteLine($"Retrieved Saved Reminder: {myReminder.Title}");
// TODO: you can uncomment it to see how does removal work
// to delete, note that once you remove the event, the reference will be null, so
// if you try to access it you'll get a null reference error.
//EventStore.RemoveReminder(myReminder as EKReminder, true, out error);
//Console.WriteLine("Reminder Deleted.");
}
}
public void NullableProperties()
{
using (var rem = new EKReminder()) {
rem.StartDateComponents = null;
rem.DueDateComponents = null;
rem.CompletionDate = null;
}
}
void Start()
{
if (CoreXT.IsDevice)
{
//eventStore, calender, etc will be null if Init() is not called. Manually initilizing helps save memory and must be done before using.
PersonalXT.Init();
manager = new CLLocationManager();
//response for calling PersonalXT.RequestCalendarAccess();
//optional handler if you want to add custom messages to the user
PersonalXT.CalendarAccess += delegate(object sender, GrantedEventArgs e) {
Log("Calendar grant access: " + e.granted);
};
//if reminder is granted access, then add reminder as well as retrieve location data
PersonalXT.ReminderAccess += delegate(object sender, GrantedEventArgs e) {
Log("Reminder grant access: " + e.granted);
if (e.granted)
{
manager.StartUpdatingLocation(); //will update delagate function manager.DidUpdateLocations
}
};
//removing reminders after it is found. or you can do whatever else with it.
PersonalXT.RemindersFound += delegate(object sender, ReminderArgs e) {
foreach (EKReminder obj in e.objList)
{
PersonalXT.eventStore.RemoveReminder(obj, true, null);
}
Log("Reminders Removed");
};
//alternate way to do call back functions instead of using delegate file (see example PeoplePickerNavigationControllerDelegate.cs)
manager.DidUpdateLocations += delegate(object sender, CLLocationManager.DidUpdateLocationsEventArgs e){
manager.StopUpdatingLocation();
EKStructuredLocation location = new EKStructuredLocation();
location.title = "Current location";
location.geoLocation = e.locations[e.locations.Length - 1] as CLLocation;
EKReminder reminder = EKReminder.Reminder(PersonalXT.eventStore);
reminder.title = "Buy U3DXT at coordinates: " + location.geoLocation.coordinate;
reminder.calendar = PersonalXT.eventStore.defaultCalendarForNewReminders;
NSError error = null;
PersonalXT.eventStore.SaveReminder(reminder, true, error);
if (error != null)
{
Log("error: " + error);
}
Log("current location coordinates: " + location.geoLocation.coordinate);
};
manager.desiredAccuracy = CLLocation.kCLLocationAccuracyNearestTenMeters;
manager.distanceFilter = 1;
}
}
public void NullableProperties()
{
#if NET
using var store = new EKEventStore();
using (var rem = EKReminder.Create(store)) {
#else
using (var rem = new EKReminder()) {
#endif
rem.StartDateComponents = null;
rem.DueDateComponents = null;
rem.CompletionDate = null;
}
}
public void DefaultProperties()
{
using (var rem = new EKReminder()) {
Assert.AreEqual(0, rem.Priority, "Priority");
Assert.IsFalse(rem.Completed, "Completed");
Assert.IsNull(rem.CompletionDate, "CompletionDate");
Assert.IsNull(rem.StartDateComponents, "StartDateComponents");
Assert.IsNull(rem.DueDateComponents, "DueDateComponents");
rem.Completed = true;
Assert.IsTrue(rem.Completed, "Completed - Changed");
}
}
public void AddReminder(String title, String message, DateTime RemindTime)
{
// create a new reminder and set its title and message
EKReminder reminder = EKReminder.Create(eventStore);
reminder.Title = title;
reminder.Notes = message;
// adding the remind time to the reminder as its due date and alarm time
// an alarm time
EKAlarm timeToRing = new EKAlarm();
NSDate nsDate = (NSDate)DateTime.SpecifyKind(RemindTime, DateTimeKind.Utc);
timeToRing.AbsoluteDate = nsDate;
reminder.AddAlarm(timeToRing);
// date components required to add to the reminder
NSDateComponents dueDate = new NSDateComponents();
dueDate.Calendar = new NSCalendar(NSCalendarType.Gregorian);
// all of these value need to be applied induvidualy - although in xcode there is a way to apply them at once
dueDate.Year = RemindTime.Year;
dueDate.Month = RemindTime.Month;
dueDate.Day = RemindTime.Day;
dueDate.Hour = RemindTime.Hour;
dueDate.Minute = RemindTime.Minute;
dueDate.Second = RemindTime.Second;
if (dueDate.IsValidDate)
{
// well that seems to be a valid date component so lets set the start and due date to it
reminder.StartDateComponents = dueDate;
reminder.DueDateComponents = dueDate;
}
// and finnaly lets save it to the phone's calendar - 1st create an error too record to then set the calendar to save to then save to it
NSError e;
reminder.Calendar = eventStore.DefaultCalendarForNewReminders;
eventStore.SaveReminder(reminder, true, out e);
// alert user if the reminder could not be added
if (e != null)
{
UIAlertController.Create("Failed to add reminder", e.ToString(), UIAlertControllerStyle.Alert);
}
}
public void Add(int actionResult, DateTime inputDStart, DateTime inputDEnd, string inputTitle, string inputLocation)
{
App.Current.EventStore.RequestAccess(EKEntityType.Event,
(bool granted, NSError e) => {
if (granted)
{
EKEvent newEvent = EKEvent.FromStore(App.Current.EventStore);
// make the event start 20 minutes from now and last 30 minutes
newEvent.StartDate = DateTimeToNSDate(inputDStart);
newEvent.EndDate = DateTimeToNSDate(inputDEnd);
newEvent.Title = inputTitle;
newEvent.Location = inputLocation;
EKReminder reminder = EKReminder.Create(App.Current.EventStore);
reminder.Title = "Do something awesome!";
reminder.Calendar = App.Current.EventStore.DefaultCalendarForNewReminders;
if (actionResult == 0)
{
newEvent.Calendar = App.Current.EventStore.DefaultCalendarForNewEvents;
App.Current.EventStore.SaveEvent(newEvent, EKSpan.ThisEvent, out e);
}
else if (actionResult == 1)
{
NSError ee;
App.Current.EventStore.SaveReminder(reminder, true, out ee);
}
else if (actionResult == 2)
{
newEvent.Calendar = App.Current.EventStore.DefaultCalendarForNewEvents;
App.Current.EventStore.SaveEvent(newEvent, EKSpan.ThisEvent, out e);
}
this.InvokeOnMainThread(() => {
var av = new UIAlertView("QR Code Scan Results:", "Successfully Added event!", null, "ok", null);
av.Show();
});
}
else
{
this.InvokeOnMainThread(() => {
var av = new UIAlertView("Access Denied", "User Denied Access to Calendar Data", null, "ok", null);
av.Show();
});
}
});
}
public void DefaultProperties()
{
#if NET
using var store = new EKEventStore();
using (var rem = EKReminder.Create(store)) {
#else
using (var rem = new EKReminder()) {
#endif
Assert.AreEqual(0, rem.Priority, "Priority");
Assert.IsFalse(rem.Completed, "Completed");
Assert.IsNull(rem.CompletionDate, "CompletionDate");
Assert.IsNull(rem.StartDateComponents, "StartDateComponents");
Assert.IsNull(rem.DueDateComponents, "DueDateComponents");
rem.Completed = true;
Assert.IsTrue(rem.Completed, "Completed - Changed");
}
}
public void Range()
{
using (var rem = new EKReminder()) {
// priority is documented to have a range of 0-9 but there's no validation in ObjC
// this test is here to ensure Apple does not start throwing native exceptions at some points
rem.Priority = -1;
Assert.That(rem.Priority, Is.EqualTo((nint)(-1)), "-1");
rem.Priority = 10;
Assert.That(rem.Priority, Is.EqualTo((nint)10), "10");
// The following tests fail randomly.
// // at some point values are ?normalized? but no exception is thrown
// rem.Priority = nint.MinValue;
// Assert.That (rem.Priority, Is.EqualTo ((nint) 0), "MinValue");
// // exposed as an NSInteger but internal storage looks different
// rem.Priority = nint.MaxValue;
// Assert.That (rem.Priority, Is.EqualTo ((nint) (-1)), "MaxValue");
}
}
public void Predicates()
{
if (Runtime.Arch == Arch.DEVICE)
{
Assert.Inconclusive("defaults are different on devices");
}
var store = new EKEventStore(EKEntityMask.Reminder);
var rem = EKReminder.Create(store);
rem.Calendar = store.DefaultCalendarForNewReminders;
NSError error;
Assert.IsTrue(store.SaveReminder(rem, true, out error), "SaveReminder");
var predicate = store.PredicateForIncompleteReminders(null, null, new [] { rem.Calendar });
var mre = new ManualResetEvent(false);
bool found = false;
store.FetchReminders(predicate, l => {
found = l.Any(ll => ll.ClassHandle == rem.ClassHandle);
mre.Set();
});
Assert.IsTrue(mre.WaitOne(3000), "#1");
Assert.IsTrue(found, "#2");
mre.Reset();
predicate = store.PredicateForReminders(null);
store.FetchReminders(predicate, l => mre.Set());
Assert.IsTrue(mre.WaitOne(3000), "#10");
mre.Reset();
predicate = store.PredicateForCompleteReminders(null, null, null);
store.FetchReminders(predicate, l => mre.Set());
Assert.IsTrue(mre.WaitOne(3000), "#20");
Assert.IsTrue(store.RemoveReminder(rem, true, out error), "RemoveReminder");
}
public async Task AddReminder(string title, string notes, DateTime date)
{
try
{
var result = await _eventStore.RequestAccessAsync(EKEntityType.Reminder);
if (result.Item1)
{
EKReminder reminder = null;
var predicat = _eventStore.PredicateForReminders(null);
var reminders = await _eventStore.FetchRemindersAsync(predicat);
reminder = reminders.Where((EKReminder arg) => !arg.Completed && arg.Title == title).FirstOrDefault();
if (reminder == null)
{
reminder = EKReminder.Create(_eventStore);
}
reminder.Title = title;
EKAlarm timeToRing = new EKAlarm();
timeToRing.AbsoluteDate = ConvertDateTimeToNSDate(date);
reminder.AddAlarm(timeToRing);
reminder.Calendar = _eventStore.DefaultCalendarForNewReminders;
reminder.Notes = notes;
NSError error;
_eventStore.SaveReminder(reminder, true, out error);
if (error != null)
{
Debug.WriteLine(error.Description);
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
public ToDoItem(EKReminder reminder)
{
Completed = reminder.Completed;
Text = reminder.Title;
identifier = reminder.UUID;
}
public async void AddEventToCalender(object sender, EventArgs e)
{
try
{
var store = new EKEventStore();
if (EKEventStore.GetAuthorizationStatus(EKEntityType.Reminder) == EKAuthorizationStatus.Authorized)
{
if (EKEventStore.GetAuthorizationStatus(EKEntityType.Event) == EKAuthorizationStatus.Authorized)
{
NSDate startDate = ConvertDateTimeToNSDate(BaseFunctions.GetDateTimeFull(App.reminderEvent.eventStartDate + " " + App.reminderEvent.eventStartTime));
NSDate endDate = ConvertDateTimeToNSDate(BaseFunctions.GetDateTimeFull(App.reminderEvent.eventEndDate + " " + App.reminderEvent.eventEndTime));
NSPredicate query = store.PredicateForEvents(startDate, endDate, null);
EKCalendarItem[] events = store.EventsMatching(query);
bool exists = false;
for (int i = 0; i < events.Length; i++)
{
if (events[i].Title == App.reminderEvent.eventName)
{
exists = true;
}
}
if (!exists)
{
EKEvent eEvent = EKEvent.FromStore(store);
eEvent.AddAlarm(EKAlarm.FromDate(ConvertDateTimeToNSDate(BaseFunctions.GetDateTimeFull(App.reminderEvent.eventStartDate + " " + App.reminderEvent.eventStartTime))));
eEvent.StartDate = startDate;
eEvent.EndDate = endDate;
eEvent.Title = App.reminderEvent.eventName;
eEvent.TimeZone = new NSTimeZone("UTC");
eEvent.Location = App.reminderEvent.eventAddress;
eEvent.Notes = App.reminderEvent.eventDescription;
eEvent.Calendar = store.DefaultCalendarForNewEvents;
NSError eventError;
store.SaveEvent(eEvent, EKSpan.ThisEvent, out eventError);
EKReminder reminder = EKReminder.Create(store);
reminder.Title = App.reminderEvent.eventName;
reminder.AddAlarm(EKAlarm.FromDate(ConvertDateTimeToNSDate(BaseFunctions.GetDateTimeFull(App.reminderEvent.eventStartDate + " " + App.reminderEvent.eventStartTime))));
reminder.TimeZone = new NSTimeZone("UTC");
reminder.Calendar = store.DefaultCalendarForNewEvents;
await App.Current.MainPage.DisplayAlert("Alert", "This event is added to your calender", "Ok");
}
else
{
await App.Current.MainPage.DisplayAlert("Alert", "This event is already added to your calender", "Ok");
}
}
else
{
store.RequestAccess(EKEntityType.Event, StoreAcceptRequest);
}
}
else
{
store.RequestAccess(EKEntityType.Reminder, StoreAcceptRequest);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
}
