void FireEventPermissionCompletionHandler(ClusterEventAuthorizationType eventType)
{
EKAuthorizationStatus status = EKEventStore.GetAuthorizationStatus(EKEquivalentEventType(eventType));
if (_eventPermissionCompletionHandler != null)
{
ClusterDialogResult userDialogResult = ClusterDialogResult.Granted;
ClusterDialogResult systemDialogResult = ClusterDialogResult.Granted;
if (status == EKAuthorizationStatus.NotDetermined)
{
userDialogResult = ClusterDialogResult.Denied;
systemDialogResult = ClusterDialogResult.NoActionTaken;
}
else if (status == EKAuthorizationStatus.Authorized)
{
userDialogResult = ClusterDialogResult.Granted;
systemDialogResult = ClusterDialogResult.Granted;
}
else if (status == EKAuthorizationStatus.Denied)
{
userDialogResult = ClusterDialogResult.Granted;
systemDialogResult = ClusterDialogResult.Denied;
}
else if (status == EKAuthorizationStatus.Restricted)
{
userDialogResult = ClusterDialogResult.Granted;
systemDialogResult = ClusterDialogResult.ParentallyRestricted;
}
_eventPermissionCompletionHandler((status == EKAuthorizationStatus.Authorized),
userDialogResult,
systemDialogResult);
_eventPermissionCompletionHandler = null;
}
}
public static void RequestEventStorePermission(EKEntityType entityType, bool assert_granted = false)
{
TestRuntime.AssertMacSystemVersion(10, 9, throwIfOtherPlatform: false);
var status = EKEventStore.GetAuthorizationStatus(entityType);
Console.WriteLine("EKEventStore.GetAuthorizationStatus ({1}): {0}", status, entityType);
switch (status)
{
case EKAuthorizationStatus.Authorized:
case EKAuthorizationStatus.Restricted:
return;
case EKAuthorizationStatus.NotDetermined:
// There's an instance method on EKEventStore to request permission,
// but creating the instance can end up blocking the app showing a permission dialog...
// (on Mavericks at least)
if (TestRuntime.CheckMacSystemVersion(10, 10))
{
return; // Crossing fingers that this won't hang.
}
NUnit.Framework.Assert.Ignore("This test requires permission to access events, but there's no API to request access without potentially showing dialogs.");
break;
case EKAuthorizationStatus.Denied:
if (assert_granted)
{
NUnit.Framework.Assert.Ignore("This test requires permission to access events.");
}
break;
}
}
internal static PermissionStatus CheckPermissionStatus(EKEntityType entityType)
{
var status = EKEventStore.GetAuthorizationStatus(entityType);
return(status switch
{
EKAuthorizationStatus.Authorized => PermissionStatus.Granted,
EKAuthorizationStatus.Denied => PermissionStatus.Denied,
EKAuthorizationStatus.Restricted => PermissionStatus.Restricted,
_ => PermissionStatus.Unknown,
});
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);
}
}
}
PermissionStatus GetEventPermissionStatus(EKEntityType eventType)
{
var status = EKEventStore.GetAuthorizationStatus(eventType);
switch (status)
{
case EKAuthorizationStatus.Authorized:
return(PermissionStatus.Granted);
case EKAuthorizationStatus.Denied:
return(PermissionStatus.Denied);
case EKAuthorizationStatus.Restricted:
return(PermissionStatus.Restricted);
default:
return(PermissionStatus.Unknown);
}
}
public ClusterAuthorizationStatus EventPermissionAuthorizationStatus(ClusterEventAuthorizationType eventType)
{
var status = EKEventStore.GetAuthorizationStatus(ClusterPrePermissions.SharedPermissions.EKEquivalentEventType(eventType));
switch (status)
{
case EKAuthorizationStatus.Authorized:
return(ClusterAuthorizationStatus.Authorized);
case EKAuthorizationStatus.Denied:
return(ClusterAuthorizationStatus.Denied);
case EKAuthorizationStatus.Restricted:
return(ClusterAuthorizationStatus.Restricted);
default:
return(ClusterAuthorizationStatus.UnDetermined);
}
}
public void ShowEventPermissionsWithType(ClusterEventAuthorizationType eventType, string requestTitle, string message, string denyButtonTitle, string grantButtonTitle, ClusterPrePermissionCompletionHandler completionHandler)
{
if (requestTitle.Length == 0)
{
switch (eventType)
{
case ClusterEventAuthorizationType.Event:
requestTitle = @"Access Calendar?";
break;
default:
requestTitle = @"Access Reminders?";
break;
}
}
denyButtonTitle = GetTitleForType(ClusterTitleType.Deny, denyButtonTitle);
grantButtonTitle = GetTitleForType(ClusterTitleType.Request, grantButtonTitle);
var status = EKEventStore.GetAuthorizationStatus(EKEquivalentEventType(eventType));
if (status == EKAuthorizationStatus.NotDetermined)
{
_eventPermissionCompletionHandler = completionHandler;
_preEventPermissionAlertView = new UIAlertView(requestTitle, message, new AlertViewDelegate(this), denyButtonTitle, grantButtonTitle);
_preEventPermissionAlertView.Tag = (nint)(int)eventType;
_preEventPermissionAlertView.Show();
}
else
{
if (completionHandler != null)
{
completionHandler((status == EKAuthorizationStatus.Authorized),
ClusterDialogResult.NoActionTaken,
ClusterDialogResult.NoActionTaken);
}
}
}
public void CheckEventStoreAccess(EKEntityType type)
{
EKAuthorizationStatus status = EKEventStore.GetAuthorizationStatus(type);
DataClass dc = type == EKEntityType.Event ? DataClass.Calendars : DataClass.Reminders;
switch (status)
{
case EKAuthorizationStatus.NotDetermined:
ShowAlert(dc, "not determined");
break;
case EKAuthorizationStatus.Restricted:
ShowAlert(dc, "restricted");
break;
case EKAuthorizationStatus.Denied:
ShowAlert(dc, "denied");
break;
case EKAuthorizationStatus.Authorized:
ShowAlert(dc, "granted");
break;
}
}
string CheckEventStoreAccess(EKEntityType type)
{
return(EKEventStore.GetAuthorizationStatus(type).ToString());
}
protected override string CheckAccess()
{
return(EKEventStore.GetAuthorizationStatus(type).ToString());
}
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());
}
}
public string CheckAccess()
{
return(EKEventStore.GetAuthorizationStatus(type).ToString());
}
