EventKitu v Xamarin. iOSEventKit in Xamarin.iOS

systém iOS má vestavěnou dvě aplikace související s kalendáři: aplikace kalendáře a aplikace s připomenutími.iOS has two calendar-related applications built-in: the Calendar Application, and the Reminders Application. Je dostatečně jasné, abyste pochopili, jak aplikace kalendáře spravuje data kalendáře, ale aplikace s připomenutími není méně zřejmá.It’s straightforward enough to understand how the Calendar Application manages calendar data, but the Reminders Application is less obvious. K připomenutím můžou být ve skutečnosti přidružená data z hlediska jejich splnění, pokud jsou dokončená atd. V takovém případě iOS ukládá všechna data kalendáře, ať už jde o události v kalendáři nebo připomenutí, v jednom umístění, které se nazývá databáze kalendáře.Reminders can actually have dates associated with them in terms of when they’re due, when they’re completed, etc. As such, iOS stores all calendar data, whether it be calendar events or reminders, in one location, called the Calendar Database.

EventKitu Framework poskytuje způsob, jak získat přístup k kalendářům, událostem kalendářea datům připomenutí , které ukládá kalendář databáze.The EventKit framework provides a way to access the Calendars, Calendar Events, and Reminders data that Calendar Database stores. Přístup k kalendářům a událostem kalendáře byl k dispozici od verze iOS 4, ale přístup k připomenutím je v systému iOS 6 novinkou.Access to the calendars and calendar events has been available since iOS 4, but access to reminders is new in iOS 6.

V této příručce se pokryje:In this guide we’re going to cover:

  • Základy EventKitu – to přináší základní části EventKitu prostřednictvím hlavních tříd a poskytuje porozumění jejich využití.EventKit Basics – This will introduce the fundamental pieces of EventKit via the major classes and provides an understanding of their usage. Tato část je povinná pro čtení, než se pustíte do další části dokumentu.This section is required reading before tackling the next part of the document.
  • Běžné úlohy – část běžné úlohy je určena jako rychlá referenční příručka, jak provádět běžné věci, jako je například; vytváření výčtu kalendářů, vytváření, ukládání a načítání událostí a připomenutí kalendáře a používání integrovaných řadičů pro vytváření a úpravu událostí kalendáře.Common Tasks – The common tasks section is intended to be a quick reference on how to do common things such as; enumerating calendars, creating, saving and retrieving calendar events and reminders, as well as using the built-in controllers for creating and modifying calendar events. Tento oddíl není nutné číst zepředu po obnovení, protože se jedná o odkaz pro konkrétní úkoly.This section need not be read front-to-back, as it’s meant to be a reference for particular tasks.

Všechny úlohy v této příručce jsou k dispozici v doprovodné ukázkové aplikaci:All tasks in this guide are available in the companion sample application:

Doprovodné obrazovky s ukázkovou aplikacíThe companion sample application screens

PožadavkyRequirements

EventKitu se zavedla v iOS 4,0, ale přístup k datům připomenutí byl představený v iOS 6,0.EventKit was introduced in iOS 4.0, but access to Reminders data was introduced in iOS 6.0. V takovém případě pro obecné EventKitu vývoj budete muset pro připomenutí cílit alespoň na verzi 4,0 a 6,0.As such, to do general EventKit development, you’ll need to target at least version 4.0, and 6.0 for reminders.

Kromě toho aplikace připomenutí není v simulátoru k dispozici, což znamená, že data připomenutí nebudou k dispozici, pokud je nepřidáte jako první.Additionally, the Reminders application is not available on the simulator, which means that reminders data will also not be available, unless you add them first. Žádosti o přístup se navíc zobrazují jenom uživateli na skutečném zařízení.Additionally, access requests are only shown to the user on the actual device. V takovém případě je vývoj EventKitu nejlépe testován na zařízení.As such, EventKit development is best tested on the Device.

Základy pro sadu Event KitEvent Kit Basics

Při práci s EventKitu je důležité mít k dispozici všechny společné třídy a jejich využití.When working with EventKit, it’s important to have a grasp of the common classes and their usage. Všechny tyto třídy lze nalézt v EventKit a EventKitUI (pro EKEventEditController ).All of these classes can be found in the EventKit and EventKitUI (for the EKEventEditController).

EventstoruEventStore

Třída eventstoru je nejdůležitější třídou v EventKitu, protože je nutné provést všechny operace v EventKitu.The EventStore class is the most important class in EventKit because it’s required to perform any operations in EventKit. Lze si představit jako trvalé úložiště nebo databázový stroj pro všechna EventKitu data.It can be thought of as the persistent storage, or database engine, for all EventKit data. Od EventStore vás máte přístup k kalendářům a událostem kalendáře v aplikaci kalendáře i k připomenutím v aplikaci připomenutí.From EventStore you have access to both the calendars and calendar events in the Calendar Application, as well as reminders in the Reminders Application.

Vzhledem k tomu EventStore , že se jako databázový stroj, měl by být dlouhotrvající, což znamená, že by měl být vytvořen a zničen co nejmenším možným způsobem během životnosti instance aplikace.Because EventStore is like a database engine, it should be long-lived, meaning that it should be created and destroyed as little as possible during the lifetime of an application instance. Doporučuje se, abyste po vytvoření jedné instance aplikace EventStore v aplikaci zanechali tento odkaz na celou dobu životnosti aplikace, pokud si nejste jisti, že ji nebudete potřebovat znovu.In fact, it’s recommended that once you create one instance of an EventStore in an application, you keep that reference around for the entire lifetime of the application, unless you’re sure you won’t need it again. Kromě toho by všechna volání měla jít na jednu EventStore instanci.additionally, all calls should go to a single EventStore instance. Z tohoto důvodu se doporučuje vzor singleton, aby bylo možné udržovat jedinou instanci.For this reason, the Singleton pattern is recommended for keeping a single instance available.

Vytváření úložiště událostíCreating an Event Store

Následující kód ilustruje účinný způsob, jak vytvořit jednu instanci EventStore třídy a zpřístupnit ji staticky v rámci aplikace:The following code illustrates an efficient way to create a single instance of the EventStore class and make it available statically from within an application:

public class App
{
    public static App Current {
            get { return current; }
    }
    private static App current;

    public EKEventStore EventStore {
            get { return eventStore; }
    }
    protected EKEventStore eventStore;

    static App ()
    {
            current = new App();
    }
    protected App () 
    {
            eventStore = new EKEventStore ( );
    }
}

Výše uvedený kód používá ke konkretizaci instance EventStore při načtení aplikace vzor singleton.The code above uses the Singleton pattern to instantiate an instance of the EventStore when the application loads. V EventStore rámci aplikace lze potom použít globálně, jak je znázorněno níže:The EventStore can then be accessed globally from within the application as follows:

App.Current.EventStore;

Všimněte si, že všechny příklady v tomto příkladu používají tento model, takže na něj odkazují EventStore App.Current.EventStore .Note that all examples in here use this pattern, so they reference the EventStore via App.Current.EventStore.

Požaduje se přístup k datům kalendáře a připomenutí.Requesting Access to Calendar and Reminder Data

Aby bylo možné získat přístup k datům přes Eventstoru, musí aplikace nejprve požádat o přístup k datům událostí kalendáře nebo k datům připomenutí v závislosti na tom, který z nich potřebujete.Before being allowed to access any data via the EventStore, an application must first request access to either the calendar events data or reminders data, depending on which one you need. Pro usnadnění tohoto prvku EventStore zpřístupňuje metoda, která je volána, RequestAccess když je volána – zobrazí zobrazení výstrahy uživateli, že aplikace požaduje přístup k datům v kalendáři, nebo data připomenutí v závislosti na tom, která z nich EKEntityType je předána.To facilitate this, the EventStore exposes a method called RequestAccess which — when called — will show an alert view to the user telling them that the application is requesting access to either the calendar data, or reminder data, depending on which EKEntityType is passed to it. Vzhledem k tomu, že vyvolává zobrazení výstrah, je volání asynchronní a volání obslužné rutiny dokončení předané jako NSAction (nebo lambda) k tomuto objektu, který získá dva parametry; logická hodnota, bez ohledu na udělení přístupu, a a NSError , která, pokud hodnota not-null, bude v požadavku obsahovat jakékoli informace o chybě.Because it raises an alert view, the call is asynchronous, and will call a completion handler passed as an NSAction (or Lambda) to it which will receive two parameters; a boolean of whether or not access was granted, and an NSError, which, if not-null will contain any error information in the request. Například následující kód bude vyžadovat přístup k datům události kalendáře a zobrazit zobrazení výstrah, pokud požadavek nebyl udělen.For example, the following coded will request access to calendar event data and show an alert view if the request was not granted.

App.Current.EventStore.RequestAccess (EKEntityType.Event, 
    (bool granted, NSError e) => {
            if (granted)
                    //do something here
            else
                    new UIAlertView ( "Access Denied", 
"User Denied Access to Calendar Data", null,
"ok", null).Show ();
            } );

Po udělení žádosti se zapamatuje, dokud se aplikace nainstaluje do zařízení a neotevře se uživateli výstraha.Once the request has been granted, it will be remembered as long as the application is installed on the device and will not pop up an alert to the user. Přístup je však poskytován pouze pro typ prostředku, buď jsou události kalendáře nebo připomenutí udělena.However, access is only given to the type of resource, either calendar events or reminders granted. Pokud aplikace potřebuje přístup k oběma, měla by vyžadovat obě.If an application needs access to both, it should request both.

Vzhledem k tomu, že oprávnění je zapamatování, je poměrně levné na to, aby se povedl požadavek pokaždé, takže před provedením operace je vhodné vždy požádat o přístup.Because permission is remembered, it’s relatively cheap to make the request each time, so it’s a good idea to always request access before performing an operation.

Vzhledem k tomu, že obslužná rutina dokončení je volána na samostatném vlákně (bez uživatelského rozhraní), všechny aktualizace uživatelského rozhraní v obslužné rutině dokončení by měly být volány prostřednictvím InvokeOnMainThread , jinak bude vyvolána výjimka a pokud není zachycena, aplikace dojde k chybě.Additionally, because the completion handler is called on a separate (non-UI) thread, any updates to the UI in the completion handler should be called via InvokeOnMainThread, otherwise an exception will be thrown, and if not caught, the application will crash.

EKEntityTypeEKEntityType

EKEntityType je výčet, který popisuje typ EventKit položky nebo data.EKEntityType is an enumeration that describes the type of EventKit item or data. Má dvě hodnoty: Event a připomenutí.It has two values: Event and Reminder. Používá se v mnoha metodách, včetně informací o EventStore.RequestAccess tom, EventKit Jaký druh dat má získat přístup k nebo načíst.It’s used in a number of methods, including EventStore.RequestAccess to tell EventKit what kind of data to get access to or retrieve.

EKCalendarEKCalendar

EKCalendar představuje kalendář, který obsahuje skupinu událostí kalendáře.EKCalendar represents a calendar, which contains a group of calendar events. Kalendáře se můžou ukládat na hodně různých místech, jako je například místně, v iCloudna místě poskytovatele třetí strany, jako je například Exchange Server nebo Googleatd. V mnoha případech EKCalendar se používá k oznámení EventKit , kde hledat události nebo kam je uložit.Calendars can be stored in a lot of different places, such as locally, in iCloud, in a 3rd party provider location such as an Exchange Server or Google, etc. Many times EKCalendar is used to tell EventKit where to look for events, or where to save them.

EKEventEditControllerEKEventEditController

EKEventEditController lze nalézt v EventKitUI oboru názvů a je vestavěným kontrolérem, který lze použít k úpravě nebo vytvoření událostí kalendáře.EKEventEditController can be found in the EventKitUI namespace and is a built-in controller that can be used to edit or create calendar events. Podobně jako u vestavěných řadičů kamery EKEventEditController dělá těžké zvedání v zobrazení uživatelského rozhraní a manipulace s uložením.Much like the built in camera controllers, EKEventEditController does the heavy lifting for you in displaying the UI and handling saving.

EKEventEKEvent

EKEvent představuje událost kalendáře.EKEvent represents a calendar event. EKEventA EKReminder dědí z EKCalendarItem a pole, jako například Title , Notes a tak dále.Both EKEvent and EKReminder inherit from EKCalendarItem and have fields such as Title, Notes, and so on.

EKReminderEKReminder

EKReminder představuje položku připomenutí.EKReminder represents a reminder item.

EKSpanEKSpan

EKSpan je výčet, který popisuje rozsah událostí při změně událostí, které se mohou opakovat, a má dvě hodnoty: ThisEvent a FutureEvents.EKSpan is an enumeration that describes the span of events when modifying events that can recur, and has two values: ThisEvent and FutureEvents. ThisEvent znamená, že všechny změny budou provedeny pouze pro konkrétní událost v řadě, na kterou se odkazuje, zatímco FutureEvents Tato událost a všechna budoucí opakování budou mít vliv.ThisEvent means that any changes will only occur to the particular event in the series that is being referenced, whereas FutureEvents will affect that event and all future recurrences.

ÚlohyTasks

Pro snadné použití EventKitu využití bylo rozdělené do běžných úloh, které jsou popsané v následujících částech.For ease of use, EventKit usage has been broken up into common tasks, described in the following sections.

Zobrazení výčtu kalendářůEnumerate Calendars

Chcete-li vytvořit výčet kalendářů, které uživatel nakonfiguroval na zařízení, zavolejte na GetCalendars EventStore a předejte typ kalendářů (připomenutí nebo události), které chcete přijmout:To enumerate the calendars that the user has configured on the device, call GetCalendars on the EventStore and pass the type of calendars (either reminders or events) that you wish to receive:

EKCalendar[] calendars = 
App.Current.EventStore.GetCalendars ( EKEntityType.Event );

Přidání nebo úprava události pomocí integrovaného kontroleruAdd or Modify an Event Using the Built-in Controller

EKEventEditViewController má spoustu těžkého zvedání, pokud chcete vytvořit nebo upravit událost se stejným uživatelským rozhraním, které se uživateli zobrazí při použití aplikace kalendáře:The EKEventEditViewController does a lot of the heavy lifting for you if you want to create or edit an event with the same UI that’s presented to the user when using the Calendar Application:

Uživatelské rozhraní, které se uživateli zobrazí při použití aplikace kalendářeThe UI that is presented to the user when using the Calendar Application

Chcete-li jej použít, je třeba jej deklarovat jako proměnnou na úrovni třídy, aby nezískala uvolňování paměti, pokud je deklarována v rámci metody:To use it, you’ll want to declare it as a class-level variable so that it doesn’t get garbage-collected if it’s declared within a method:

public class HomeController : DialogViewController
{
        protected CreateEventEditViewDelegate eventControllerDelegate;
        ...
}

Pak ji můžete spustit: vytvořte její odkaz na, zakažte na EventStore ni delegáta EKEventEditViewDelegate a pak ji zobrazte pomocí PresentViewController :Then, to launch it: instantiate it, give it a reference to the EventStore, wire up an EKEventEditViewDelegate delegate to it, and then display it using PresentViewController:

EventKitUI.EKEventEditViewController eventController = 
        new EventKitUI.EKEventEditViewController ();

// set the controller's event store - it needs to know where/how to save the event
eventController.EventStore = App.Current.EventStore;

// wire up a delegate to handle events from the controller
eventControllerDelegate = new CreateEventEditViewDelegate ( eventController );
eventController.EditViewDelegate = eventControllerDelegate;

// show the event controller
PresentViewController ( eventController, true, null );

Případně, pokud chcete událost předem naplnit, můžete buď vytvořit novou událost (jak je vidět níže), nebo můžete načíst uloženou událost:Optionally, if you want to pre-populate the event, you can either create a brand new event (as shown below), or you can retrieve a saved event:

EKEvent newEvent = EKEvent.FromStore ( App.Current.EventStore );
// set the alarm for 10 minutes from now
newEvent.AddAlarm ( EKAlarm.FromDate ( DateTime.Now.AddMinutes ( 10 ) ) );
// make the event start 20 minutes from now and last 30 minutes
newEvent.StartDate = DateTime.Now.AddMinutes ( 20 );
newEvent.EndDate = DateTime.Now.AddMinutes ( 50 );
newEvent.Title = "Get outside and exercise!";
newEvent.Notes = "This is your reminder to go and exercise for 30 minutes.”;

Pokud chcete uživatelské rozhraní předem naplnit, nezapomeňte nastavit vlastnost události na řadiči:If you do wish to pre-populate the UI, make sure to set the Event property on the controller:

eventController.Event = newEvent;

Pokud chcete použít existující událost, přečtěte si část jak načíst událost podle ID později.To use an existing event, see the Retrieve an Event by ID section later on.

Delegát by měl přepsat Completed metodu, která je volána řadičem, když je uživatel dokončen v dialogovém okně:The delegate should override the Completed method, which is called by the controller when the user is finished with the dialog:

protected class CreateEventEditViewDelegate : EventKitUI.EKEventEditViewDelegate
{
        // we need to keep a reference to the controller so we can dismiss it
        protected EventKitUI.EKEventEditViewController eventController;

        public CreateEventEditViewDelegate (EventKitUI.EKEventEditViewController eventController)
        {
                // save our controller reference
                this.eventController = eventController;
        }

        // completed is called when a user eith
        public override void Completed (EventKitUI.EKEventEditViewController controller, EKEventEditViewAction action)
        {
                eventController.DismissViewController (true, null);
                }
        }
}

V případě potřeby můžete v delegátu zaškrtnout akci v Completed metodě pro úpravu události a znovu uložit nebo provést jiné akce, pokud je zrušena, etcetera:Optionally, in the delegate, you can check the Action in the Completed method to modify the event and resave, or do other things, if it’s cancelled, etcetera:

public override void Completed (EventKitUI.EKEventEditViewController controller, EKEventEditViewAction action)
{
        eventController.DismissViewController (true, null);

        switch ( action ) {

        case EKEventEditViewAction.Canceled:
                break;
        case EKEventEditViewAction.Deleted:
                break;
        case EKEventEditViewAction.Saved:
                // if you wanted to modify the event you could do so here,
// and then save:
                //App.Current.EventStore.SaveEvent ( controller.Event, )
                break;
        }
}

Programové vytvoření událostiCreating an Event Programmatically

Chcete-li vytvořit událost v kódu, použijte FromStore pro třídu metodu Factory FromStore EKEvent a nastavte na ni všechna data:To create an event in code, use the FromStore factory method on the EKEvent class, and set any data on it:

EKEvent newEvent = EKEvent.FromStore ( App.Current.EventStore );
// set the alarm for 10 minutes from now
newEvent.AddAlarm ( EKAlarm.FromDate ( DateTime.Now.AddMinutes ( 10 ) ) );
// make the event start 20 minutes from now and last 30 minutes
newEvent.StartDate = DateTime.Now.AddMinutes ( 20 );
newEvent.EndDate = DateTime.Now.AddMinutes ( 50 );
newEvent.Title = "Get outside and do some exercise!";
newEvent.Notes = "This is your motivational event to go and do 30 minutes of exercise. Super important. Do this.";

Je nutné nastavit kalendář, ve kterém má být událost uložena, ale pokud nemáte žádné předvolby, můžete použít výchozí:You must set the calendar that you want the event saved in, but if you have no preference, you can use the default:

newEvent.Calendar = App.Current.EventStore.DefaultCalendarForNewEvents;

Chcete-li uložit událost, zavolejte metodu SaveEvent na EventStore :To save the event, call the SaveEvent method on the EventStore:

NSError e;
App.Current.EventStore.SaveEvent ( newEvent, EKSpan.ThisEvent, out e );

Po uložení bude vlastnost EventIdentifier aktualizována jedinečným identifikátorem, který lze později použít k načtení události:After it’s saved, the EventIdentifier property will be updated with a unique identifier that can be used later to retrieve the event:

Console.WriteLine ("Event Saved, ID: " + newEvent.CalendarItemIdentifier);

EventIdentifier je identifikátor GUID formátu řetězce.EventIdentifier is a string formatted GUID.

Programové vytvoření připomenutíCreate a Reminder Programmatically

Vytvoření připomenutí v kódu je mnohem stejné jako vytvoření události kalendáře:Creating a reminder in code is much the same as creating a calendar event:

EKReminder reminder = EKReminder.Create ( App.Current.EventStore );
reminder.Title = "Do something awesome!";
reminder.Calendar = App.Current.EventStore.DefaultCalendarForNewReminders;

Pro uložení volejte metodu SaveReminder na EventStore :To save, call the SaveReminder method on the EventStore:

NSError e;
App.Current.EventStore.SaveReminder ( reminder, true, out e );

Načítání události podle IDRetrieving an Event by ID

Chcete-li načíst událost podle ID, použijte metodu EventFromIdentifier v objektu EventStore a předejte ji do objektu EventIdentifier , který byl načten z události:To retrieve an event by it’s ID, use the EventFromIdentifier method on the EventStore and pass it the EventIdentifier that was pulled from the event:

EKEvent mySavedEvent = App.Current.EventStore.EventFromIdentifier ( newEvent.EventIdentifier );

Pro události jsou k dispozici dvě další vlastnosti identifikátoru, ale EventIdentifier je to ten, který je v tomto případě vhodný.For events, there is are two other identifier properties, but EventIdentifier is the only one that works for this.

Načítání připomenutí podle IDRetrieving a Reminder by ID

Chcete-li načíst připomenutí, použijte metodu GetCalendarItem EventStore a předejte ji CalendarItemIdentifier:To retrieve a reminder, use the GetCalendarItem method on the EventStore and pass it the CalendarItemIdentifier:

EKCalendarItem myReminder = App.Current.EventStore.GetCalendarItem ( reminder.CalendarItemIdentifier );

Vzhledem k tomu GetCalendarItem , že vrací hodnotu EKCalendarItem , musí být přetypování na, EKReminder Pokud potřebujete získat přístup k datům připomenutí nebo použít instanci jako EKReminder později.Because GetCalendarItem returns an EKCalendarItem, it must be cast to EKReminder if you need to access reminder data or use the instance as an EKReminder later.

Nepoužívejte GetCalendarItem pro události kalendáře, stejně jako v době psaní, nefunguje.Don’t use GetCalendarItem for calendar events, as at the time of writing, it doesn’t work.

Odstranění událostiDeleting an Event

Chcete-li odstranit událost kalendáře, RemoveEvent zavolejte na RemoveEvent EventStore a předejte odkaz na událost a příslušné EKSpan :To delete a calendar event, call RemoveEvent on your EventStore and pass a reference to the event, and the appropriate EKSpan:

NSError e;
App.Current.EventStore.RemoveEvent ( mySavedEvent, EKSpan.ThisEvent, true, out e);

Poznámka: po odstranění události se ale odkaz na událost bude null .Note however, after an event has been deleted, the event reference will be null.

Odstranění připomenutíDeleting a Reminder

Chcete-li odstranit připomenutí, zavolejte RemoveReminder na EventStore a předejte odkaz na připomenutí:To delete a reminder, call RemoveReminder on the EventStore and pass a reference to the reminder:

NSError e;
App.Current.EventStore.RemoveReminder ( myReminder as EKReminder, true, out e);

Všimněte si, že ve výše uvedeném kódu je přetypování na EKReminder , protože se GetCalendarItem použilo k jeho načtení.Note that in the above code there is a cast to EKReminder, because GetCalendarItem was used to retrieve it

Hledání událostíSearching for Events

Chcete-li vyhledat události kalendáře, je nutné vytvořit objekt NSPredicate prostřednictvím metody PredicateForEvents na EventStore .To search for calendar events, you must create an NSPredicate object via the PredicateForEvents method on the EventStore. NSPredicateJe objekt dat dotazu, který iOS používá k vyhledání shody:An NSPredicate is a query data object that iOS uses to locate matches:

DateTime startDate = DateTime.Now.AddDays ( -7 );
DateTime endDate = DateTime.Now;
// the third parameter is calendars we want to look in, to use all calendars, we pass null
NSPredicate query = App.Current.EventStore.PredicateForEvents ( startDate, endDate, null );

Po vytvoření NSPredicate použijte metodu EventsMatching na EventStore :Once you’ve created the NSPredicate, use the EventsMatching method on the EventStore:

// execute the query
EKCalendarItem[] events = App.Current.EventStore.EventsMatching ( query );

Všimněte si, že dotazy jsou synchronní (blokující) a mohou trvat dlouhou dobu v závislosti na dotazu, takže můžete chtít vytvořit nové vlákno nebo úkol, aby to promohl.Note that queries are synchronous (blocking) and may take a long time, depending on the query, so you may want to spin up a new thread or task to do it.

Hledání připomenutíSearching for Reminders

Hledání připomenutí je podobné událostem; vyžaduje predikát, ale volání je již asynchronní, takže si nemusí podepisovat starosti s blokováním vlákna:Searching for reminders is similar to events; it requires a predicate, but the call is already asynchronous, so you needn’t worry about blocking the thread:

// create our NSPredicate which we'll use for the query
NSPredicate query = App.Current.EventStore.PredicateForReminders ( null );

// execute the query
App.Current.EventStore.FetchReminders (
        query, ( EKReminder[] items ) => {
                // do someting with the items
        } );

SouhrnSummary

Tento dokument vám poskytl přehled o důležitých částech EventKitu Frameworku a řadu nejběžnějších úloh.This document gave an overview of both the important pieces of the EventKit framework, and a number of the most common tasks. EventKitu Framework je však velmi velký a výkonný a obsahuje funkce, které zde nejsou zavedeny, například: dávkové aktualizace, konfigurace alarmů, konfigurace opakování u událostí, registrace a naslouchání změnám v databázi kalendáře, nastavení geografických a dalších.However, the EventKit framework is very large and powerful, and includes features that haven’t been introduced here, such as: batch updates, configuring alarms, configuring recurrence on events, registering and listening for changes on the calendar database, setting GeoFences and more. Další informace najdete v tématu Průvodce programováním kalendáře a připomenutíspolečnosti Apple.For more information see Apple’s Calendar and Reminders Programming Guide.