public void LoadAndMergeTodaysItems(ObservableCollection <IToDoItem> toDo, ObservableCollection <IToDoItem> toDone)
        {
            var items = new List <IToDoItem> ();

            var predicate = eventStore.PredicateForReminders(null);


            eventStore.FetchReminders(predicate, (EKReminder [] reminders) => {
                foreach (var reminder in reminders)
                {
                    if (reminder.Alarms == null)
                    {
                        continue;
                    }
                    foreach (var alarm in reminder.Alarms)
                    {
                        var alarmDate = (DateTime)alarm.AbsoluteDate;
                        if (!IsToday(alarmDate))
                        {
                            continue;
                        }
                        AddOrMerge(new ToDoItem(reminder), toDo, toDone);
                    }
                }
            });
        }
Esempio n. 2
0
        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");
        }
Esempio n. 3
0
        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);
            }
        }