Load next/previous weeks on scroll

Author: alllexey

app/src/main/java/me/alllexey123/itmowidgets/ui/schedule/ScheduleActivity.kt

@@ -46,11 +46,12 @@ class ScheduleActivity : AppCompatActivity() {
 
         observeUiState()
 
-        scheduleViewModel.fetchScheduleData(forceRefresh = false)
 
         swipeRefreshLayout.setOnRefreshListener {
             scheduleViewModel.fetchScheduleData(forceRefresh = true)
         }
+
+        scheduleViewModel.fetchScheduleData(forceRefresh = false)
     }
 
     private fun setupButtons() {
@@ -75,6 +76,25 @@ class ScheduleActivity : AppCompatActivity() {
         outerRecyclerView.adapter = dayScheduleAdapter
 
         snapHelper.attachToRecyclerView(outerRecyclerView)
+
+        outerRecyclerView.addOnScrollListener(object : RecyclerView.OnScrollListener() {
+            override fun onScrolled(recyclerView: RecyclerView, dx: Int, dy: Int) {
+                super.onScrolled(recyclerView, dx, dy)
+                val layoutManager = recyclerView.layoutManager as LinearLayoutManager
+                val firstVisibleItemPosition = layoutManager.findFirstVisibleItemPosition()
+                val lastVisibleItemPosition = layoutManager.findLastVisibleItemPosition()
+                val totalItemCount = dayScheduleAdapter.itemCount
+
+                if (totalItemCount > 0) {
+                    if (firstVisibleItemPosition < 2) {
+                        scheduleViewModel.fetchPreviousDays()
+                    }
+                    if (lastVisibleItemPosition > totalItemCount - 3) {
+                        scheduleViewModel.fetchNextDays()
+                    }
+                }
+            }
+        })
     }
 
     private var isInitialLoad = true

app/src/main/java/me/alllexey123/itmowidgets/ui/schedule/ScheduleViewModel.kt

@@ -23,14 +23,19 @@ class ScheduleViewModel(
     private val _uiState = MutableLiveData<ScheduleUiState>()
     val uiState: LiveData<ScheduleUiState> = _uiState
 
+    private var isLoading = false
+    private var dateRange: ClosedRange<LocalDate>? = null
+
     fun fetchScheduleData(forceRefresh: Boolean) {
+        if (isLoading) return
+        isLoading = true
+
         viewModelScope.launch {
             try {
-                val startDate = LocalDate.now().minusDays(7)
-                val endDate = LocalDate.now().plusDays(7)
+                val startDate = dateRange?.start ?: LocalDate.now().minusDays(7)
+                val endDate = dateRange?.endInclusive ?: LocalDate.now().plusDays(7)
 
-                val cachedSchedule =
-                    scheduleRepository.getCachedScheduleForRange(startDate, endDate)
+                val cachedSchedule = scheduleRepository.getCachedScheduleForRange(startDate, endDate)
 
                 if (cachedSchedule.isNotEmpty() && !forceRefresh) {
 
@@ -48,10 +53,100 @@ class ScheduleViewModel(
                     val remoteSchedule = scheduleRepository.getScheduleForRange(startDate, endDate)
                     _uiState.postValue(ScheduleUiState.Success(remoteSchedule, false))
                 }
+                dateRange = startDate..endDate
+            } catch (e: Exception) {
+                val errorMessage = "Failed to update schedule: ${e.message}"
+                _uiState.postValue(ScheduleUiState.Error(errorMessage))
+                e.printStackTrace()
+            } finally {
+                isLoading = false
+            }
+        }
+    }
+
+    fun fetchPreviousDays() {
+        if (isLoading) return
+        isLoading = true
+
+        viewModelScope.launch {
+            val currentSchedule = (_uiState.value as? ScheduleUiState.Success)?.schedule ?: emptyList()
+            try {
+                val currentStartDate = dateRange?.start ?: LocalDate.now()
+                val newStartDate = currentStartDate.minusDays(7)
+                val newEndDate = currentStartDate.minusDays(1)
+
+                val cachedSchedule = scheduleRepository.getCachedScheduleForRange(newStartDate, newEndDate)
+                val remoteSchedule = if (cachedSchedule.isNotEmpty()) {
+                    val totalDays = Duration.between(newStartDate.atStartOfDay(), newEndDate.atStartOfDay()).toDays() + 1
+
+                    if (cachedSchedule.size < totalDays) {
+                        _uiState.postValue(ScheduleUiState.Loading)
+                        scheduleRepository.getScheduleForRange(newStartDate, newEndDate)
+                    } else {
+                        cachedSchedule
+                    }
+                } else {
+                    _uiState.value = ScheduleUiState.Loading
+                    scheduleRepository.getScheduleForRange(newStartDate, newEndDate)
+                }
+
+                val updatedSchedule = (remoteSchedule + currentSchedule).distinctBy { it.date }.sortedBy { it.date }
+                _uiState.postValue(ScheduleUiState.Success(updatedSchedule, false))
+                dateRange = newStartDate..(dateRange?.endInclusive ?: LocalDate.now())
+            } catch (e: Exception) {
+                val errorMessage = "Failed to update schedule: ${e.message}"
+                _uiState.postValue(ScheduleUiState.Error(errorMessage))
+                _uiState.postValue(ScheduleUiState.Success(currentSchedule, false))
+                e.printStackTrace()
+            } finally {
+                isLoading = false
+            }
+        }
+    }
+
+    fun fetchNextDays() {
+        if (isLoading) return
+        isLoading = true
+
+        viewModelScope.launch {
+            val currentSchedule =
+                (_uiState.value as? ScheduleUiState.Success)?.schedule ?: emptyList()
+            try {
+
+                val currentEndDate = dateRange?.endInclusive ?: LocalDate.now()
+                val newStartDate = currentEndDate.plusDays(1)
+                val newEndDate = currentEndDate.plusDays(7)
+
+                val cachedSchedule =
+                    scheduleRepository.getCachedScheduleForRange(newStartDate, newEndDate)
+                val remoteSchedule = if (cachedSchedule.isNotEmpty()) {
+                    val totalDays =
+                        Duration.between(newStartDate.atStartOfDay(), newEndDate.atStartOfDay())
+                            .toDays() + 1
+
+                    if (cachedSchedule.size < totalDays) {
+                        _uiState.postValue(ScheduleUiState.Loading)
+                        scheduleRepository.getScheduleForRange(newStartDate, newEndDate)
+                    } else {
+                        cachedSchedule
+                    }
+                } else {
+                    _uiState.value = ScheduleUiState.Loading
+                    scheduleRepository.getScheduleForRange(newStartDate, newEndDate)
+                }
+
+                val updatedSchedule =
+                    (currentSchedule + remoteSchedule).distinctBy { it.date }.sortedBy { it.date }
+                _uiState.postValue(ScheduleUiState.Success(updatedSchedule, false))
+
+                dateRange = (dateRange?.start ?: LocalDate.now())..newEndDate
             } catch (e: Exception) {
                 val errorMessage = "Failed to update schedule: ${e.message}"
                 _uiState.postValue(ScheduleUiState.Error(errorMessage))
+                _uiState.postValue(ScheduleUiState.Success(currentSchedule, false))
                 e.printStackTrace()
+            } finally {
+                isLoading = false
             }
         }
     }