/// <summary>
/// Creates a new calendar or updates the name and color of an existing one.
/// </summary>
/// <param name="calendar">The calendar to create/update</param>
/// <exception cref="System.ArgumentException">Calendar does not exist on device or is read-only</exception>
/// <exception cref="System.UnauthorizedAccessException">Calendar access denied</exception>
/// <exception cref="Calendars.Plugin.Abstractions.PlatformException">Unexpected platform-specific error</exception>
public async Task AddOrUpdateCalendarAsync(Calendar calendar)
{
await RequestCalendarAccess().ConfigureAwait(false);
EKCalendar deviceCalendar = null;
if (!string.IsNullOrEmpty(calendar.ExternalID))
{
deviceCalendar = _eventStore.GetCalendar(calendar.ExternalID);
if (deviceCalendar == null)
{
throw new ArgumentException("Specified calendar does not exist on device", "calendar");
}
}
if (deviceCalendar == null)
{
deviceCalendar = CreateEKCalendar(calendar.Name, calendar.Color);
calendar.ExternalID = deviceCalendar.CalendarIdentifier;
// Update color in case iOS assigned one
if (deviceCalendar?.CGColor != null)
{
calendar.Color = ColorConversion.ToHexColor(deviceCalendar.CGColor);
}
}
else
{
deviceCalendar.Title = calendar.Name;
if (!string.IsNullOrEmpty(calendar.Color))
{
deviceCalendar.CGColor = ColorConversion.ToCGColor(calendar.Color);
}
NSError error = null;
if (!_eventStore.SaveCalendar(deviceCalendar, true, out error))
{
// Without this, the eventStore will continue to return the "updated"
// calendar even though the save failed!
// (this obviously also resets any other changes, but since we own the eventStore
// we can be pretty confident that won't be an issue)
//
_eventStore.Reset();
if (error.Domain == _ekErrorDomain && error.Code == (int)EKErrorCode.CalendarIsImmutable)
{
throw new ArgumentException(error.LocalizedDescription, new NSErrorException(error));
}
else
{
throw new PlatformException(error.LocalizedDescription, new NSErrorException(error));
}
}
}
}
/// <summary>
/// _removes the reminders.
/// </summary>
/// <param name="objList">Object list.</param>
private static void _removeReminders(object[] objList)
{
EKReminder currentReminder;
foreach (object obj in objList)
{
currentReminder = obj as EKReminder;
eventStore.RemoveReminder(currentReminder, true, null);
}
eventStore.SaveCalendar(calendar, true, null);
}
public async Task <bool> CreateCalendarForAppAlarmsAsync()
{
bool hasPermission = await ASkForPermissionsAsync();
if (hasPermission && appCalendar == null)
{
appCalendar = EKCalendar.Create(EKEntityType.Event, eventsStore);
appCalendar.Title = "My App Calendar";
appCalendar.Source = eventsStore.Sources.Where(s => s.SourceType == EKSourceType.CalDav).FirstOrDefault();
appCalendar.CGColor = UIColor.Purple.CGColor;
bool saved = eventsStore.SaveCalendar(appCalendar, true, out NSError e);
return(saved);
}
return(true);
}
public async Task PushMeetingsToCalendarAsync(List <Meeting> meetings)
{
try
{
using (await _PushMeetingsToCalendarAsyncLock.LockAsync())
{
if (!(await _eventStore.RequestAccessAsync(EKEntityType.Event)).Item1)
{
return;
}
var calendar = _eventStore.GetCalendar(AcraCalendarIdentifier);
CGColor colorToUse = null;
if (calendar != null)
{
colorToUse = calendar.CGColor;
NSError errorToDelete;;
_eventStore.RemoveCalendar(calendar, true, out errorToDelete);
}
var otherToDelete = _eventStore.GetCalendars(EKEntityType.Event).Where(c => c.Title.StartsWith("ACRA"));
foreach (var item in otherToDelete)
{
NSError errorToDelete;
_eventStore.RemoveCalendar(item, true, out errorToDelete);
}
// now recreate a calendar !
calendar = EKCalendar.FromEventStore(_eventStore);
calendar.Title = "ACRA du " + DateTime.Now.ToString("g", new System.Globalization.CultureInfo("fr"));
if (colorToUse != null)
{
calendar.CGColor = colorToUse;
}
EKSource[] sources = _eventStore.Sources;
var sourceToSet = sources
.FirstOrDefault(s => s.SourceType == EKSourceType.CalDav && s.Title.Equals("iCloud", StringComparison.InvariantCultureIgnoreCase));
if (sourceToSet == null)
{
sourceToSet = sources.FirstOrDefault(s => s.SourceType == EKSourceType.Local);
}
if (sourceToSet == null)
{
sourceToSet = _eventStore.DefaultCalendarForNewEvents.Source;
}
calendar.Source = sourceToSet;
NSError error;
_eventStore.SaveCalendar(calendar, true, out error);
AcraCalendarIdentifier = calendar.CalendarIdentifier;
var toSaves = meetings.OrderByDescending(ap => ap.StartDate).ToArray();
var howMuch = toSaves.Length;
for (int index = 0; index < howMuch; index++)
{
var appointData = toSaves[index];
var toSave = EKEvent.FromStore(_eventStore);
//if (!string.IsNullOrEmpty(appointData.))
//{
// toSave.Location = appointData.Location;
//}
toSave.StartDate = ConvertDateTimeToNSDate(appointData.StartDate);
toSave.AllDay = appointData.AllDayEvent;
if (appointData.IsRecurrent && appointData.AllDayEvent)
{
var end = EKRecurrenceEnd.FromEndDate(ConvertDateTimeToNSDate(appointData.EndDate));
var rule = new EKRecurrenceRule(EKRecurrenceFrequency.Weekly, 1, end);
toSave.RecurrenceRules = new[] { rule };
}
else
{
toSave.EndDate = ConvertDateTimeToNSDate(appointData.EndDate);
}
// If set to AllDay and given an EndDate of 12am the next day, EventKit
// assumes that the event consumes two full days.
// (whereas WinPhone/Android consider that one day, and thus so do we)
//
if (appointData.AllDayEvent)
{
toSave.EndDate = ConvertDateTimeToNSDate(appointData.EndDate.AddDays(-1));
}
if (!appointData.IsHoliday)
{
if (appointData.Duration.TotalDays > 1 && !appointData.IsRecurrent)
{
toSave.Title = ((int)appointData.Duration.TotalDays + 1) + " " + appointData.Title;
}
else
{
toSave.Title = appointData.Title;
}
}
else
{
//TODO : localisation
toSave.Title = "[FERIE] " + appointData.Title;
}
toSave.Notes = appointData.Type.ToString();
toSave.Calendar = calendar;
NSError errorCommit;
_eventStore.SaveEvent(toSave, EKSpan.ThisEvent, out errorCommit);
}
}
NSError errorEvent;
_eventStore.Commit(out errorEvent);
}
catch (Exception e)
{
//TODO : localisation
await App.Instance.AlertService.ShowExceptionMessageAsync(e, "Impossible de renseigner votre calendrier iOS");
}
}
