Restored prefetching mechanism, fixing this issue:

AndroidDeveloperLB · AndroidDeveloperLB · commit 8ebc6465b47e · 2018-05-27T14:15:03.000+03:00
Quivr#86 Quivr#89
diff --git a/build.gradle b/build.gradle
@@ -7,7 +7,7 @@ buildscript {
         google()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.2.0-alpha14'
+        classpath 'com.android.tools.build:gradle:3.2.0-alpha15'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
 
         // NOTE: Do not place your application dependencies here; they belong
diff --git a/library/src/main/java/com/alamkanak/weekview/PrefetchingWeekViewLoader.kt b/library/src/main/java/com/alamkanak/weekview/PrefetchingWeekViewLoader.kt
@@ -0,0 +1,39 @@
+package com.alamkanak.weekview
+
+import android.support.annotation.IntRange
+import java.util.*
+
+/**
+ * <h1>PrefetchingWeekViewLoader</h1>
+ * This class provides prefetching data loading behaviour.
+ * By setting a specific period of N, data is retrieved for the current period,
+ * the next N periods and the previous N periods.
+ */
+/**
+ * @param weekViewLoader An instance of the WeekViewLoader class
+ * @param prefetchingPeriod The amount of periods to be fetched before and after the
+ * current period. Must be 1 or greater.
+ */
+class PrefetchingWeekViewLoader(weekViewLoader: WeekViewLoader, @IntRange(from = 1L) val prefetchingPeriod: Int = 1) : WeekViewLoader {
+    private var mWeekViewLoader: WeekViewLoader? = weekViewLoader
+
+    init {
+        if (prefetchingPeriod < 1)
+            throw IllegalArgumentException("Must specify prefetching period of at least 1!")
+    }
+
+    override fun onLoad(periodIndex: Int): MutableList<WeekViewEvent>? {
+        // fetch the current period
+        val events = ArrayList(mWeekViewLoader!!.onLoad(periodIndex)!!)
+        // fetch periods before/after
+        for (i in 1..this.prefetchingPeriod) {
+            events.addAll(mWeekViewLoader!!.onLoad(periodIndex - i)!!)
+            events.addAll(mWeekViewLoader!!.onLoad(periodIndex + i)!!)
+        }
+        // return list of all events together
+        return events
+    }
+
+    override fun toWeekViewPeriodIndex(instance: Calendar) = mWeekViewLoader!!.toWeekViewPeriodIndex(instance)
+
+}
diff --git a/library/src/main/java/com/alamkanak/weekview/WeekView.kt b/library/src/main/java/com/alamkanak/weekview/WeekView.kt
@@ -17,6 +17,7 @@ import android.util.AttributeSet
 import android.util.TypedValue
 import android.view.*
 import android.widget.OverScroller
+import com.alamkanak.weekview.MonthLoader.MonthChangeListener
 import com.alamkanak.weekview.WeekViewUtil.daysBetween
 import com.alamkanak.weekview.WeekViewUtil.getPassedMinutesInDay
 import com.alamkanak.weekview.WeekViewUtil.isSameDay
@@ -224,7 +225,11 @@ class WeekView @JvmOverloads constructor(context: Context, attrs: AttributeSet?
      * are loaded in week view. For a MonthLoader events are loaded for every month. You can define
      * your custom event loader by extending WeekViewLoader.
      */
-    var weekViewLoader: WeekViewLoader? = null
+    val weekViewLoader: WeekViewLoader = PrefetchingWeekViewLoader(MonthLoader(object : MonthChangeListener {
+        override fun onMonthChange(newYear: Int, newMonth: Int): MutableList<WeekViewEvent>? {
+            return monthChangeListener?.onMonthChange(newYear, newMonth)
+        }
+    }))
     var emptyViewClickListener: EmptyViewClickListener? = null
     var emptyViewLongPressListener: EmptyViewLongPressListener? = null
     var scrollListener: ScrollListener? = null
@@ -359,7 +364,7 @@ class WeekView @JvmOverloads constructor(context: Context, attrs: AttributeSet?
             // If the tap was on an event then trigger the callback.
             if (mEventRects != null && eventClickListener != null) {
                 val reversedEventRects = mEventRects
-                Collections.reverse(reversedEventRects!!)
+                reversedEventRects!!.reverse()
                 for (eventRect in reversedEventRects) {
                     if (newEventIdentifier != eventRect.event.identifier && eventRect.rectF != null && e.x > eventRect.rectF!!.left && e.x < eventRect.rectF!!.right && e.y > eventRect.rectF!!.top && e.y < eventRect.rectF!!.bottom) {
                         eventClickListener!!.onEventClick(eventRect.originalEvent, eventRect.rectF!!)
@@ -455,7 +460,7 @@ class WeekView @JvmOverloads constructor(context: Context, attrs: AttributeSet?
 
             if (eventLongPressListener != null && mEventRects != null) {
                 val reversedEventRects = mEventRects
-                Collections.reverse(reversedEventRects!!)
+                reversedEventRects!!.reverse()
                 for (event in reversedEventRects) {
                     if (event.rectF != null && e.x > event.rectF!!.left && e.x < event.rectF!!.right && e.y > event.rectF!!.top && e.y < event.rectF!!.bottom) {
                         eventLongPressListener!!.onEventLongPress(event.originalEvent, event.rectF!!)
@@ -491,16 +496,16 @@ class WeekView @JvmOverloads constructor(context: Context, attrs: AttributeSet?
 
     private val xMinLimit: Float
         get() {
-            if (maxDate == null) {
-                return Integer.MIN_VALUE.toFloat()
+            return if (maxDate == null) {
+                Integer.MIN_VALUE.toFloat()
             } else {
                 val date = maxDate!!.clone() as Calendar
                 date.add(Calendar.DATE, 1 - realNumberOfVisibleDays)
                 while (date.before(minDate)) {
                     date.add(Calendar.DATE, 1)
                 }
 
-                return getXOriginForDate(date)
+                getXOriginForDate(date)
             }
         }
 
@@ -525,11 +530,7 @@ class WeekView @JvmOverloads constructor(context: Context, attrs: AttributeSet?
         get() = mCurrentOrigin.x + (mWidthPerDay + columnGap) * leftDaysWithGaps +
                 mHeaderColumnWidth
 
-    var monthChangeListener: MonthLoader.MonthChangeListener?
-        get() = if (weekViewLoader is MonthLoader) (weekViewLoader as MonthLoader).onMonthChangeListener else null
-        set(value) {
-            this.weekViewLoader = MonthLoader(value)
-        }
+    var monthChangeListener: MonthChangeListener? = null
 
     /**
      *  the interpreter which provides the text to show in the header column and the header row.
@@ -1404,11 +1405,35 @@ class WeekView @JvmOverloads constructor(context: Context, attrs: AttributeSet?
                 continue
             }
 
-            // 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 && mFetchedPeriod != weekViewLoader!!.toWeekViewPeriodIndex(day).toInt() &&
-                    Math.abs(mFetchedPeriod - weekViewLoader!!.toWeekViewPeriodIndex(day)) > 0.5) {
+            // Get more events if necessary.
+
+            // mFetchedPeriod: currently fetched period index
+            // mWeekViewLoader.toWeekViewPeriodIndex(day): index for the day we want to display
+            // fetchIndex = 1.0: end of period in the future reached
+            // fetchIndex = 0.0: end of period in the past reached
+            val fetchIndex = this.weekViewLoader.toWeekViewPeriodIndex(day) - mFetchedPeriod
+
+            // if we are using the PrefetchingWeekViewLoader class, we need to adjust the bounds
+            // so that we wait to fetch new data until we really need it
+            var upperBound = 1.0
+            var lowerBound = 0.0
+
+            if (this.weekViewLoader is PrefetchingWeekViewLoader) {
+                // the offset causes the onMonthChangeListener to be trigger when half of the
+                // last fetched period is passed
+
+                // example:
+                // if the prefetching period = 1, we load the current period, the next and the previous
+                // when half of the next/previous period is passed, the listener is triggered to fetch new data
+                val boundOffset = this.weekViewLoader.prefetchingPeriod - 0.5
+
+                upperBound = 1.0 + boundOffset
+                lowerBound = 0.0 - boundOffset
+            }
+
+            if ((mEventRects == null || mRefreshEvents ||
+                            dayNumber == leftDaysWithGaps + 1 && mFetchedPeriod != this.weekViewLoader.toWeekViewPeriodIndex(day).toInt() &&
+                            (fetchIndex >= upperBound || fetchIndex <= lowerBound))) {
                 getMoreEvents(day)
                 mRefreshEvents = false
             }
@@ -1824,7 +1849,7 @@ class WeekView @JvmOverloads constructor(context: Context, attrs: AttributeSet?
         if (mEvents == null)
             mEvents = ArrayList()
 
-        if (weekViewLoader == null && !isInEditMode)
+        if (this.weekViewLoader == null && !isInEditMode)
             throw IllegalStateException("You must provide a MonthChangeListener")
 
         // If a refresh was requested then reset some variables.
@@ -1833,18 +1858,16 @@ class WeekView @JvmOverloads constructor(context: Context, attrs: AttributeSet?
             mFetchedPeriod = -1
         }
 
-        if (weekViewLoader != null) {
-            val periodToFetch = weekViewLoader!!.toWeekViewPeriodIndex(day).toInt()
-            if (!isInEditMode && (mFetchedPeriod < 0 || mFetchedPeriod != periodToFetch || mRefreshEvents)) {
-                val newEvents = weekViewLoader!!.onLoad(periodToFetch)
+        val periodToFetch = this.weekViewLoader.toWeekViewPeriodIndex(day).toInt()
+        if (!isInEditMode && (mFetchedPeriod < 0 || mFetchedPeriod != periodToFetch || mRefreshEvents)) {
+            val newEvents = this.weekViewLoader.onLoad(periodToFetch)
 
-                // Clear events.
-                this.clearEvents()
-                cacheAndSortEvents(newEvents)
-                calculateHeaderHeight()
+            // Clear events.
+            this.clearEvents()
+            cacheAndSortEvents(newEvents)
+            calculateHeaderHeight()
 
-                mFetchedPeriod = periodToFetch
-            }
+            mFetchedPeriod = periodToFetch
         }
 
         // Prepare to calculate positions of each events.
@@ -2427,12 +2450,12 @@ class WeekView @JvmOverloads constructor(context: Context, attrs: AttributeSet?
             goToNearestOrigin()
 
             // Calculate focused point for scale action
-            if (isZoomFocusPointEnabled) {
+            mFocusedPointY = if (isZoomFocusPointEnabled) {
                 // Use fractional focus, percentage of height
-                mFocusedPointY = (height.toFloat() - mHeaderHeight - (weekDaysHeaderRowPadding * 2).toFloat() - spaceBelowAllDayEvents) * zoomFocusPoint
+                (height.toFloat() - mHeaderHeight - (weekDaysHeaderRowPadding * 2).toFloat() - spaceBelowAllDayEvents) * zoomFocusPoint
             } else {
                 // Grab focus
-                mFocusedPointY = detector.focusY
+                detector.focusY
             }
 
             return true
diff --git a/library/src/main/java/com/alamkanak/weekview/WeekViewEvent.kt b/library/src/main/java/com/alamkanak/weekview/WeekViewEvent.kt
@@ -78,7 +78,7 @@ class WeekViewEvent {
      * @param allDay    Is the event an all day event.
      * @param shader    the Shader of the event rectangle
      */
-    @JvmOverloads constructor(id: String, name: String?, location: String?, startTime: Calendar, endTime: Calendar, allDay: Boolean = false, shader: Shader? = null) {
+    @JvmOverloads constructor(id: String?, name: String?, location: String?, startTime: Calendar, endTime: Calendar, allDay: Boolean = false, shader: Shader? = null) {
         this.identifier = id
         this.name = name
         this.location = location
@@ -96,7 +96,7 @@ class WeekViewEvent {
      * @param startTime The time when the event starts.
      * @param endTime   The time when the event ends.
      */
-    constructor(id: String, name: String, startTime: Calendar, endTime: Calendar) : this(id, name, null, startTime, endTime) {}
+    constructor(id: String?, name: String, startTime: Calendar, endTime: Calendar) : this(id, name, null, startTime, endTime)
 
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
@@ -111,6 +111,7 @@ class WeekViewEvent {
         return identifier!!.hashCode()
     }
 
+
     fun splitWeekViewEvents(): MutableList<WeekViewEvent> {
         //This function splits the WeekViewEvent in WeekViewEvents by day
         val events = ArrayList<WeekViewEvent>()
@@ -156,4 +157,16 @@ class WeekViewEvent {
 
         return events
     }
+
+    override fun toString(): String {
+        if (isAllDay)
+            return "WeekViewEvent(identifier=$identifier, time=${WeekViewUtil.calendarToString(startTime, false)}, name=$name, location=$location, color=$color, isAllDay=$isAllDay, shader=$shader)"
+        val startTimeText = if (startTime == null) null
+        else startTime!!.get(Calendar.YEAR).toString() + "-" + (startTime!!.get(Calendar.MONTH) + 1).toString() + "-" + startTime!!.get(Calendar.DAY_OF_MONTH).toString() + " " +
+                startTime!!.get(Calendar.HOUR_OF_DAY).toString() + ":" + startTime!!.get(Calendar.MINUTE) + ":" + startTime!!.get(Calendar.SECOND) + "." + startTime!!.get(Calendar.MILLISECOND)
+        val endTimeText = if (endTime == null) null
+        else endTime!!.get(Calendar.YEAR).toString() + "-" + (endTime!!.get(Calendar.MONTH) + 1).toString() + "-" + endTime!!.get(Calendar.DAY_OF_MONTH).toString() + " " +
+                endTime!!.get(Calendar.HOUR_OF_DAY).toString() + ":" + endTime!!.get(Calendar.MINUTE) + ":" + endTime!!.get(Calendar.SECOND) + "." + endTime!!.get(Calendar.MILLISECOND)
+        return "WeekViewEvent(identifier=$identifier, startTime=$startTimeText, endTime=$endTimeText, name=$name, location=$location, color=$color, isAllDay=$isAllDay, shader=$shader)"
+    }
 }
diff --git a/library/src/main/java/com/alamkanak/weekview/WeekViewLoader.kt b/library/src/main/java/com/alamkanak/weekview/WeekViewLoader.kt
@@ -3,6 +3,7 @@ package com.alamkanak.weekview
 import java.util.*
 
 interface WeekViewLoader {
+
     /**
      * Convert a date into a double that will be used to reference when you're loading data.
      *
diff --git a/library/src/main/java/com/alamkanak/weekview/WeekViewUtil.kt b/library/src/main/java/com/alamkanak/weekview/WeekViewUtil.kt
@@ -130,4 +130,19 @@ object WeekViewUtil {
             return SimpleDateFormat(defaultDateFormatPattern, Locale.getDefault())
         }
     }
+
+    @JvmStatic
+    fun calendarToString(cal: Calendar?, includeTime: Boolean = true): String {
+        if (cal == null)
+            return ""
+        val sb = StringBuilder()
+        with(cal) {
+            sb.append(get(Calendar.YEAR).toString()).append('-').append((get(Calendar.MONTH) + 1).toString())
+                    .append('-').append(get(Calendar.DAY_OF_MONTH).toString())
+            if (includeTime)
+                sb.append(get(Calendar.HOUR_OF_DAY).toString()).append(':').append(get(Calendar.MINUTE).toString()).append(':')
+                        .append(get(Calendar.SECOND).toString()).append('.').append(get(Calendar.MILLISECOND).toString())
+        }
+        return sb.toString()
+    }
 }
diff --git a/sample/src/main/java/com/alamkanak/weekview/sample/BaseActivity.kt b/sample/src/main/java/com/alamkanak/weekview/sample/BaseActivity.kt
@@ -202,10 +202,10 @@ abstract class BaseActivity : AppCompatActivity(), WeekView.EventClickListener,
 
     protected fun getEventTitle(cal: Calendar, endCal: Calendar? = null): String {
         val date = cal.time
-        if (endCal == null)
-            return "${shortDateFormat.format(date)} ${timeFormat.format(date)}"
+        return if (endCal == null)
+            "${shortDateFormat.format(date)} ${timeFormat.format(date)}"
         else
-            return "${shortDateFormat.format(date)} ${timeFormat.format(date)}..${timeFormat.format(endCal.time)}"
+            "${shortDateFormat.format(date)} ${timeFormat.format(date)}..${timeFormat.format(endCal.time)}"
 //        return String.format("%02d:%02d %s/%d", time.get(Calendar.HOUR_OF_DAY), time.get(Calendar.MINUTE), time.get(Calendar.MONTH) + 1, time.get(Calendar.DAY_OF_MONTH))
     }
 
@@ -238,8 +238,8 @@ abstract class BaseActivity : AppCompatActivity(), WeekView.EventClickListener,
     }
 
     companion object {
-        val TYPE_DAY_VIEW = 1
-        val TYPE_THREE_DAY_VIEW = 2
-        val TYPE_WEEK_VIEW = 3
+        const val TYPE_DAY_VIEW = 1
+        const val TYPE_THREE_DAY_VIEW = 2
+        const val TYPE_WEEK_VIEW = 3
     }
 }
diff --git a/sample/src/main/res/layout/activity_main.xml b/sample/src/main/res/layout/activity_main.xml
@@ -1,6 +1,6 @@
 <LinearLayout
     xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools"
-    android:layout_width="match_parent" android:layout_height="match_parent" android:background="#fff"
+    android:layout_width="match_parent" android:layout_height="match_parent"
     android:orientation="vertical" tools:context=".MainActivity">
 
     <Button

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ buildscript {`
`7`	`7`	`google()`
`8`	`8`	`}`
`9`	`9`	`dependencies {`
`10`		`- classpath 'com.android.tools.build:gradle:3.2.0-alpha14'`
	`10`	`+ classpath 'com.android.tools.build:gradle:3.2.0-alpha15'`
`11`	`11`	`classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"`
`12`	`12`
`13`	`13`	`// NOTE: Do not place your application dependencies here; they belong`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@ package com.alamkanak.weekview`
`3`	`3`	`import java.util.*`
`4`	`4`
`5`	`5`	`interface WeekViewLoader {`
	`6`	`+`
`6`	`7`	`/**`
`7`	`8`	`* Convert a date into a double that will be used to reference when you're loading data.`
`8`	`9`	`*`
Original file line number	Diff line number	Diff line change
`@@ -202,10 +202,10 @@ abstract class BaseActivity : AppCompatActivity(), WeekView.EventClickListener,`
`202`	`202`
`203`	`203`	`protected fun getEventTitle(cal: Calendar, endCal: Calendar? = null): String {`
`204`	`204`	`val date = cal.time`
`205`		`- if (endCal == null)`
`206`		`- return "${shortDateFormat.format(date)} ${timeFormat.format(date)}"`
	`205`	`+ return if (endCal == null)`
	`206`	`+ "${shortDateFormat.format(date)} ${timeFormat.format(date)}"`
`207`	`207`	`else`
`208`		`- return "${shortDateFormat.format(date)} ${timeFormat.format(date)}..${timeFormat.format(endCal.time)}"`
	`208`	`+ "${shortDateFormat.format(date)} ${timeFormat.format(date)}..${timeFormat.format(endCal.time)}"`
`209`	`209`	`// return String.format("%02d:%02d %s/%d", time.get(Calendar.HOUR_OF_DAY), time.get(Calendar.MINUTE), time.get(Calendar.MONTH) + 1, time.get(Calendar.DAY_OF_MONTH))`
`210`	`210`	`}`
`211`	`211`
`@@ -238,8 +238,8 @@ abstract class BaseActivity : AppCompatActivity(), WeekView.EventClickListener,`
`238`	`238`	`}`
`239`	`239`
`240`	`240`	`companion object {`
`241`		`- val TYPE_DAY_VIEW = 1`
`242`		`- val TYPE_THREE_DAY_VIEW = 2`
`243`		`- val TYPE_WEEK_VIEW = 3`
	`241`	`+ const val TYPE_DAY_VIEW = 1`
	`242`	`+ const val TYPE_THREE_DAY_VIEW = 2`
	`243`	`+ const val TYPE_WEEK_VIEW = 3`
`244`	`244`	`}`
`245`	`245`	`}`