Simplify EventsCaches and change behavior of PagedEventsCache

The PagedEventsCache will now cache all events submitted to it until refresh() is called on WeekView.PagingAdapter.

Author: thellmund

core/src/main/java/com/alamkanak/weekview/CalendarRenderer.kt

@@ -234,8 +234,15 @@ private class SingleEventsDrawer(
     private val eventChipDrawer = EventChipDrawer(viewState)
 
     override fun draw(canvas: Canvas) {
-        for (date in viewState.dateRange) {
-            drawEventsForDate(date, canvas)
+        canvas.drawInBounds(
+            left = viewState.timeColumnWidth,
+            top = viewState.headerHeight,
+            right = viewState.viewWidth.toFloat(),
+            bottom = viewState.viewHeight.toFloat()
+        ) {
+            for (date in viewState.dateRange) {
+                drawEventsForDate(date, canvas)
+            }
         }
     }
 

core/src/main/java/com/alamkanak/weekview/CanvasExtensions.kt

@@ -10,7 +10,7 @@ fun Canvas.withTranslation(x: Float, y: Float, block: Canvas.() -> Unit) {
     restore()
 }
 
-fun Canvas.drawInRect(
+fun Canvas.drawInBounds(
     left: Float,
     top: Float,
     right: Float,

core/src/main/java/com/alamkanak/weekview/DateTimeInterpreter.kt

@@ -2,6 +2,7 @@ package com.alamkanak.weekview
 
 import java.util.Calendar
 
+@Deprecated("Use setDateFormatter() and setTimeFormatter() instead.")
 interface DateTimeInterpreter {
     fun onSetNumberOfDays(days: Int) {
         // Free ad space

core/src/main/java/com/alamkanak/weekview/EventChipDrawer.kt

@@ -72,11 +72,11 @@ internal class EventChipDrawer(
         }
 
         if (event.style.borderWidth != null) {
-            drawStroke(eventChip, canvas)
+            drawBorderStroke(eventChip, canvas)
         }
     }
 
-    private fun drawStroke(
+    private fun drawBorderStroke(
         eventChip: EventChip,
         canvas: Canvas
     ) {
@@ -185,20 +185,20 @@ internal class EventChipDrawer(
     private fun updateBackgroundPaint(
         event: ResolvedWeekViewEvent<*>,
         paint: Paint
-    ) {
-        paint.color = event.style.backgroundColor ?: viewState.defaultEventColor
-        paint.isAntiAlias = true
-        paint.strokeWidth = 0f
-        paint.style = Paint.Style.FILL
+    ) = with(paint) {
+        color = event.style.backgroundColor ?: viewState.defaultEventColor
+        isAntiAlias = true
+        strokeWidth = 0f
+        style = Paint.Style.FILL
     }
 
     private fun updateBorderPaint(
         event: ResolvedWeekViewEvent<*>,
         paint: Paint
-    ) {
-        paint.color = event.style.borderColor ?: viewState.defaultEventColor
-        paint.isAntiAlias = true
-        paint.strokeWidth = event.style.borderWidth?.toFloat() ?: 0f
-        paint.style = Paint.Style.STROKE
+    ) = with(paint) {
+        color = event.style.borderColor ?: viewState.defaultEventColor
+        isAntiAlias = true
+        strokeWidth = event.style.borderWidth?.toFloat() ?: 0f
+        style = Paint.Style.STROKE
     }
 }

core/src/main/java/com/alamkanak/weekview/EventsCache.kt

@@ -1,51 +1,18 @@
 package com.alamkanak.weekview
 
-import androidx.annotation.VisibleForTesting
+import androidx.collection.ArrayMap
 import java.util.Calendar
 
-// /**
-// * Wraps all available [EventsCache]s to allow for dynamic switching between them.
-// */
-// internal class EventsCacheWrapper<T> {
-//
-//    private val simpleEventsCache: EventsCache<T> = SimpleEventsCache()
-//    private val pagedEventsCache: EventsCache<T> = PagedEventsCache()
-//
-//    private var currentEventsCache = simpleEventsCache
-//
-//    /**
-//     * Returns the [EventsCache] that is currently in use.
-//     */
-//    fun get() = currentEventsCache
-//
-//    /**
-//     * Switches the currently used [EventsCache] to a [PagedEventsCache] (if [listener] is not null)
-//     * or [SimpleEventsCache] (otherwise).
-//     */
-//    fun onListenerChanged(listener: OnMonthChangeListener<T>?) {
-//        currentEventsCache = if (listener != null) pagedEventsCache else simpleEventsCache
-//    }
-//
-//    /**
-//     * Switches the currently used [EventsCache] to a [PagedEventsCache] (if [listener] is not null)
-//     * or [SimpleEventsCache] (otherwise).
-//     */
-//    fun onListenerChanged(listener: OnLoadMoreListener?) {
-//        currentEventsCache = if (listener != null) pagedEventsCache else simpleEventsCache
-//    }
-// }
-
 /**
  * An abstract class that provides functionality to cache [WeekViewEvent]s.
  */
 internal abstract class EventsCache<T> {
 
     abstract val allEvents: List<ResolvedWeekViewEvent<T>>
+    abstract fun update(events: List<ResolvedWeekViewEvent<T>>)
     abstract fun clear()
 
-    operator fun get(id: Long): ResolvedWeekViewEvent<T>? {
-        return allEvents.firstOrNull { it.id == id }
-    }
+    operator fun get(id: Long): ResolvedWeekViewEvent<T>? = allEvents.firstOrNull { it.id == id }
 
     operator fun get(
         dateRange: List<Calendar>
@@ -62,8 +29,6 @@ internal abstract class EventsCache<T> {
         val endTime = fetchRange.next.endDate
         return allEvents.filter { it.endTime >= startTime && it.startTime <= endTime }
     }
-
-    open operator fun get(period: Period): List<ResolvedWeekViewEvent<T>>? = null
 }
 
 /**
@@ -77,7 +42,7 @@ internal class SimpleEventsCache<T> : EventsCache<T>() {
     override val allEvents: List<ResolvedWeekViewEvent<T>>
         get() = _allEvents.orEmpty()
 
-    fun update(events: List<ResolvedWeekViewEvent<T>>) {
+    override fun update(events: List<ResolvedWeekViewEvent<T>>) {
         _allEvents = events
     }
 
@@ -87,103 +52,34 @@ internal class SimpleEventsCache<T> : EventsCache<T>() {
 }
 
 /**
- * Represents an [EventsCache] that caches [WeekViewEvent]s for a particular [FetchRange].
+ * Represents an [EventsCache] that caches [ResolvedWeekViewEvent]s for their respective [Period]
+ * and allows retrieval based on that [Period].
  */
 internal class PagedEventsCache<T> : EventsCache<T>() {
 
     override val allEvents: List<ResolvedWeekViewEvent<T>>
-        get() = previousPeriodEvents.orEmpty() +
-            currentPeriodEvents.orEmpty() +
-            nextPeriodEvents.orEmpty()
-
-    private var previousPeriodEvents: List<ResolvedWeekViewEvent<T>>? = null
-    private var currentPeriodEvents: List<ResolvedWeekViewEvent<T>>? = null
-    private var nextPeriodEvents: List<ResolvedWeekViewEvent<T>>? = null
-
-    @VisibleForTesting
-    internal var fetchedRange: FetchRange? = null
+        get() = eventsByPeriod.values.flatten()
 
-    operator fun contains(period: Period) = fetchedRange?.periods?.contains(period) ?: false
+    private val eventsByPeriod: ArrayMap<Period, List<ResolvedWeekViewEvent<T>>> = ArrayMap()
 
-    operator fun contains(fetchRange: FetchRange) = fetchedRange?.isEqual(fetchRange) ?: false
-
-    override fun get(period: Period): List<ResolvedWeekViewEvent<T>>? {
-        val range = checkNotNull(fetchedRange)
-        return when (period) {
-            range.previous -> previousPeriodEvents
-            range.current -> currentPeriodEvents
-            range.next -> nextPeriodEvents
-            else -> throw IllegalStateException("Requesting events for invalid period $period")
+    override fun update(events: List<ResolvedWeekViewEvent<T>>) {
+        val groupedEvents = events.groupBy { Period.fromDate(it.startTime) }
+        for ((period, periodEvents) in groupedEvents) {
+            eventsByPeriod[period] = periodEvents
         }
     }
 
-    /**
-     * Adjusts the [WeekViewEvent]s of the fetched [Period]s to the new [FetchRange]. This means
-     * that if the user scrolled to the next month, the following would happen:
-     *  1. The events of the current month would be moved to [previousPeriodEvents].
-     *  2. The events of the next month would be moved to [currentPeriodEvents].
-     *  3. The events of the following month aren't loaded yet; [nextPeriodEvents] will be null.
-     *  4. The [fetchedRange] will be set to the provided [FetchRange].
-     *
-     * When scrolling to the previous month, the behavior would be like so:
-     *  1. The events of the current month would be moved to [nextPeriodEvents].
-     *  2. The events of the previous month would be moved to [currentPeriodEvents].
-     *  2. The events of the preceding month aren't loaded yet; [previousPeriodEvents] will be null.
-     *  4. The [fetchedRange] will be set to the provided [FetchRange].
-     */
-    fun adjustToFetchRange(fetchRange: FetchRange) {
-        val oldFetchRange = fetchedRange ?: fetchRange
-        val newCurrentPeriod = fetchRange.current
-
-        val previousEvents = when (newCurrentPeriod) {
-            oldFetchRange.previous -> null
-            oldFetchRange.next -> currentPeriodEvents
-            else -> previousPeriodEvents
-        }
+    internal fun determinePeriodsToFetch(range: FetchRange) = range.periods.filter { it !in this }
 
-        val currentEvents = when (newCurrentPeriod) {
-            oldFetchRange.previous -> previousPeriodEvents
-            oldFetchRange.next -> nextPeriodEvents
-            else -> currentPeriodEvents
-        }
+    operator fun contains(period: Period) = eventsByPeriod.contains(period)
 
-        val nextEvents = when (newCurrentPeriod) {
-            oldFetchRange.previous -> currentPeriodEvents
-            oldFetchRange.next -> null
-            else -> nextPeriodEvents
-        }
-
-        previousPeriodEvents = previousEvents
-        currentPeriodEvents = currentEvents
-        nextPeriodEvents = nextEvents
-        fetchedRange = fetchRange
-    }
-
-    fun update(eventsByPeriod: Map<Period, List<ResolvedWeekViewEvent<T>>>) {
-        for ((period, events) in eventsByPeriod) {
-            update(period, events)
-        }
-    }
-
-    private fun update(period: Period, events: List<ResolvedWeekViewEvent<T>>) {
-        val range = checkNotNull(fetchedRange)
-        when (period) {
-            range.previous -> previousPeriodEvents = events
-            range.current -> currentPeriodEvents = events
-            range.next -> nextPeriodEvents = events
-        }
-    }
+    operator fun contains(range: FetchRange) = eventsByPeriod.containsAll(range.periods)
 
-    operator fun set(
-        period: Period,
-        events: List<ResolvedWeekViewEvent<T>>
-    ) {
-        update(period, events)
+    fun reserve(period: Period) {
+        eventsByPeriod[period] = listOf()
     }
 
     override fun clear() {
-        previousPeriodEvents = null
-        currentPeriodEvents = null
-        nextPeriodEvents = null
+        eventsByPeriod.clear()
     }
 }

core/src/main/java/com/alamkanak/weekview/EventsDiffer.kt

@@ -61,15 +61,14 @@ internal class EventsDiffer<T>(
             return
         }
 
-        when (eventsCache) {
-            is SimpleEventsCache -> eventsCache.update(events)
-            is PagedEventsCache -> eventsCache.update(mapEventsToPeriod(events))
+        eventsCache.update(events)
+
+        if (eventsCache is SimpleEventsCache) {
+            // When using SimpleEventsCache, we completely replace all event chips that are
+            // currently cached.
+            eventChipsCache.clear()
         }
 
         eventChipsCache += eventChipsFactory.createEventChips(events, viewState)
     }
-
-    private fun mapEventsToPeriod(
-        events: List<ResolvedWeekViewEvent<T>>
-    ) = events.groupBy { Period.fromDate(it.startTime) }
 }

core/src/main/java/com/alamkanak/weekview/FloatExtensions.kt

@@ -140,7 +140,7 @@ private class DayLabelsDrawer(
         val right = canvas.width.toFloat()
         val bottom = viewState.getTotalHeaderHeight()
 
-        canvas.drawInRect(left, top, right, bottom) {
+        canvas.drawInBounds(left, top, right, bottom) {
             viewState.dateRangeWithStartPixels.forEach { (date, startPixel) ->
                 drawLabel(date, startPixel, this)
             }
@@ -319,7 +319,7 @@ internal class AllDayEventsDrawer(
         val right = canvas.width.toFloat()
         val bottom = viewState.getTotalHeaderHeight()
 
-        canvas.drawInRect(left, top, right, bottom) {
+        canvas.drawInBounds(left, top, right, bottom) {
             for ((eventChip, textLayout) in allDayEventLayouts) {
                 eventChipDrawer.draw(eventChip, canvas, textLayout)
             }

core/src/main/java/com/alamkanak/weekview/HeaderRenderer.kt

@@ -10,8 +10,6 @@ internal data class FetchRange(
 
     val periods: List<Period> = listOf(previous, current, next)
 
-    fun isEqual(other: FetchRange) = this == other
-
     internal companion object {
         fun create(firstVisibleDay: Calendar): FetchRange {
             val current = Period.fromDate(firstVisibleDay)

core/src/main/java/com/alamkanak/weekview/Period.kt

@@ -846,6 +846,11 @@ private fun TypedArray.getInt(index: Int): Int? {
     return if (hasValue(index)) getInteger(index, 0) else null
 }
 
+private fun Float.limit(
+    minValue: Float,
+    maxValue: Float
+): Float = min(max(this, minValue), maxValue)
+
 private object Defaults {
     const val BACKGROUND_COLOR = Color.WHITE
     val PAST_BACKGROUND_COLOR = Color.rgb(227, 227, 227)