Skip to content

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

Refactor repository implementations and enhance VOD search functionality

David Nashashb606f6bdffad
diff --git a/data/src/main/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiService.kt b/data/src/main/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiService.kt
index 5959daa4..82f93a29 100644
--- a/data/src/main/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiService.kt
+++ b/data/src/main/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiService.kt
@@ -1294,13 +1294,15 @@ class OkHttpStalkerApiService @Inject constructor(
return session.loadUrl
}
- override fun currentCookieHeader(session: StalkerSession): String =
- sessionScopes[session.sessionScopeKey]
- ?.also { scope -> scope.lastAccessAt = System.currentTimeMillis() }
- ?.cookieJar
- ?.cookieHeaderFor(session.loadUrl)
- .orEmpty()
- .ifBlank { session.serverCookieHeader }
+ override fun currentCookieHeader(session: StalkerSession): String {
+ val scope = sessionScopes[session.sessionScopeKey]
+ ?.also { it.lastAccessAt = System.currentTimeMillis() }
+ return mergeCookieHeaders(
+ scope?.cookieJar?.cookieHeaderFor(session.loadUrl).orEmpty(),
+ scope?.restoredCookieHeader.orEmpty(),
+ session.serverCookieHeader
+ )
+ }
override fun restoreSession(session: StalkerSession, profile: StalkerDeviceProfile) {
val scopeKey = session.sessionScopeKey.takeIf { it.isNotBlank() } ?: sessionScopeKey(profile)
@@ -2828,6 +2830,20 @@ class OkHttpStalkerApiService @Inject constructor(
return cookies.entries.joinToString("; ") { (key, value) -> "$key=$value" }
}
+ private fun mergeCookieHeaders(vararg headers: String): String {
+ val cookies = linkedMapOf<String, String>()
+ headers.forEach { header ->
+ header.split(';')
+ .mapNotNull { part ->
+ val key = part.substringBefore('=', missingDelimiterValue = "").trim()
+ val value = part.substringAfter('=', missingDelimiterValue = "").trim()
+ key.takeIf { it.isNotBlank() && value.isNotBlank() }?.let { it to value }
+ }
+ .forEach { (key, value) -> cookies.putIfAbsent(key, value) }
+ }
+ return cookies.entries.joinToString("; ") { (key, value) -> "$key=$value" }
+ }
+
private suspend fun requestCredentialAuth(
url: String,
profile: StalkerDeviceProfile,
diff --git a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerProvider.kt b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerProvider.kt
index 5b864054..15be28b7 100644
--- a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerProvider.kt
+++ b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerProvider.kt
@@ -860,9 +860,8 @@ internal companion object {
?.takeUnless { it == numericKey }
val xmlResult = xmlKey?.let { getShortEpg(it, request.limit) }
return when {
- xmlResult is Result.Success -> xmlResult
- numericResult is Result.Success -> numericResult
- numericResult is Result.Error -> numericResult
+ xmlResult is Result.Success && xmlResult.data.isNotEmpty() -> xmlResult
+ numericResult != null -> numericResult
xmlResult is Result.Error -> xmlResult
else -> Result.error("Short EPG lookup returned no programs")
}
diff --git a/data/src/main/java/com/streamvault/data/repository/ChannelRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/ChannelRepositoryImpl.kt
index 1805a5e9..92b2afb3 100644
--- a/data/src/main/java/com/streamvault/data/repository/ChannelRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/ChannelRepositoryImpl.kt
@@ -170,7 +170,7 @@ class ChannelRepositoryImpl @Inject constructor(
filtered,
settings,
unlockedCats,
- stalkerPortalRoot(providerId)
+ stalkerPortalUrlForProvider = { stalkerPortalRoot(providerId) }
)
applyNumbering(presented, settings.numberingMode, offset)
}
@@ -269,7 +269,11 @@ class ChannelRepositoryImpl @Inject constructor(
}
val groupedEntities = channelDao.getByLogicalGroupId(entity.providerId, entity.logicalGroupId)
.ifEmpty { listOf(entity) }
- return buildGroupedChannels(groupedEntities, settings, stalkerPortalUrl).firstOrNull()
+ return buildGroupedChannels(
+ groupedEntities,
+ settings,
+ stalkerPortalUrlForProvider = { stalkerPortalUrl }
+ ).firstOrNull()
}
override suspend fun getStreamInfo(channel: Channel, preferStableUrl: Boolean): Result<StreamInfo> = try {
@@ -328,12 +332,17 @@ class ChannelRepositoryImpl @Inject constructor(
) { requested, entityPool, level, settings, hideDecorativeRows ->
val filteredRequested = applyVisibilityFilter(requested, level, emptySet(), hideDecorativeRows)
val filteredPool = applyVisibilityFilter(entityPool, level, emptySet(), hideDecorativeRows)
+ val stalkerPortalUrls = (requested + filteredPool)
+ .asSequence()
+ .map(ChannelBrowseEntity::providerId)
+ .distinct()
+ .associateWith(::stalkerPortalRoot)
buildChannelsForRequestedIds(
requestedIds = ids,
requestedEntities = filteredRequested,
entityPool = filteredPool.ifEmpty { filteredRequested },
settings = settings,
- stalkerPortalUrl = stalkerPortalRoot(requested.first().providerId)
+ stalkerPortalUrlForProvider = { providerId -> stalkerPortalUrls[providerId] }
)
}.flowOn(Dispatchers.Default)
}
@@ -381,7 +390,7 @@ class ChannelRepositoryImpl @Inject constructor(
filtered,
settings,
unlockedCats,
- stalkerPortalRoot(providerId)
+ stalkerPortalUrlForProvider = { stalkerPortalRoot(providerId) }
),
settings.numberingMode
)
@@ -463,17 +472,22 @@ class ChannelRepositoryImpl @Inject constructor(
requestedEntities: List<ChannelBrowseEntity>,
entityPool: List<ChannelBrowseEntity>,
settings: ChannelPresentationSettings,
- stalkerPortalUrl: String?
+ stalkerPortalUrlForProvider: (Long) -> String?
): List<Channel> {
if (requestedEntities.isEmpty()) return emptyList()
if (settings.groupingMode == LiveChannelGroupingMode.RAW_VARIANTS) {
val rawById = requestedEntities.associateBy { it.id }
return requestedIds.mapNotNull { rawId ->
- rawById[rawId]?.toPresentedRawChannel(settings.observedQualities[rawId], stalkerPortalUrl)
+ rawById[rawId]?.let { entity ->
+ entity.toPresentedRawChannel(
+ settings.observedQualities[rawId],
+ stalkerPortalUrlForProvider(entity.providerId)
+ )
+ }
}
}
- val groupedChannels = buildGroupedChannels(entityPool, settings, stalkerPortalUrl)
+ val groupedChannels = buildGroupedChannels(entityPool, settings, stalkerPortalUrlForProvider)
val groupedByRawId = buildRawVariantLookup(groupedChannels)
val seenLogicalGroups = linkedSetOf<String>()
return requestedIds.mapNotNull { rawId ->
@@ -487,14 +501,17 @@ class ChannelRepositoryImpl @Inject constructor(
entities: List<ChannelBrowseEntity>,
settings: ChannelPresentationSettings,
unlockedCats: Set<Long>,
- stalkerPortalUrl: String?
+ stalkerPortalUrlForProvider: (Long) -> String?
): List<Channel> {
val base = if (settings.groupingMode == LiveChannelGroupingMode.RAW_VARIANTS) {
entities.map { entity ->
- entity.toPresentedRawChannel(settings.observedQualities[entity.id], stalkerPortalUrl)
+ entity.toPresentedRawChannel(
+ settings.observedQualities[entity.id],
+ stalkerPortalUrlForProvider(entity.providerId)
+ )
}
} else {
- buildGroupedChannels(entities, settings, stalkerPortalUrl)
+ buildGroupedChannels(entities, settings, stalkerPortalUrlForProvider)
}
return base.map { channel ->
if (channel.categoryId != null && unlockedCats.contains(channel.categoryId)) {
@@ -508,7 +525,7 @@ class ChannelRepositoryImpl @Inject constructor(
private fun buildGroupedChannels(
entities: List<ChannelBrowseEntity>,
settings: ChannelPresentationSettings,
- stalkerPortalUrl: String?
+ stalkerPortalUrlForProvider: (Long) -> String?
): List<Channel> {
val grouped = linkedMapOf<String, MutableList<ChannelBrowseEntity>>()
entities.forEach { entity ->
@@ -553,7 +570,7 @@ class ChannelRepositoryImpl @Inject constructor(
id = selectedVariant.rawChannelId,
name = displayName,
canonicalName = canonicalName,
- logoUrl = representative.resolveLogoUrl(stalkerPortalUrl),
+ logoUrl = representative.resolveLogoUrl(stalkerPortalUrlForProvider(representative.providerId)),
groupTitle = representative.groupTitle,
categoryId = representative.categoryId,
categoryName = representative.categoryName,
diff --git a/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt
index fd312fb2..f1171cf5 100644
--- a/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt
@@ -257,12 +257,14 @@ class MovieRepositoryImpl @Inject constructor(
val provider = loadCompatibilityProvider(providerId)
val previewCategories = if (provider?.type == ProviderType.STALKER_PORTAL) {
val stalkerProvider = createStalkerProvider(providerId)
- filteredCategories.filterNot { category ->
+ val nonWildcard = filteredCategories.filterNot { category ->
stalkerProvider.isWildcardCategory(ContentType.MOVIE, category.categoryId)
}
+ if (nonWildcard.isNotEmpty()) nonWildcard else filteredCategories
} else {
filteredCategories
}
+ val allowWildcardHydration = previewCategories.size == filteredCategories.size
if (previewCategories.isEmpty()) {
send(emptyMap())
return@channelFlow
@@ -274,7 +276,7 @@ class MovieRepositoryImpl @Inject constructor(
fetchIfMissing = true,
refreshStaleInBackground = false,
requiredCount = limitPerCategory,
- allowStalkerWildcard = false
+ allowStalkerWildcard = allowWildcardHydration
)
}
// SQL LIMIT applied per-category — avoids loading the full catalog into memory
diff --git a/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt
index 0fc20632..99ad7326 100644
--- a/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt
@@ -234,12 +234,14 @@ class SeriesRepositoryImpl @Inject constructor(
val provider = loadCompatibilityProvider(providerId)
val previewCategories = if (provider?.type == ProviderType.STALKER_PORTAL) {
val stalkerProvider = createStalkerProvider(providerId)
- filteredCategories.filterNot { category ->
+ val nonWildcard = filteredCategories.filterNot { category ->
stalkerProvider.isWildcardCategory(ContentType.SERIES, category.categoryId)
}
+ if (nonWildcard.isNotEmpty()) nonWildcard else filteredCategories
} else {
filteredCategories
}
+ val allowWildcardHydration = previewCategories.size == filteredCategories.size
if (previewCategories.isEmpty()) {
send(emptyMap())
return@channelFlow
@@ -253,7 +255,7 @@ class SeriesRepositoryImpl @Inject constructor(
categoryId = category.categoryId,
provider = provider,
requiredCount = limitPerCategory,
- allowStalkerWildcard = false
+ allowStalkerWildcard = allowWildcardHydration
)
}
}
diff --git a/data/src/main/java/com/streamvault/data/repository/VodRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/VodRepositoryImpl.kt
index 99360f95..4671ad5b 100644
--- a/data/src/main/java/com/streamvault/data/repository/VodRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/VodRepositoryImpl.kt
@@ -56,14 +56,43 @@ class VodRepositoryImpl @Inject constructor(
categoryDao.getByProviderAndType(providerId, ContentType.VOD.name),
preferencesRepository.parentalControlLevel,
preferencesRepository.getHiddenCategoryIds(providerId, ContentType.VOD)
- ) { entities, parentalLevel, hiddenIds ->
- entities.asSequence()
- .filterNot { it.categoryId in hiddenIds }
- .filter { parentalLevel < 3 || (!it.isAdult && !it.isUserProtected) }
- .map { it.toDomain() }
- .toList()
+ ) { entities, parentalLevel, vodHiddenIds ->
+ entities to (parentalLevel to vodHiddenIds)
+ }.flatMapLatest { (entities, filters) ->
+ val parentalLevel = filters.first
+ val vodHiddenIds = filters.second
+ val unified = filterUnifiedCategories(entities, parentalLevel, vodHiddenIds)
+ if (unified.isNotEmpty()) {
+ flowOf(unified)
+ } else {
+ // A UNIFIED_VOD portal may still have SPLIT-era MOVIE rows until the next sync
+ // reconciles their type. Category ids are layout-independent, so keep the VOD
+ // surface usable while that durable repair catches up.
+ flow {
+ val movieHiddenIds = preferencesRepository
+ .getHiddenCategoryIds(providerId, ContentType.MOVIE)
+ .first()
+ emit(
+ filterUnifiedCategories(
+ categoryDao.getByProviderAndTypeSync(providerId, ContentType.MOVIE.name),
+ parentalLevel,
+ vodHiddenIds + movieHiddenIds
+ )
+ )
+ }
+ }
}
+ private fun filterUnifiedCategories(
+ entities: List<com.streamvault.data.local.entity.CategoryEntity>,
+ parentalLevel: Int,
+ hiddenIds: Set<Long>
+ ): List<Category> = entities.asSequence()
+ .filterNot { it.categoryId in hiddenIds }
+ .filter { parentalLevel < 3 || (!it.isAdult && !it.isUserProtected) }
+ .map { it.toDomain() }
+ .toList()
+
override fun getCategoryPreview(
providerId: Long,
categoryId: Long,
diff --git a/data/src/main/java/com/streamvault/data/sync/ProviderContinuationScheduler.kt b/data/src/main/java/com/streamvault/data/sync/ProviderContinuationScheduler.kt
index a9318050..defedf95 100644
--- a/data/src/main/java/com/streamvault/data/sync/ProviderContinuationScheduler.kt
+++ b/data/src/main/java/com/streamvault/data/sync/ProviderContinuationScheduler.kt
@@ -10,7 +10,10 @@ internal class ProviderContinuationScheduler(
override suspend fun schedule(snapshot: ProviderSnapshot, work: List<SyncContinuation>) {
val providerId = snapshot.provider.id
if (work.any { it.operation == SyncContinuationOperation.FULL_CATALOG }) {
- workScheduler.scheduleProviderResume(providerId, snapshot.configurationGeneration)
+ // A catalog continuation resumes the committed provider workflow. The snapshot
+ // generation is not a ProviderConfigRevisionEntity revision and must not be sent
+ // through the configuration-edit worker path (fresh providers have no revision row).
+ workScheduler.scheduleProviderResume(providerId)
}
if (work.any { it.operation == SyncContinuationOperation.REFRESH_GUIDE }) {
workScheduler.scheduleBackgroundEpg(providerId)
diff --git a/data/src/test/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiServiceTest.kt b/data/src/test/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiServiceTest.kt
index 6e232f4e..7d190855 100644
--- a/data/src/test/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiServiceTest.kt
+++ b/data/src/test/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiServiceTest.kt
@@ -3053,6 +3053,36 @@ class OkHttpStalkerApiServiceTest {
assertThat(requestCookie).contains("sid=restored-cookie")
}
+ @Test
+ fun restoreSession_keepsRestoredCookiesWhenResponseRefreshesOnlyOneCookie() = runTest {
+ val service = OkHttpStalkerApiService(
+ okHttpClient = OkHttpClient.Builder()
+ .addInterceptor { chain ->
+ Response.Builder()
+ .request(chain.request())
+ .protocol(Protocol.HTTP_1_1)
+ .code(200)
+ .message("OK")
+ .addHeader("Set-Cookie", "sid=refreshed; Path=/; HttpOnly")
+ .body("""{"js":[]}""".toResponseBody("application/json".toMediaType()))
+ .build()
+ }
+ .build(),
+ json = Json { ignoreUnknownKeys = true }
+ )
+ val session = stalkerSession().copy(
+ sessionScopeKey = "restored-scope",
+ serverCookieHeader = "sid=restored-cookie; affinity=keep-me"
+ )
+ val profile = stalkerProfile()
+
+ service.restoreSession(session, profile)
+ service.getVodCategories(session, profile)
+
+ assertThat(service.currentCookieHeader(session)).contains("sid=refreshed")
+ assertThat(service.currentCookieHeader(session)).contains("affinity=keep-me")
+ }
+
@Test
fun authenticate_classifies_status2_envelope_as_device_not_registered() = runTest {
val service = OkHttpStalkerApiService(
diff --git a/data/src/test/java/com/streamvault/data/remote/stalker/StalkerProviderTest.kt b/data/src/test/java/com/streamvault/data/remote/stalker/StalkerProviderTest.kt
index 552d1d39..5d297445 100644
--- a/data/src/test/java/com/streamvault/data/remote/stalker/StalkerProviderTest.kt
+++ b/data/src/test/java/com/streamvault/data/remote/stalker/StalkerProviderTest.kt
@@ -153,6 +153,36 @@ class StalkerProviderTest {
assertThat(api.shortEpgCalls).containsExactly("42")
}
+ @Test
+ fun shortEpgRequest_preservesNumericErrorWhenXmlFallbackIsEmpty() = runTest {
+ val numericFailure = Result.error<List<StalkerProgramRecord>>(
+ message = "temporary portal failure",
+ exception = IllegalStateException("temporary portal failure")
+ )
+ val api = FakeStalkerApiService(
+ profile = StalkerProviderProfile(accountName = "Room"),
+ shortEpgResultsByChannel = mapOf(
+ "42" to numericFailure,
+ "xml.channel" to Result.success(emptyList())
+ )
+ )
+ val provider = StalkerProvider(
+ providerId = 7,
+ api = api,
+ portalUrl = "https://portal.example.com/c/",
+ macAddress = "00:1A:79:12:34:56",
+ deviceProfile = "MAG250",
+ timezone = "UTC",
+ locale = "en"
+ )
+
+ val result = provider.getShortEpg(GuideRequest(streamId = 42L, epgChannelId = "xml.channel"))
+
+ assertThat(result).isInstanceOf(Result.Error::class.java)
+ assertThat((result as Result.Error).message).isEqualTo("temporary portal failure")
+ assertThat(api.shortEpgCalls).containsExactly("42", "xml.channel").inOrder()
+ }
+
@Test
fun fullEpgRequest_usesNumericPortalKey() = runTest {
val api = FakeStalkerApiService(
@@ -1410,6 +1440,7 @@ class StalkerProviderTest {
private val vodPageItems: List<StalkerItemRecord> = emptyList(),
private val seriesPageItems: List<StalkerItemRecord> = emptyList(),
private val shortEpgByChannel: Map<String, List<StalkerProgramRecord>> = emptyMap(),
+ private val shortEpgResultsByChannel: Map<String, Result<List<StalkerProgramRecord>>> = emptyMap(),
private val epgByChannel: Map<String, List<StalkerProgramRecord>> = emptyMap(),
private var authenticationFailuresBeforeSuccess: Int = 0,
private val authenticationError: Throwable? = null
@@ -1530,7 +1561,8 @@ class StalkerProviderTest {
limit: Int
): Result<List<StalkerProgramRecord>> {
shortEpgCalls += channelId
- return Result.success(shortEpgByChannel[channelId].orEmpty())
+ return shortEpgResultsByChannel[channelId]
+ ?: Result.success(shortEpgByChannel[channelId].orEmpty())
}
override suspend fun getEpg(
diff --git a/data/src/test/java/com/streamvault/data/repository/ChannelRepositoryImplTest.kt b/data/src/test/java/com/streamvault/data/repository/ChannelRepositoryImplTest.kt
index dd15de56..06d1303e 100644
--- a/data/src/test/java/com/streamvault/data/repository/ChannelRepositoryImplTest.kt
+++ b/data/src/test/java/com/streamvault/data/repository/ChannelRepositoryImplTest.kt
@@ -469,6 +469,79 @@ class ChannelRepositoryImplTest {
.isEqualTo("http://portal.example/stalker_portal/misc/logos/120/536.png")
}
+ @Test
+ fun `getChannelsByIds resolves mixed provider stalker logos against each provider`() = runTest {
+ whenever(preferencesRepository.liveChannelGroupingMode)
+ .thenReturn(flowOf(LiveChannelGroupingMode.RAW_VARIANTS))
+ whenever(channelDao.getByIds(listOf(101L, 202L))).thenReturn(
+ flowOf(
+ listOf(
+ ChannelBrowseEntity(
+ id = 101L,
+ streamId = 101L,
+ name = "Provider One Channel",
+ logoUrl = "101.png",
+ streamUrl = "https://stream/101",
+ number = 1,
+ providerId = 1L
+ ),
+ ChannelBrowseEntity(
+ id = 202L,
+ streamId = 202L,
+ name = "Provider Two Channel",
+ logoUrl = "202.png",
+ streamUrl = "https://stream/202",
+ number = 1,
+ providerId = 2L
+ )
+ )
+ )
+ )
+ whenever(providerSnapshotDao.getConfigSync(1L)).thenReturn(
+ ProviderConfigEntity(
+ providerId = 1L,
+ type = ProviderType.STALKER_PORTAL,
+ schemaVersion = 1,
+ configurationGeneration = 1L,
+ identityKey = "stalker-1",
+ encryptedConfigJson = "one",
+ updatedAt = 1L
+ )
+ )
+ whenever(providerSnapshotDao.getConfigSync(2L)).thenReturn(
+ ProviderConfigEntity(
+ providerId = 2L,
+ type = ProviderType.STALKER_PORTAL,
+ schemaVersion = 1,
+ configurationGeneration = 1L,
+ identityKey = "stalker-2",
+ encryptedConfigJson = "two",
+ updatedAt = 1L
+ )
+ )
+ whenever(providerConfigurationCodec.decode(ProviderType.STALKER_PORTAL, "one"))
+ .thenReturn(
+ StalkerConfig(
+ portalUrl = "http://one.example/stalker_portal/server/load.php",
+ device = StalkerDeviceIdentity(macAddress = "00:1A:79:12:34:01")
+ )
+ )
+ whenever(providerConfigurationCodec.decode(ProviderType.STALKER_PORTAL, "two"))
+ .thenReturn(
+ StalkerConfig(
+ portalUrl = "http://two.example/stalker_portal/server/load.php",
+ device = StalkerDeviceIdentity(macAddress = "00:1A:79:12:34:02")
+ )
+ )
+
+ val result = createRepository().getChannelsByIds(listOf(101L, 202L)).first()
+
+ assertThat(result.map { it.logoUrl }).containsExactly(
+ "http://one.example/stalker_portal/misc/logos/120/101.png",
+ "http://two.example/stalker_portal/misc/logos/120/202.png"
+ ).inOrder()
+ }
+
@Test
fun `getChannel reads updated stalker portal config after an edit`() = runTest {
whenever(channelDao.getBrowseById(536L)).thenReturn(
diff --git a/data/src/test/java/com/streamvault/data/repository/MovieRepositoryImplTest.kt b/data/src/test/java/com/streamvault/data/repository/MovieRepositoryImplTest.kt
index c6909418..fb5e937e 100644
--- a/data/src/test/java/com/streamvault/data/repository/MovieRepositoryImplTest.kt
+++ b/data/src/test/java/com/streamvault/data/repository/MovieRepositoryImplTest.kt
@@ -31,6 +31,7 @@ import com.streamvault.data.remote.stalker.StalkerCategoryRecord
import com.streamvault.data.remote.stalker.StalkerItemRecord
import com.streamvault.data.remote.stalker.StalkerPagedItems
import com.streamvault.data.remote.stalker.StalkerRemoteIdentityResolver
+import com.streamvault.data.remote.stalker.stalkerStableHashId
import com.streamvault.data.remote.dto.XtreamCategory
import com.streamvault.data.remote.dto.XtreamStream
import com.streamvault.data.remote.stalker.StalkerApiService
@@ -577,6 +578,44 @@ class MovieRepositoryImplTest {
verify(stalkerApiService, never()).getVodStreamsPage(any(), any(), anyOrNull(), eq(2))
}
+ @Test
+ fun `stalker preview keeps wildcard-only movie category`() = runTest {
+ val wildcardId = stalkerStableHashId(7L, ContentType.MOVIE, "*")
+ whenever(preferencesRepository.parentalControlLevel).thenReturn(flowOf(0))
+ whenever(categoryDao.getByProviderAndType(7L, ContentType.MOVIE.name)).thenReturn(
+ flowOf(
+ listOf(
+ CategoryEntity(
+ providerId = 7L,
+ categoryId = wildcardId,
+ name = "*",
+ type = ContentType.MOVIE
+ )
+ )
+ )
+ )
+ whenever(movieDao.getCountByCategory(7L, wildcardId)).thenReturn(flowOf(18))
+ whenever(movieCategoryHydrationDao.get(7L, wildcardId)).thenReturn(null)
+ whenever(movieDao.getByCategoryPreview(7L, wildcardId, 18)).thenReturn(
+ flowOf(
+ listOf(
+ MovieEntity(
+ id = 1L,
+ streamId = 1L,
+ name = "Movie",
+ categoryId = wildcardId,
+ providerId = 7L
+ )
+ )
+ )
+ )
+ stubProvider(stalkerProvider())
+
+ val result = createRepository().getCategoryPreviewRows(7L, listOf(wildcardId), 18).first()
+
+ assertThat(result[wildcardId]).hasSize(1)
+ }
+
@Test
fun `stalker preview hydration survives preview flow cancellation`() = runTest {
val requestStarted = CompletableDeferred<Unit>()
diff --git a/data/src/test/java/com/streamvault/data/repository/SeriesRepositoryImplTest.kt b/data/src/test/java/com/streamvault/data/repository/SeriesRepositoryImplTest.kt
index b4ca8d29..3d577bf1 100644
--- a/data/src/test/java/com/streamvault/data/repository/SeriesRepositoryImplTest.kt
+++ b/data/src/test/java/com/streamvault/data/repository/SeriesRepositoryImplTest.kt
@@ -34,6 +34,7 @@ import com.streamvault.data.remote.stalker.StalkerPagedItems
import com.streamvault.data.remote.stalker.StalkerProviderProfile
import com.streamvault.data.remote.stalker.StalkerProvider
import com.streamvault.data.remote.stalker.StalkerRemoteIdentityResolver
+import com.streamvault.data.remote.stalker.stalkerStableHashId
import com.streamvault.data.remote.stalker.StalkerSeasonRecord
import com.streamvault.data.remote.stalker.StalkerSeriesDetails
import com.streamvault.data.remote.stalker.StalkerSession
@@ -467,6 +468,45 @@ class SeriesRepositoryImplTest {
verify(stalkerApiService, never()).getSeriesPage(any(), any(), anyOrNull(), eq(2))
}
+ @Test
+ fun `stalker preview keeps wildcard-only series category`() = runTest {
+ val wildcardId = stalkerStableHashId(7L, ContentType.SERIES, "*")
+ whenever(preferencesRepository.parentalControlLevel).thenReturn(flowOf(0))
+ whenever(categoryDao.getByProviderAndType(7L, ContentType.SERIES.name)).thenReturn(
+ flowOf(
+ listOf(
+ CategoryEntity(
+ providerId = 7L,
+ categoryId = wildcardId,
+ name = "*",
+ type = ContentType.SERIES
+ )
+ )
+ )
+ )
+ whenever(seriesDao.getCountByCategory(7L, wildcardId)).thenReturn(flowOf(18))
+ whenever(seriesCategoryHydrationDao.get(7L, wildcardId)).thenReturn(null)
+ whenever(seriesDao.getByCategoryPreview(7L, wildcardId, 18)).thenReturn(
+ flowOf(
+ listOf(
+ SeriesEntity(
+ id = 1L,
+ seriesId = 1L,
+ providerSeriesId = "1",
+ name = "Series",
+ categoryId = wildcardId,
+ providerId = 7L
+ )
+ )
+ )
+ )
+ stubProvider(stalkerProvider())
+
+ val result = createRepository().getCategoryPreviewRows(7L, listOf(wildcardId), 18).first()
+
+ assertThat(result[wildcardId]).hasSize(1)
+ }
+
@Test
fun `opening stalker series category fills at least forty items across natural pages`() = runTest {
whenever(preferencesRepository.parentalControlLevel).thenReturn(flowOf(0))
diff --git a/data/src/test/java/com/streamvault/data/repository/VodRepositoryImplTest.kt b/data/src/test/java/com/streamvault/data/repository/VodRepositoryImplTest.kt
index ff9f19d5..260d6440 100644
--- a/data/src/test/java/com/streamvault/data/repository/VodRepositoryImplTest.kt
+++ b/data/src/test/java/com/streamvault/data/repository/VodRepositoryImplTest.kt
@@ -79,6 +79,33 @@ class VodRepositoryImplTest {
configurationGeneration = 1L
)
+ @Test
+ fun getCategories_fallsBackToStoredMovieCategoriesWhenVodRowsAreMissing() = runTest {
+ whenever(categoryDao.getByProviderAndType(1L, ContentType.VOD.name))
+ .thenReturn(flowOf(emptyList()))
+ whenever(categoryDao.getByProviderAndTypeSync(1L, ContentType.MOVIE.name))
+ .thenReturn(
+ listOf(
+ CategoryEntity(
+ providerId = 1L,
+ categoryId = 42L,
+ name = "Action",
+ type = ContentType.MOVIE
+ )
+ )
+ )
+ whenever(preferences.parentalControlLevel).thenReturn(flowOf(0))
+ whenever(preferences.getHiddenCategoryIds(1L, ContentType.VOD))
+ .thenReturn(flowOf(emptySet()))
+ whenever(preferences.getHiddenCategoryIds(1L, ContentType.MOVIE))
+ .thenReturn(flowOf(emptySet()))
+
+ val categories = repository().getCategories(1L).first()
+
+ assertThat(categories.map { it.id }).containsExactly(42L)
+ assertThat(categories.single().name).isEqualTo("Action")
+ }
+
@Test
fun searchVod_returnsMixedPortalResultsWithStablePersistedIds() = runTest {
val snapshot = stalkerSnapshot(1L)
diff --git a/data/src/test/java/com/streamvault/data/sync/ProviderContinuationSchedulerTest.kt b/data/src/test/java/com/streamvault/data/sync/ProviderContinuationSchedulerTest.kt
new file mode 100644
index 00000000..0d525d07
--- /dev/null
+++ b/data/src/test/java/com/streamvault/data/sync/ProviderContinuationSchedulerTest.kt
@@ -0,0 +1,39 @@
+package com.streamvault.data.sync
+
+import com.streamvault.domain.model.Provider
+import com.streamvault.domain.model.ProviderSnapshot
+import com.streamvault.domain.model.ProviderType
+import com.streamvault.domain.model.StalkerConfig
+import com.streamvault.domain.model.StalkerDeviceIdentity
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+
+class ProviderContinuationSchedulerTest {
+ @Test
+ fun `full catalog continuation schedules ordinary provider resume`() = runTest {
+ val workScheduler = mock<ProviderSyncWorkScheduler>()
+ val snapshot = ProviderSnapshot(
+ provider = Provider(id = 7L, name = "Portal", type = ProviderType.STALKER_PORTAL),
+ configuration = StalkerConfig(
+ portalUrl = "https://portal.example.com",
+ device = StalkerDeviceIdentity(macAddress = "00:11:22:33:44:55")
+ ),
+ configurationGeneration = 1L
+ )
+
+ ProviderContinuationScheduler(workScheduler).schedule(
+ snapshot,
+ listOf(
+ SyncContinuation(
+ operation = SyncContinuationOperation.FULL_CATALOG,
+ reason = "test",
+ force = true
+ )
+ )
+ )
+
+ verify(workScheduler).scheduleProviderResume(7L)
+ }
+}
diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MoviesViewModel.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MoviesViewModel.kt
index 7eecf5d4..a7b99557 100644
--- a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MoviesViewModel.kt
+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MoviesViewModel.kt
@@ -33,6 +33,7 @@ import com.streamvault.feature.catalog.presentation.vod.buildVodPreviewCatalog
import com.streamvault.feature.catalog.presentation.vod.buildVodSearchCatalog
import com.streamvault.feature.catalog.presentation.vod.loadVodReorderItems
import com.streamvault.feature.catalog.presentation.vod.matchesVodGroupMembership
+import com.streamvault.feature.catalog.presentation.vod.keepNonProviderWideCategoriesOrAll
import com.streamvault.feature.catalog.presentation.vod.moveVodItemDown
import com.streamvault.feature.catalog.presentation.vod.moveVodItemUp
import com.streamvault.feature.catalog.presentation.vod.selectVodCategory
@@ -173,7 +174,10 @@ class MoviesViewModel @Inject constructor(
sortMode = sortMode
).let { categories ->
if (provider.type == ProviderType.STALKER_PORTAL) {
- categories.filterNot(::isLikelyProviderWideStalkerCategory)
+ keepNonProviderWideCategoriesOrAll(
+ categories,
+ ::isLikelyProviderWideStalkerCategory
+ )
} else {
categories
}
diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesViewModel.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesViewModel.kt
index e7acdc3c..ee30cfa4 100644
--- a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesViewModel.kt
+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesViewModel.kt
@@ -34,6 +34,7 @@ import com.streamvault.feature.catalog.presentation.vod.buildVodSearchCatalog
import com.streamvault.feature.catalog.presentation.vod.loadVodReorderItems
import com.streamvault.feature.catalog.presentation.vod.markVodFavorites
import com.streamvault.feature.catalog.presentation.vod.matchesVodGroupMembership
+import com.streamvault.feature.catalog.presentation.vod.keepNonProviderWideCategoriesOrAll
import com.streamvault.feature.catalog.presentation.vod.moveVodItemDown
import com.streamvault.feature.catalog.presentation.vod.moveVodItemUp
import com.streamvault.feature.catalog.presentation.vod.selectVodCategory
@@ -173,7 +174,10 @@ class SeriesViewModel @Inject constructor(
sortMode = sortMode
).let { categories ->
if (provider.type == ProviderType.STALKER_PORTAL) {
- categories.filterNot(::isLikelyProviderWideStalkerCategory)
+ keepNonProviderWideCategoriesOrAll(
+ categories,
+ ::isLikelyProviderWideStalkerCategory
+ )
} else {
categories
}
diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/vod/VodBrowseStateHelpers.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/vod/VodBrowseStateHelpers.kt
index a25fcd99..936fb7f0 100644
--- a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/vod/VodBrowseStateHelpers.kt
+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/vod/VodBrowseStateHelpers.kt
@@ -2,6 +2,7 @@
import com.streamvault.domain.model.LibraryFilterType
import com.streamvault.domain.model.LibrarySortBy
+import com.streamvault.domain.model.ProviderType
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.update
@@ -46,6 +47,24 @@ fun incrementVodSelectedCategoryLoadLimit(
fun shouldShowVodPreview(selectedCategory: String?, isReorderMode: Boolean): Boolean =
selectedCategory == null && !isReorderMode
+/** Keeps a provider-wide Stalker bucket when it is the only available category. */
+fun <T> keepNonProviderWideCategoriesOrAll(
+ categories: List<T>,
+ isProviderWide: (T) -> Boolean
+): List<T> {
+ val nonProviderWide = categories.filterNot(isProviderWide)
+ return if (nonProviderWide.isNotEmpty()) nonProviderWide else categories
+}
+
+fun isPortalVodSearchQuery(
+ providerType: ProviderType?,
+ enabled: Boolean,
+ query: String
+): Boolean = enabled && providerType == ProviderType.STALKER_PORTAL && query.trim().length >= 2
+
+fun portalVodSearchBelongsToProvider(snapshotProviderId: Long?, activeProviderId: Long?): Boolean =
+ snapshotProviderId != null && snapshotProviderId == activeProviderId
+
enum class VodReorderMoveDirection {
EARLIER,
LATER
diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/vod/VodViewModel.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/vod/VodViewModel.kt
index e11a0357..22ca39b8 100644
--- a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/vod/VodViewModel.kt
+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/vod/VodViewModel.kt
@@ -14,7 +14,6 @@ import com.streamvault.domain.model.VodCatalogItem
import com.streamvault.domain.model.VodCategoryKind
import com.streamvault.domain.model.VodCategoryHydration
import com.streamvault.domain.model.VodCategoryHydrationRequest
-import com.streamvault.domain.model.ProviderType
import com.streamvault.domain.repository.ProviderRepository
import com.streamvault.domain.repository.PlaybackHistoryRepository
import com.streamvault.domain.repository.VodRepository
@@ -28,6 +27,7 @@ import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.channelFlow
import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.flow.distinctUntilChanged
import kotlinx.coroutines.flow.flatMapLatest
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.flow.map
@@ -88,6 +88,7 @@ private data class SelectedVodSnapshot(
)
private data class PortalVodSearchSnapshot(
+ val providerId: Long? = null,
val query: String = "",
val items: List<VodCatalogItem> = emptyList(),
val totalCount: Int = 0,
@@ -111,7 +112,6 @@ class VodViewModel @Inject constructor(
const val CATEGORY_LOAD_INCREMENT = 8
const val PREVIEW_ITEM_COUNT = 20
const val SELECTED_PAGE_SIZE = 60
- const val PORTAL_SEARCH_MIN_LENGTH = 2
const val PORTAL_SEARCH_DEBOUNCE_MILLIS = 250L
}
@@ -136,6 +136,36 @@ class VodViewModel @Inject constructor(
private val activeProvider = providerRepository.getActiveProvider()
.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), null)
+ init {
+ viewModelScope.launch {
+ activeProvider
+ .map { it?.id }
+ .distinctUntilChanged()
+ .collect {
+ resetPortalSearch()
+ if (isPortalSearchQuery(searchQuery.value)) {
+ startPortalSearch(searchQuery.value)
+ } else if (searchQuery.value.isNotBlank()) {
+ ensureCompleteForBrowseOperation()
+ }
+ }
+ }
+ viewModelScope.launch {
+ portalSearchEnabled
+ .distinctUntilChanged()
+ .collect { enabled ->
+ if (enabled && isPortalSearchQuery(searchQuery.value)) {
+ startPortalSearch(searchQuery.value)
+ } else {
+ resetPortalSearch()
+ if (!enabled && searchQuery.value.isNotBlank()) {
+ ensureCompleteForBrowseOperation()
+ }
+ }
+ }
+ }
+ }
+
private val catalog: Flow<UnifiedVodCatalogSnapshot> = combine(
activeProvider,
visibleCategoryCount
@@ -180,10 +210,7 @@ class VodViewModel @Inject constructor(
val filterType = values[6] as LibraryFilterType
val sortBy = values[7] as LibrarySortBy
val category = snapshot.rows.firstOrNull { it.category.id == categoryId }?.category
- val portalSearchActive = provider != null &&
- portalSearchEnabled &&
- query.trim().length >= PORTAL_SEARCH_MIN_LENGTH &&
- provider.type == ProviderType.STALKER_PORTAL
+ val portalSearchActive = isPortalVodSearchQuery(provider?.type, portalSearchEnabled, query)
if (portalSearchActive) {
flowOf(SelectedVodSnapshot(category = category))
} else if (provider == null || category == null) {
@@ -216,18 +243,23 @@ class VodViewModel @Inject constructor(
val snapshot = values[1] as UnifiedVodCatalogSnapshot
val selectedContent = values[2] as SelectedVodSnapshot
val portalSnapshot = values[3] as PortalVodSearchSnapshot
+ val currentPortalSnapshot = if (
+ portalVodSearchBelongsToProvider(portalSnapshot.providerId, provider?.id)
+ ) {
+ portalSnapshot
+ } else {
+ PortalVodSearchSnapshot()
+ }
val viewMode = values[4] as String?
val infiniteScroll = values[5] as Boolean
val portalSearchEnabled = values[6] as Boolean
val query = values[7] as String
val filterType = values[8] as LibraryFilterType
val sortBy = values[9] as LibrarySortBy
- val portalSearchActive = portalSearchEnabled &&
- provider?.type == ProviderType.STALKER_PORTAL &&
- query.trim().length >= PORTAL_SEARCH_MIN_LENGTH
+ val portalSearchActive = isPortalVodSearchQuery(provider?.type, portalSearchEnabled, query)
val requiresCompleteCatalog = query.isNotBlank() ||
filterType != LibraryFilterType.ALL || sortBy != LibrarySortBy.LIBRARY
- val isCompletingBrowse = selectedContent.category != null && requiresCompleteCatalog &&
+ val isCompletingBrowse = !portalSearchActive && selectedContent.category != null && requiresCompleteCatalog &&
selectedContent.hydration?.isComplete != true
VodUiState(
provider = provider,
@@ -249,13 +281,13 @@ class VodViewModel @Inject constructor(
selectedLibrarySortBy = sortBy,
viewMode = VodViewMode.fromStorage(viewMode),
portalSearchActive = portalSearchActive,
- portalSearchItems = portalSnapshot.items,
- portalSearchTotalCount = portalSnapshot.totalCount,
- portalSearchPageSize = portalSnapshot.pageSize,
- canLoadMorePortalSearch = portalSearchActive && portalSnapshot.hasMore,
- isLoadingPortalSearch = portalSearchActive && portalSnapshot.isLoading && portalSnapshot.items.isEmpty(),
- isAppendingPortalSearch = portalSearchActive && portalSnapshot.isLoading && portalSnapshot.items.isNotEmpty(),
- portalSearchError = if (portalSearchActive) portalSnapshot.error else null,
+ portalSearchItems = currentPortalSnapshot.items,
+ portalSearchTotalCount = currentPortalSnapshot.totalCount,
+ portalSearchPageSize = currentPortalSnapshot.pageSize,
+ canLoadMorePortalSearch = portalSearchActive && currentPortalSnapshot.hasMore,
+ isLoadingPortalSearch = portalSearchActive && currentPortalSnapshot.isLoading && currentPortalSnapshot.items.isEmpty(),
+ isAppendingPortalSearch = portalSearchActive && currentPortalSnapshot.isLoading && currentPortalSnapshot.items.isNotEmpty(),
+ portalSearchError = if (portalSearchActive) currentPortalSnapshot.error else null,
isLoading = provider == null || provider.catalogLayout == CatalogLayout.UNKNOWN
)
}.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), VodUiState())
@@ -265,11 +297,7 @@ class VodViewModel @Inject constructor(
}
fun selectCategory(category: Category?) {
- portalSearchJob?.cancel()
- portalSearchJob = null
- portalSearchRequestInFlight = false
- portalSearchGeneration++
- portalSearch.value = PortalVodSearchSnapshot()
+ resetPortalSearch()
completeHydrationJob?.cancel()
completeHydrationJob = null
selectedItemLimit.value = SELECTED_PAGE_SIZE
@@ -278,9 +306,7 @@ class VodViewModel @Inject constructor(
searchQuery.value = ""
return
}
- if (isPortalSearchProvider(activeProvider.value) &&
- searchQuery.value.trim().length >= PORTAL_SEARCH_MIN_LENGTH
- ) {
+ if (isPortalSearchQuery(searchQuery.value)) {
startPortalSearch(searchQuery.value)
return
}
@@ -326,82 +352,86 @@ class VodViewModel @Inject constructor(
fun setSearchQuery(query: String) {
searchQuery.value = query
selectedItemLimit.value = SELECTED_PAGE_SIZE
- if (isPortalSearchProvider(activeProvider.value)) {
+ if (isPortalSearchQuery(query)) {
startPortalSearch(query)
- } else if (query.isNotBlank()) {
- ensureCompleteForBrowseOperation()
- }
- }
-
- fun setSelectedLibraryFilterType(filterType: LibraryFilterType) {
- selectedLibraryFilterType.value = filterType
- selectedItemLimit.value = SELECTED_PAGE_SIZE
- if (filterType != LibraryFilterType.ALL && !isPortalSearchActive()) {
- ensureCompleteForBrowseOperation()
+ } else {
+ resetPortalSearch()
+ if (query.isNotBlank()) {
+ ensureCompleteForBrowseOperation()
+ }
}
}
- fun setSelectedLibrarySortBy(sortBy: LibrarySortBy) {
- selectedLibrarySortBy.value = sortBy
- selectedItemLimit.value = SELECTED_PAGE_SIZE
- if (sortBy != LibrarySortBy.LIBRARY && !isPortalSearchActive()) {
- ensureCompleteForBrowseOperation()
- }
- }
+ private fun isPortalSearchQuery(query: String): Boolean =
+ isPortalVodSearchQuery(activeProvider.value?.type, portalSearchEnabled.value, query)
- private fun ensureCompleteForBrowseOperation() {
- val state = uiState.value
- val providerId = state.provider?.id ?: return
- val categoryId = state.selectedCategory?.id ?: return
- if (completeHydrationJob?.isActive == true) return
- completeHydrationJob = viewModelScope.launch {
- vodRepository.hydrateCompletely(providerId, categoryId)
- }
+ private fun resetPortalSearch() {
+ portalSearchJob?.cancel()
+ portalSearchJob = null
+ portalSearchRequestInFlight = false
+ portalSearchGeneration++
+ portalSearch.value = PortalVodSearchSnapshot()
}
- private fun isPortalSearchProvider(provider: Provider?): Boolean =
- portalSearchEnabled.value && provider?.type == ProviderType.STALKER_PORTAL
-
- private fun isPortalSearchActive(): Boolean =
- searchQuery.value.trim().length >= PORTAL_SEARCH_MIN_LENGTH &&
- isPortalSearchProvider(activeProvider.value)
+ private fun isPortalSearchActive(): Boolean = isPortalSearchQuery(searchQuery.value)
private fun startPortalSearch(query: String) {
- portalSearchJob?.cancel()
- portalSearchJob = null
- portalSearchRequestInFlight = false
- portalSearchGeneration += 1
- val generation = portalSearchGeneration
+ resetPortalSearch()
+ val providerId = activeProvider.value?.id ?: return
val normalized = query.trim()
- portalSearch.value = PortalVodSearchSnapshot(query = normalized)
- if (normalized.length < PORTAL_SEARCH_MIN_LENGTH) return
+ if (!isPortalSearchQuery(normalized)) return
+ val generation = portalSearchGeneration
+ portalSearch.value = PortalVodSearchSnapshot(
+ providerId = providerId,
+ query = normalized
+ )
portalSearchJob = viewModelScope.launch {
kotlinx.coroutines.delay(PORTAL_SEARCH_DEBOUNCE_MILLIS)
- requestPortalSearchPage(normalized, page = 1, generation = generation)
+ requestPortalSearchPage(
+ query = normalized,
+ page = 1,
+ generation = generation,
+ providerId = providerId
+ )
}
}
private fun loadMorePortalSearch() {
val snapshot = portalSearch.value
if (portalSearchRequestInFlight || !snapshot.hasMore) return
+ val providerId = activeProvider.value?.id ?: return
+ if (!portalVodSearchBelongsToProvider(snapshot.providerId, providerId)) return
val query = snapshot.query
val generation = portalSearchGeneration
portalSearchJob = viewModelScope.launch {
- requestPortalSearchPage(query, snapshot.nextPage, generation)
+ requestPortalSearchPage(query, snapshot.nextPage, generation, providerId)
}
}
- private suspend fun requestPortalSearchPage(query: String, page: Int, generation: Long) {
- if (generation != portalSearchGeneration || query.isBlank()) return
+ private suspend fun requestPortalSearchPage(
+ query: String,
+ page: Int,
+ generation: Long,
+ providerId: Long
+ ) {
+ if (
+ generation != portalSearchGeneration ||
+ query.isBlank() ||
+ activeProvider.value?.id != providerId ||
+ !portalVodSearchBelongsToProvider(portalSearch.value.providerId, providerId)
+ ) return
portalSearchRequestInFlight = true
portalSearch.value = portalSearch.value.copy(
isLoading = true,
error = null
)
try {
- when (val result = vodRepository.searchVod(activeProvider.value?.id ?: return, query, page)) {
+ when (val result = vodRepository.searchVod(providerId, query, page)) {
is com.streamvault.domain.model.Result.Success -> {
- if (generation != portalSearchGeneration) return
+ if (
+ generation != portalSearchGeneration ||
+ activeProvider.value?.id != providerId
+ ) return
val current = portalSearch.value
val merged = if (page == 1) {
result.data.items
@@ -419,7 +449,10 @@ class VodViewModel @Inject constructor(
)
}
is com.streamvault.domain.model.Result.Error -> {
- if (generation == portalSearchGeneration) {
+ if (
+ generation == portalSearchGeneration &&
+ activeProvider.value?.id == providerId
+ ) {
portalSearch.value = portalSearch.value.copy(
isLoading = false,
error = result.message
@@ -429,13 +462,43 @@ class VodViewModel @Inject constructor(
is com.streamvault.domain.model.Result.Loading -> Unit
}
} finally {
- if (generation == portalSearchGeneration) {
+ if (
+ generation == portalSearchGeneration &&
+ activeProvider.value?.id == providerId
+ ) {
portalSearchRequestInFlight = false
portalSearch.value = portalSearch.value.copy(isLoading = false)
}
}
}
+ fun setSelectedLibraryFilterType(filterType: LibraryFilterType) {
+ selectedLibraryFilterType.value = filterType
+ selectedItemLimit.value = SELECTED_PAGE_SIZE
+ if (filterType != LibraryFilterType.ALL && !isPortalSearchActive()) {
+ ensureCompleteForBrowseOperation()
+ }
+ }
+
+ fun setSelectedLibrarySortBy(sortBy: LibrarySortBy) {
+ selectedLibrarySortBy.value = sortBy
+ selectedItemLimit.value = SELECTED_PAGE_SIZE
+ if (sortBy != LibrarySortBy.LIBRARY && !isPortalSearchActive()) {
+ ensureCompleteForBrowseOperation()
+ }
+ }
+
+ private fun ensureCompleteForBrowseOperation() {
+ val state = uiState.value
+ val providerId = state.provider?.id ?: return
+ val categoryId = state.selectedCategory?.id ?: return
+ if (completeHydrationJob?.isActive == true) return
+ completeHydrationJob = viewModelScope.launch {
+ vodRepository.hydrateCompletely(providerId, categoryId)
+ }
+ }
+
+
private fun applyBrowse(
items: List<VodCatalogItem>,
history: List<PlaybackHistory>,
diff --git a/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/vod/CatalogVodHelpersTest.kt b/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/vod/CatalogVodHelpersTest.kt
index 67a6dd06..b6318dba 100644
--- a/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/vod/CatalogVodHelpersTest.kt
+++ b/feature/catalog/src/test/java/com/streamvault/feature/catalog/presentation/vod/CatalogVodHelpersTest.kt
@@ -7,6 +7,7 @@ import com.streamvault.domain.model.Favorite
import com.streamvault.domain.model.LibraryFilterType
import com.streamvault.domain.model.LibrarySortBy
import com.streamvault.domain.model.Movie
+import com.streamvault.domain.model.ProviderType
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.runBlocking
import org.junit.Test
@@ -67,6 +68,32 @@ class CatalogVodHelpersTest {
assertThat(state.value).isEqualTo(State("Drama", LibraryFilterType.FAVORITES, LibrarySortBy.RATING, true))
}
+ @Test
+ fun providerWideCategory_isKeptWhenItIsTheOnlyCategory() {
+ val wildcard = "*"
+
+ assertThat(
+ keepNonProviderWideCategoriesOrAll(listOf(wildcard)) { it == wildcard }
+ ).containsExactly(wildcard)
+ assertThat(
+ keepNonProviderWideCategoriesOrAll(listOf(wildcard, "Action")) { it == wildcard }
+ ).containsExactly("Action")
+ }
+
+ @Test
+ fun portalSearch_requiresTwoCharactersButDoesNotTreatShortQueryAsPortalSearch() {
+ assertThat(isPortalVodSearchQuery(ProviderType.STALKER_PORTAL, true, "a")).isFalse()
+ assertThat(isPortalVodSearchQuery(ProviderType.STALKER_PORTAL, true, "ab")).isTrue()
+ assertThat(isPortalVodSearchQuery(ProviderType.XTREAM_CODES, true, "ab")).isFalse()
+ }
+
+ @Test
+ fun portalSearchSnapshot_isRejectedAfterProviderChanges() {
+ assertThat(portalVodSearchBelongsToProvider(7L, 7L)).isTrue()
+ assertThat(portalVodSearchBelongsToProvider(7L, 8L)).isFalse()
+ assertThat(portalVodSearchBelongsToProvider(null, 7L)).isFalse()
+ }
+
@Test
fun incrementLoadLimit_isSuppressedWhenNoMoreItems() {
val limit = MutableStateFlow(VodBrowseDefaults.SELECTED_CATEGORY_PAGE_SIZE)