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);
}
}
async Task <PermissionStatus> RequestEventPermission(EKEntityType eventType)
{
if (GetEventPermissionStatus(eventType) == PermissionStatus.Granted)
{
return(PermissionStatus.Granted);
}
eventStore = new EKEventStore();
var results = await eventStore.RequestAccessAsync(eventType).ConfigureAwait(false);
return(results.Item1 ? PermissionStatus.Granted : PermissionStatus.Denied);
}
public async Task <bool> AddAppointment(MyAppointmentType appointment)
{
var eventStore = new EKEventStore();
var granted = await eventStore.RequestAccessAsync(EKEntityType.Event);
if (granted.Item1)
{
EKEvent newEvent = EKEvent.FromStore(eventStore);
newEvent.StartDate = DateTimeToNSDate(appointment.ExpireDate);
newEvent.EndDate = DateTimeToNSDate(appointment.ExpireDate.AddHours(1));
newEvent.Title = appointment.Title; newEvent.Notes = appointment.WhereWhen;
newEvent.Calendar = eventStore.DefaultCalendarForNewEvents;
return(eventStore.SaveEvent(newEvent, EKSpan.ThisEvent, out NSError e));
}
return(false);
}
private async Task RequestCalendarAccess()
{
if (EKEventStore.GetAuthorizationStatus(EKEntityType.Event) != EKAuthorizationStatus.Authorized)
{
var accessResult = await _eventStore.RequestAccessAsync(EKEntityType.Event).ConfigureAwait(false);
bool hasAccess = accessResult.Item1;
NSError error = accessResult.Item2;
if (!hasAccess)
{
// This is the same exception WinPhone would throw
throw new UnauthorizedAccessException("Calendar access denied", error != null ? new NSErrorException(error) : null);
}
}
}
private async Task <bool> RequestCalendarAccess()
{
if (!_hasCalendarAccess.HasValue)
{
var accessResult = await _eventStore.RequestAccessAsync(EKEntityType.Event).ConfigureAwait(false);
NSError error = null;
#if __UNIFIED__
_hasCalendarAccess = accessResult.Item1;
error = accessResult.Item2;
#else
_hasCalendarAccess = accessResult;
#endif
if (!_hasCalendarAccess.Value)
{
// This is the same exception WinPhone would throw
throw new UnauthorizedAccessException("Calendar access denied", error != null ? new NSErrorException(error) : null);
}
}
return(_hasCalendarAccess.Value);
}
