Skip to content

StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.

Fix TV guide loading and EPG fallback performance

David Nashash6f12017159a0
diff --git a/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgViewModel.kt
index b3693c2b..38e6a4b8 100644
--- a/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgViewModel.kt
+++ b/app/src/main/java/com/streamvault/app/ui/screens/epg/EpgViewModel.kt
@@ -216,6 +216,15 @@ private data class CombinedGuideRequest(
val providerIds: List<Long>
)
+private data class GuideFallbackContext(
+ val providerId: Long,
+ val selectedCategoryId: Long,
+ val guideAnchorTime: Long,
+ val guideWindowStart: Long,
+ val guideWindowEnd: Long,
+ val visibleChannelIds: List<Long>
+)
+
@HiltViewModel
@OptIn(ExperimentalCoroutinesApi::class, FlowPreview::class)
class EpgViewModel @Inject constructor(
@@ -235,7 +244,8 @@ class EpgViewModel @Inject constructor(
companion object {
const val MAX_CHANNELS = 60
- private const val MAX_XTREAM_GUIDE_FALLBACK_CHANNELS = 24
+ private const val MAX_XTREAM_GUIDE_FALLBACK_CHANNELS = 10
+ private const val MAX_XTREAM_GUIDE_FALLBACK_PROGRAMS = 6
const val LOOKBACK_MS = 60 * 60 * 1000L
const val LOOKAHEAD_MS = 6 * 60 * 60 * 1000L
const val HALF_HOUR_SHIFT_MS = 30 * 60 * 1000L
@@ -264,6 +274,7 @@ class EpgViewModel @Inject constructor(
private val _programReminderUiState = MutableStateFlow(ProgramReminderUiState())
val programReminderUiState: StateFlow<ProgramReminderUiState> = _programReminderUiState.asStateFlow()
private var overrideSearchJob: Job? = null
+ private var guideFallbackJob: Job? = null
private var combinedCategoriesById: Map<Long, CombinedCategory> = emptyMap()
init {
@@ -620,6 +631,7 @@ class EpgViewModel @Inject constructor(
old.first == new.first && old.second?.id == new.second?.id
}.collectLatest { (activeSource, activeProvider) ->
if (activeSource == null && activeProvider == null) {
+ guideFallbackJob?.cancel()
baseGuideSnapshot.value = null
_uiState.update {
it.copy(
@@ -765,6 +777,13 @@ class EpgViewModel @Inject constructor(
favoriteChannelIds = favoriteIds
)
}.collectLatest { channelSelection ->
+ val visibleChannels = channelSelection.channels.take(MAX_CHANNELS)
+ val guideResult = loadGuidePrograms(
+ providerId = provider.id,
+ channels = visibleChannels,
+ windowStart = request.windowStart,
+ windowEnd = request.windowEnd
+ )
publishGuideSnapshot(
providerId = provider.id,
providerName = provider.name,
@@ -776,15 +795,19 @@ class EpgViewModel @Inject constructor(
categories = categories,
request = request,
channelSelection = channelSelection,
- guideResult = loadGuidePrograms(
- provider = provider,
+ guideResult = guideResult
+ )
+ scheduleGuideFallbackEnrichment(
+ snapshotContext = GuideFallbackContext(
providerId = provider.id,
- channels = channelSelection.channels.take(MAX_CHANNELS),
- categoryId = request.resolvedCategoryId,
- favoritesOnly = request.favoritesOnly,
- windowStart = request.windowStart,
- windowEnd = request.windowEnd
- )
+ selectedCategoryId = request.resolvedCategoryId,
+ guideAnchorTime = request.anchorTime,
+ guideWindowStart = request.windowStart,
+ guideWindowEnd = request.windowEnd,
+ visibleChannelIds = visibleChannels.map(Channel::id)
+ ),
+ channels = visibleChannels,
+ existingProgramsByChannel = guideResult.programsByChannel
)
finalizeStartupCategory(request.resolvedCategoryId)
}
@@ -885,6 +908,12 @@ class EpgViewModel @Inject constructor(
favoriteChannelIds = favoriteIds
)
}.collectLatest { channelSelection ->
+ val visibleChannels = channelSelection.channels.take(MAX_CHANNELS)
+ val guideResult = loadCombinedGuidePrograms(
+ channels = visibleChannels,
+ windowStart = request.windowStart,
+ windowEnd = request.windowEnd
+ )
publishGuideSnapshot(
providerId = 0L,
providerName = profileName,
@@ -893,11 +922,19 @@ class EpgViewModel @Inject constructor(
categories = categories,
request = request,
channelSelection = channelSelection,
- guideResult = loadCombinedGuidePrograms(
- channels = channelSelection.channels.take(MAX_CHANNELS),
- windowStart = request.windowStart,
- windowEnd = request.windowEnd
- )
+ guideResult = guideResult
+ )
+ scheduleGuideFallbackEnrichment(
+ snapshotContext = GuideFallbackContext(
+ providerId = 0L,
+ selectedCategoryId = request.resolvedCategoryId,
+ guideAnchorTime = request.anchorTime,
+ guideWindowStart = request.windowStart,
+ guideWindowEnd = request.windowEnd,
+ visibleChannelIds = visibleChannels.map(Channel::id)
+ ),
+ channels = visibleChannels,
+ existingProgramsByChannel = guideResult.programsByChannel
)
finalizeStartupCategory(request.resolvedCategoryId)
}
@@ -1203,11 +1240,8 @@ class EpgViewModel @Inject constructor(
}
private suspend fun loadGuidePrograms(
- provider: com.streamvault.domain.model.Provider,
providerId: Long,
channels: List<Channel>,
- categoryId: Long,
- favoritesOnly: Boolean,
windowStart: Long,
windowEnd: Long
): GuideProgramsResult {
@@ -1243,20 +1277,9 @@ class EpgViewModel @Inject constructor(
val programsByChannel = resolvedPrograms + legacyPrograms
- // 3. Xtream on-demand fallback for still-missing channels
- val fallbackProgramsByChannel = fetchXtreamGuideFallback(
- provider = provider,
- providerId = providerId,
- channels = channels,
- existingProgramsByChannel = programsByChannel,
- windowStart = windowStart,
- windowEnd = windowEnd
- )
- val mergedProgramsByChannel = programsByChannel + fallbackProgramsByChannel
-
GuideProgramsResult(
- programsByChannel = mergedProgramsByChannel,
- failedCount = guideKeys.count { lookupKey -> mergedProgramsByChannel[lookupKey].isNullOrEmpty() }
+ programsByChannel = programsByChannel,
+ failedCount = countMissingGuideEntries(channels, programsByChannel)
)
}
}
@@ -1276,19 +1299,9 @@ class EpgViewModel @Inject constructor(
val mergedProgramsByChannel = buildMap<String, List<Program>> {
groupedPrograms.forEach { (providerId, providerChannels) ->
- val provider = providerRepository.getProvider(providerId)
- ?: com.streamvault.domain.model.Provider(
- id = providerId,
- name = "M3U Provider",
- type = com.streamvault.domain.model.ProviderType.M3U,
- serverUrl = ""
- )
val result = loadGuidePrograms(
- provider = provider,
providerId = providerId,
channels = providerChannels,
- categoryId = ChannelRepository.ALL_CHANNELS_ID,
- favoritesOnly = false,
windowStart = windowStart,
windowEnd = windowEnd
)
@@ -1298,10 +1311,61 @@ class EpgViewModel @Inject constructor(
val guideKeys = channels.mapNotNull(Channel::guideLookupKey).distinct()
return GuideProgramsResult(
programsByChannel = mergedProgramsByChannel,
- failedCount = guideKeys.count { lookupKey -> mergedProgramsByChannel[lookupKey].isNullOrEmpty() }
+ failedCount = countMissingGuideEntries(channels, mergedProgramsByChannel)
)
}
+ private fun scheduleGuideFallbackEnrichment(
+ snapshotContext: GuideFallbackContext,
+ channels: List<Channel>,
+ existingProgramsByChannel: Map<String, List<Program>>
+ ) {
+ guideFallbackJob?.cancel()
+ if (channels.isEmpty()) {
+ guideFallbackJob = null
+ return
+ }
+
+ guideFallbackJob = viewModelScope.launch {
+ val fallbackProgramsByChannel = buildMap {
+ channels.groupBy(Channel::providerId).forEach { (providerId, providerChannels) ->
+ val provider = providerRepository.getProvider(providerId) ?: return@forEach
+ val providerPrograms = fetchXtreamGuideFallback(
+ provider = provider,
+ providerId = providerId,
+ channels = providerChannels,
+ existingProgramsByChannel = existingProgramsByChannel + this,
+ windowStart = snapshotContext.guideWindowStart,
+ windowEnd = snapshotContext.guideWindowEnd
+ )
+ putAll(providerPrograms)
+ }
+ }
+ if (fallbackProgramsByChannel.isEmpty()) {
+ return@launch
+ }
+
+ baseGuideSnapshot.update { currentSnapshot ->
+ if (currentSnapshot == null || !currentSnapshot.matches(snapshotContext)) {
+ return@update currentSnapshot
+ }
+
+ val mergedProgramsByChannel = currentSnapshot.baseProgramsByChannel + fallbackProgramsByChannel
+ val visibleChannels = currentSnapshot.visibleChannels
+ val channelsWithSchedule = countChannelsWithSchedule(visibleChannels, mergedProgramsByChannel)
+ val hasUpcomingData = hasUpcomingGuideData(mergedProgramsByChannel, currentSnapshot.guideWindowStart)
+
+ currentSnapshot.copy(
+ baseProgramsByChannel = mergedProgramsByChannel,
+ failedScheduleCount = countMissingGuideEntries(visibleChannels, mergedProgramsByChannel),
+ lastUpdatedAt = System.currentTimeMillis(),
+ baseChannelsWithSchedule = channelsWithSchedule,
+ baseGuideStale = visibleChannels.isNotEmpty() && (channelsWithSchedule == 0 || !hasUpcomingData)
+ )
+ }
+ }
+ }
+
private suspend fun fetchXtreamGuideFallback(
provider: com.streamvault.domain.model.Provider,
providerId: Long,
@@ -1333,7 +1397,7 @@ class EpgViewModel @Inject constructor(
epgChannelId = channel.epgChannelId
)
},
- limit = 12
+ limit = MAX_XTREAM_GUIDE_FALLBACK_PROGRAMS
)
return fallbackChannels.mapNotNull { channel ->
@@ -1351,6 +1415,40 @@ class EpgViewModel @Inject constructor(
}.toMap()
}
+ private fun GuideBaseSnapshot.matches(context: GuideFallbackContext): Boolean =
+ providerId == context.providerId &&
+ selectedCategoryId == context.selectedCategoryId &&
+ guideAnchorTime == context.guideAnchorTime &&
+ guideWindowStart == context.guideWindowStart &&
+ guideWindowEnd == context.guideWindowEnd &&
+ visibleChannels.map(Channel::id) == context.visibleChannelIds
+
+ private fun countMissingGuideEntries(
+ channels: List<Channel>,
+ programsByChannel: Map<String, List<Program>>
+ ): Int =
+ channels.mapNotNull(Channel::guideLookupKey)
+ .distinct()
+ .count { lookupKey -> programsByChannel[lookupKey].isNullOrEmpty() }
+
+ private fun countChannelsWithSchedule(
+ channels: List<Channel>,
+ programsByChannel: Map<String, List<Program>>
+ ): Int =
+ channels.count { channel ->
+ channel.guideLookupKey()
+ ?.let { lookupKey -> programsByChannel[lookupKey].orEmpty().isNotEmpty() }
+ ?: false
+ }
+
+ private fun hasUpcomingGuideData(
+ programsByChannel: Map<String, List<Program>>,
+ windowStart: Long
+ ): Boolean =
+ programsByChannel.values.any { programs ->
+ programs.any { program -> program.endTime > windowStart }
+ }
+
private suspend fun buildGuideDisplaySnapshot(
baseSnapshot: GuideBaseSnapshot,
searchQuery: String,
diff --git a/app/src/test/java/com/streamvault/app/ui/screens/epg/EpgViewModelTest.kt b/app/src/test/java/com/streamvault/app/ui/screens/epg/EpgViewModelTest.kt
index ac6c5e3b..0ad9d4a3 100644
--- a/app/src/test/java/com/streamvault/app/ui/screens/epg/EpgViewModelTest.kt
+++ b/app/src/test/java/com/streamvault/app/ui/screens/epg/EpgViewModelTest.kt
@@ -1,6 +1,7 @@
package com.streamvault.app.ui.screens.epg
import com.google.common.truth.Truth.assertThat
+import com.google.common.truth.Truth.assertWithMessage
import androidx.lifecycle.ViewModel
import com.streamvault.data.preferences.PreferencesRepository
import com.streamvault.domain.manager.ParentalControlManager
@@ -24,6 +25,7 @@ import com.streamvault.domain.repository.CombinedM3uRepository
import com.streamvault.domain.repository.EpgRepository
import com.streamvault.domain.repository.EpgSourceRepository
import com.streamvault.domain.repository.FavoriteRepository
+import com.streamvault.domain.repository.LiveStreamProgramRequest
import com.streamvault.domain.repository.ProviderRepository
import com.streamvault.domain.usecase.GetCustomCategories
import com.streamvault.domain.usecase.ScheduleRecording
@@ -103,10 +105,10 @@ class EpgViewModelTest {
}
}
testDispatcher.scheduler.advanceUntilIdle()
- assertThat(condition()).isTrue()
+ assertWithMessage(createdViewModels.lastOrNull()?.uiState?.value.toString()).that(condition()).isTrue()
}
- private fun createViewModel(): EpgViewModel =
+ private fun createViewModel(providerRepository: ProviderRepository = this.providerRepository): EpgViewModel =
EpgViewModel(
providerRepository = providerRepository,
combinedM3uRepository = combinedM3uRepository,
diff --git a/data/src/main/java/com/streamvault/data/epg/EpgResolutionEngine.kt b/data/src/main/java/com/streamvault/data/epg/EpgResolutionEngine.kt
index 0559c935..0e8eacdd 100644
--- a/data/src/main/java/com/streamvault/data/epg/EpgResolutionEngine.kt
+++ b/data/src/main/java/com/streamvault/data/epg/EpgResolutionEngine.kt
@@ -267,8 +267,13 @@ class EpgResolutionEngine @Inject constructor(
if (mappings.isEmpty()) return@withContext emptyMap()
- // Also load channel entities to get epgChannelId for the lookup key
- val channels = channelDao.getByProviderSync(providerId)
+ val channels = if (channelIds.size <= 500) {
+ channelDao.getGuideLookupsByIds(channelIds)
+ } else {
+ channelIds.chunked(500).flatMap { chunk ->
+ channelDao.getGuideLookupsByIds(chunk)
+ }
+ }
val channelById = channels.associateBy { it.id }
val result = mutableMapOf<String, List<Program>>()
diff --git a/data/src/main/java/com/streamvault/data/local/dao/Daos.kt b/data/src/main/java/com/streamvault/data/local/dao/Daos.kt
index cc182d79..895ffd95 100644
--- a/data/src/main/java/com/streamvault/data/local/dao/Daos.kt
+++ b/data/src/main/java/com/streamvault/data/local/dao/Daos.kt
@@ -178,6 +178,15 @@ abstract class ChannelDao {
@Query("SELECT * FROM channels WHERE id = :id")
abstract suspend fun getById(id: Long): ChannelEntity?
+ @Query(
+ """
+ SELECT id, stream_id, epg_channel_id
+ FROM channels
+ WHERE id IN (:ids)
+ """
+ )
+ abstract suspend fun getGuideLookupsByIds(ids: List<Long>): List<ChannelGuideLookupEntity>
+
@Query("SELECT * FROM channels WHERE provider_id = :providerId")
abstract suspend fun getByProviderSync(providerId: Long): List<ChannelEntity>
diff --git a/data/src/main/java/com/streamvault/data/local/entity/Entities.kt b/data/src/main/java/com/streamvault/data/local/entity/Entities.kt
index 79821579..1d07400d 100644
--- a/data/src/main/java/com/streamvault/data/local/entity/Entities.kt
+++ b/data/src/main/java/com/streamvault/data/local/entity/Entities.kt
@@ -99,6 +99,12 @@ data class ChannelBrowseEntity(
@ColumnInfo(name = "error_count") val errorCount: Int = 0
)
+data class ChannelGuideLookupEntity(
+ val id: Long = 0,
+ @ColumnInfo(name = "stream_id") val streamId: Long = 0,
+ @ColumnInfo(name = "epg_channel_id") val epgChannelId: String? = null
+)
+
@Entity(
tableName = "channel_preferences",
foreignKeys = [ForeignKey(
diff --git a/data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.kt
index 28094073..7279ffb4 100644
--- a/data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.kt
@@ -42,6 +42,10 @@ class ProviderRepositoryImpl @Inject constructor(
private val syncMetadataRepository: SyncMetadataRepository,
private val transactionRunner: DatabaseTransactionRunner
) : ProviderRepository {
+ private companion object {
+ const val XTREAM_GUIDE_BATCH_CONCURRENCY = 4
+ }
+
private val repositoryScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
override fun getProviders(): Flow<List<Provider>> =
@@ -297,13 +301,20 @@ class ProviderRepositoryImpl @Inject constructor(
limit: Int
): Result<List<Program>> {
return when (val providerContextResult = createXtreamLiveProgramProviderContext(providerId)) {
- is Result.Success -> fetchXtreamProgramsForLiveStream(
- providerId = providerId,
- streamId = streamId,
- epgChannelId = epgChannelId,
- limit = limit,
- xtreamProvider = providerContextResult.data
- )
+ is Result.Success -> {
+ val result = fetchXtreamProgramsForLiveStream(
+ providerId = providerId,
+ streamId = streamId,
+ epgChannelId = epgChannelId,
+ limit = limit,
+ xtreamProvider = providerContextResult.data
+ )
+ if (result is Result.Success && result.data.isNotEmpty()) {
+ cacheProgramsForChannel(providerId, result.data)
+ refreshCachedEpgMetadata(providerId)
+ }
+ result
+ }
is Result.Error -> Result.error(providerContextResult.message, providerContextResult.exception)
is Result.Loading -> Result.error("Unexpected loading state")
}
@@ -323,9 +334,10 @@ class ProviderRepositoryImpl @Inject constructor(
return when (val providerContextResult = createXtreamLiveProgramProviderContext(providerId)) {
is Result.Success -> coroutineScope {
+ val requestDispatcher = Dispatchers.IO.limitedParallelism(XTREAM_GUIDE_BATCH_CONCURRENCY)
normalizedRequests
.map { request ->
- async {
+ async(requestDispatcher) {
request to fetchXtreamProgramsForLiveStream(
providerId = providerId,
streamId = request.streamId,
@@ -336,6 +348,15 @@ class ProviderRepositoryImpl @Inject constructor(
}
}
.awaitAll()
+ .also { results ->
+ val cachedPrograms = results
+ .mapNotNull { (_, result) -> (result as? Result.Success)?.data }
+ .flatten()
+ if (cachedPrograms.isNotEmpty()) {
+ cacheProgramsForChannels(providerId, cachedPrograms)
+ refreshCachedEpgMetadata(providerId)
+ }
+ }
.toMap()
}
is Result.Error -> normalizedRequests.associateWith { request ->
@@ -444,14 +465,13 @@ class ProviderRepositoryImpl @Inject constructor(
?.sortedBy { it.startTime }
.orEmpty()
if (shortPrograms.isNotEmpty()) {
- val normalizedPrograms = normalizeXtreamPrograms(
- providerId = providerId,
- channelId = epgChannelId ?: streamId.toString(),
- programs = shortPrograms
+ return Result.success(
+ normalizeXtreamPrograms(
+ providerId = providerId,
+ channelId = epgChannelId ?: streamId.toString(),
+ programs = shortPrograms
+ )
)
- cacheProgramsForChannel(providerId, normalizedPrograms)
- refreshCachedEpgMetadata(providerId)
- return Result.success(normalizedPrograms)
}
return when (val fullProgramsResult = xtreamProvider.getEpg(streamId.toString())) {
@@ -461,8 +481,6 @@ class ProviderRepositoryImpl @Inject constructor(
channelId = epgChannelId ?: streamId.toString(),
programs = fullProgramsResult.data.sortedBy { it.startTime }
)
- cacheProgramsForChannel(providerId, normalizedPrograms)
- refreshCachedEpgMetadata(providerId)
Result.success(normalizedPrograms)
}
is Result.Error -> {
@@ -529,6 +547,17 @@ class ProviderRepositoryImpl @Inject constructor(
}
}
+ private suspend fun cacheProgramsForChannels(providerId: Long, programs: List<Program>) {
+ if (programs.isEmpty()) return
+ val programsByChannel = programs.groupBy { it.channelId }
+ transactionRunner.inTransaction {
+ programsByChannel.forEach { (channelId, channelPrograms) ->
+ programDao.deleteForChannel(providerId, channelId)
+ programDao.insertAll(channelPrograms.map { it.toEntity().copy(providerId = providerId) })
+ }
+ }
+ }
+
private suspend fun refreshCachedEpgMetadata(providerId: Long) {
val now = System.currentTimeMillis()
val metadata = (syncMetadataRepository.getMetadata(providerId) ?: SyncMetadata(providerId)).copy(