Dynamic prefetch range.

Author: Jens Claes

library/src/main/java/com/alamkanak/weekview/MonthLoader.java

@@ -0,0 +1,31 @@
+package com.alamkanak.weekview;
+
+import java.util.Calendar;
+import java.util.List;
+
+public class MonthLoader implements WeekViewLoader {
+
+    private WeekView.MonthChangeListener mOnMonthChangeListener;
+    public MonthLoader(WeekView.MonthChangeListener listener){
+        this.mOnMonthChangeListener = listener;
+    }
+
+    @Override
+    public double toWeekViewPeriodIndex(Calendar instance){
+        return instance.get(Calendar.YEAR)*12 + instance.get(Calendar.MONTH) + (instance.get(Calendar.DAY_OF_MONTH)-1)/30.0;
+    }
+
+    @Override
+    public List<WeekViewEvent> onLoad(int periodIndex){
+        return mOnMonthChangeListener.onMonthChange(periodIndex/12,periodIndex%12+1);
+    }
+
+
+    public WeekView.MonthChangeListener getOnMonthChangeListener() {
+        return mOnMonthChangeListener;
+    }
+
+    public void setOnMonthChangeListener(WeekView.MonthChangeListener onMonthChangeListener) {
+        this.mOnMonthChangeListener = onMonthChangeListener;
+    }
+}

library/src/main/java/com/alamkanak/weekview/WeekView.java

@@ -64,10 +64,13 @@ public class WeekView extends View {
     private Paint mEventBackgroundPaint;
     private float mHeaderColumnWidth;
     private List<EventRect> mEventRects;
+    private List<WeekViewEvent> mPreviousPeriodEvents;
+    private List<WeekViewEvent> mCurrentPeriodEvents;
+    private List<WeekViewEvent> mNextPeriodEvents;
     private TextPaint mEventTextPaint;
     private Paint mHeaderColumnBackgroundPaint;
     private Scroller mStickyScroller;
-    private int mFetchedMonths[] = new int[3];
+    private int mFetchedPeriod = -1; // the middle period the calendar has fetched.
     private boolean mRefreshEvents = false;
     private float mDistanceY = 0;
     private float mDistanceX = 0;
@@ -104,7 +107,7 @@ public class WeekView extends View {
     // Listeners.
     private EventClickListener mEventClickListener;
     private EventLongPressListener mEventLongPressListener;
-    private MonthChangeListener mMonthChangeListener;
+    private WeekViewLoader mWeekViewLoader;
     private EmptyViewClickListener mEmptyViewClickListener;
     private EmptyViewLongPressListener mEmptyViewLongPressListener;
     private DateTimeInterpreter mDateTimeInterpreter;
@@ -427,7 +430,9 @@ private void drawHeaderRowAndEvents(Canvas canvas) {
 
             // Get more events if necessary. We want to store the events 3 months beforehand. Get
             // events only when it is the first iteration of the loop.
-            if (mEventRects == null || mRefreshEvents || (dayNumber == leftDaysWithGaps + 1 && mFetchedMonths[1] != day.get(Calendar.MONTH)+1 && day.get(Calendar.DAY_OF_MONTH) == 15)) {
+            if (mEventRects == null || mRefreshEvents ||
+                    (dayNumber == leftDaysWithGaps + 1 && mFetchedPeriod != (int) mWeekViewLoader.toWeekViewPeriodIndex(day) &&
+                            Math.abs(mFetchedPeriod - mWeekViewLoader.toWeekViewPeriodIndex(day)) > 0.5)) {
                 getMoreEvents(day);
                 mRefreshEvents = false;
             }
@@ -644,59 +649,60 @@ public EventRect(WeekViewEvent event, WeekViewEvent originalEvent, RectF rectF)
      * @param day The day where the user is currently is.
      */
     private void getMoreEvents(Calendar day) {
-
-        // Delete all events if its not current month +- 1.
-        deleteFarMonths(day);
-
         // Get more events if the month is changed.
         if (mEventRects == null)
             mEventRects = new ArrayList<EventRect>();
-        if (mMonthChangeListener == null && !isInEditMode())
+        if (mWeekViewLoader == null && !isInEditMode())
             throw new IllegalStateException("You must provide a MonthChangeListener");
 
         // If a refresh was requested then reset some variables.
         if (mRefreshEvents) {
             mEventRects.clear();
-            mFetchedMonths = new int[3];
+            mPreviousPeriodEvents = null;
+            mCurrentPeriodEvents = null;
+            mNextPeriodEvents = null;
+            mFetchedPeriod = -1;
         }
 
-        // Get events of previous month.
-        int previousMonth = (day.get(Calendar.MONTH) == 0?12:day.get(Calendar.MONTH));
-        int nextMonth = (day.get(Calendar.MONTH)+2 == 13 ?1:day.get(Calendar.MONTH)+2);
-        int[] lastFetchedMonth = mFetchedMonths.clone();
-        if (mFetchedMonths[0] < 1 || mFetchedMonths[0] != previousMonth || mRefreshEvents) {
-            if (!containsValue(lastFetchedMonth, previousMonth) && !isInEditMode()){
-                List<WeekViewEvent> events = mMonthChangeListener.onMonthChange((previousMonth==12)?day.get(Calendar.YEAR)-1:day.get(Calendar.YEAR), previousMonth);
-                sortEvents(events);
-                for (WeekViewEvent event: events) {
-                    cacheEvent(event);
-                }
-            }
-            mFetchedMonths[0] = previousMonth;
-        }
-
-        // Get events of this month.
-        if (mFetchedMonths[1] < 1 || mFetchedMonths[1] != day.get(Calendar.MONTH)+1 || mRefreshEvents) {
-            if (!containsValue(lastFetchedMonth, day.get(Calendar.MONTH)+1) && !isInEditMode()) {
-                List<WeekViewEvent> events = mMonthChangeListener.onMonthChange(day.get(Calendar.YEAR), day.get(Calendar.MONTH) + 1);
-                sortEvents(events);
-                for (WeekViewEvent event : events) {
-                    cacheEvent(event);
-                }
-            }
-            mFetchedMonths[1] = day.get(Calendar.MONTH)+1;
-        }
-
-        // Get events of next month.
-        if (mFetchedMonths[2] < 1 || mFetchedMonths[2] != nextMonth || mRefreshEvents) {
-            if (!containsValue(lastFetchedMonth, nextMonth) && !isInEditMode()) {
-                List<WeekViewEvent> events = mMonthChangeListener.onMonthChange(nextMonth == 1 ? day.get(Calendar.YEAR) + 1 : day.get(Calendar.YEAR), nextMonth);
-                sortEvents(events);
-                for (WeekViewEvent event : events) {
-                    cacheEvent(event);
+        if(mWeekViewLoader != null){
+            int periodToFetch = (int) mWeekViewLoader.toWeekViewPeriodIndex(day);
+            if (!isInEditMode() && (mFetchedPeriod < 0 || mFetchedPeriod != periodToFetch || mRefreshEvents)) {
+                List<WeekViewEvent> previousPeriodEvents = null;
+                List<WeekViewEvent> currentPeriodEvents = null;
+                List<WeekViewEvent> nextPeriodEvents = null;
+
+                if(mPreviousPeriodEvents != null && mCurrentPeriodEvents != null && mNextPeriodEvents != null){
+                    if(periodToFetch == mFetchedPeriod-1){
+                        currentPeriodEvents = mPreviousPeriodEvents;
+                        nextPeriodEvents = mCurrentPeriodEvents;
+                    }else if(periodToFetch == mFetchedPeriod){
+                        previousPeriodEvents = mPreviousPeriodEvents;
+                        currentPeriodEvents = mCurrentPeriodEvents;
+                        nextPeriodEvents = mNextPeriodEvents;
+                    }else if(periodToFetch == mFetchedPeriod+1){
+                        previousPeriodEvents = mCurrentPeriodEvents;
+                        currentPeriodEvents = mNextPeriodEvents;
+                    }
                 }
+                if(currentPeriodEvents == null)
+                    currentPeriodEvents = mWeekViewLoader.onLoad(periodToFetch);
+                if(previousPeriodEvents == null)
+                    previousPeriodEvents = mWeekViewLoader.onLoad(periodToFetch-1);
+                if(nextPeriodEvents == null)
+                    nextPeriodEvents = mWeekViewLoader.onLoad(periodToFetch+1);
+
+
+                //clear events
+                mEventRects.clear();
+                sortAndCacheEvents(previousPeriodEvents);
+                sortAndCacheEvents(currentPeriodEvents);
+                sortAndCacheEvents(nextPeriodEvents);
+
+                mPreviousPeriodEvents = previousPeriodEvents;
+                mCurrentPeriodEvents = currentPeriodEvents;
+                mNextPeriodEvents = nextPeriodEvents;
+                mFetchedPeriod = periodToFetch;
             }
-            mFetchedMonths[2] = nextMonth;
         }
 
         // Prepare to calculate positions of each events.
@@ -745,6 +751,13 @@ private void cacheEvent(WeekViewEvent event) {
             mEventRects.add(new EventRect(event, event, null));
     }
 
+    private void sortAndCacheEvents(List<WeekViewEvent> events){
+        sortEvents(events);
+        for(WeekViewEvent event : events){
+            cacheEvent(event);
+        }
+    }
+
     /**
      * Sorts the events in ascending order.
      * @param events The events to be sorted.
@@ -873,38 +886,6 @@ private boolean isTimeAfterOrEquals(Calendar time1, Calendar time2) {
         return !(time1 == null || time2 == null) && time1.getTimeInMillis() >= time2.getTimeInMillis();
     }
 
-    /**
-     * Deletes the events of the months that are too far away from the current month.
-     * @param currentDay The current day.
-     */
-    private void deleteFarMonths(Calendar currentDay) {
-
-        if (mEventRects == null) return;
-
-        Calendar nextMonth = (Calendar) currentDay.clone();
-        nextMonth.add(Calendar.MONTH, 1);
-        nextMonth.set(Calendar.DAY_OF_MONTH, nextMonth.getActualMaximum(Calendar.DAY_OF_MONTH));
-        nextMonth.set(Calendar.HOUR_OF_DAY, 12);
-        nextMonth.set(Calendar.MINUTE, 59);
-        nextMonth.set(Calendar.SECOND, 59);
-
-        Calendar prevMonth = (Calendar) currentDay.clone();
-        prevMonth.add(Calendar.MONTH, -1);
-        prevMonth.set(Calendar.DAY_OF_MONTH, 1);
-        prevMonth.set(Calendar.HOUR_OF_DAY, 0);
-        prevMonth.set(Calendar.MINUTE, 0);
-        prevMonth.set(Calendar.SECOND, 0);
-
-        List<EventRect> newEvents = new ArrayList<EventRect>();
-        for (EventRect eventRect : mEventRects) {
-            boolean isFarMonth = eventRect.event.getStartTime().getTimeInMillis() > nextMonth.getTimeInMillis() || eventRect.event.getEndTime().getTimeInMillis() < prevMonth.getTimeInMillis();
-            if (!isFarMonth) newEvents.add(eventRect);
-        }
-        mEventRects.clear();
-        mEventRects.addAll(newEvents);
-    }
-
-
     /////////////////////////////////////////////////////////////////
     //
     //      Functions related to setting and getting the properties.
@@ -920,11 +901,21 @@ public EventClickListener getEventClickListener() {
     }
 
     public MonthChangeListener getMonthChangeListener() {
-        return mMonthChangeListener;
+        if(mWeekViewLoader instanceof MonthLoader)
+            return ((MonthLoader) mWeekViewLoader).getOnMonthChangeListener();
+        return null;
     }
 
     public void setMonthChangeListener(MonthChangeListener monthChangeListener) {
-        this.mMonthChangeListener = monthChangeListener;
+        this.mWeekViewLoader = new MonthLoader(monthChangeListener);
+    }
+
+    public WeekViewLoader getWeekViewLoader(){
+        return mWeekViewLoader;
+    }
+
+    public void setWeekViewLoader(WeekViewLoader loader){
+        this.mWeekViewLoader = loader;
     }
 
     public EventLongPressListener getEventLongPressListener() {

library/src/main/java/com/alamkanak/weekview/WeekViewLoader.java

@@ -0,0 +1,23 @@
+package com.alamkanak.weekview;
+
+import java.util.Calendar;
+import java.util.List;
+
+public interface WeekViewLoader {
+    /**
+     * Convert a date into a double that will be used to reference when you're loading data.
+     *
+     * All periods that have the same integer part, define one period. Dates that are later in time should have a greater return value.
+     *
+     * @param instance the date
+     * @return The period index in which the date falls (floating point number).
+     */
+    public double toWeekViewPeriodIndex(Calendar instance);
+
+    /**
+     * Load the events within the period
+     * @param periodIndex the period to load
+     * @return A list with the events of this period
+     */
+    public List<WeekViewEvent> onLoad(int periodIndex);
+}