Skip to content

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

Allow VOD-only Xtream and Stalker providers

David Nashash12323092fd09
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 af496d08..e9575717 100644
--- a/data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.kt
@@ -43,6 +43,7 @@ import javax.inject.Singleton
@Singleton
class ProviderRepositoryImpl @Inject constructor(
private val providerDao: ProviderDao,
+ private val categoryDao: CategoryDao,
private val channelDao: ChannelDao,
private val programDao: ProgramDao,
private val recordingRunDao: RecordingRunDao,
@@ -153,7 +154,7 @@ class ProviderRepositoryImpl @Inject constructor(
return try {
val provider = providerDao.getById(id)
?: return Result.error("Provider not found")
- if (!hasUsableLiveCatalogForActivation(id, provider.type, channelDao, syncMetadataRepository)) {
+ if (!hasUsableLiveCatalogForActivation(id, provider.type, channelDao, categoryDao, syncMetadataRepository)) {
syncManager.scheduleProviderSyncResume(id)
return Result.error("Provider is saved but no content has been committed yet. Sync will resume in background.")
}
@@ -497,10 +498,11 @@ class ProviderRepositoryImpl @Inject constructor(
} else {
ProviderStatus.ACTIVE
}
- if (!hasUsableLiveCatalogForActivation(
+ if (!hasUsableLiveCatalogForActivation(
providerData.id,
providerData.type,
channelDao,
+ categoryDao,
syncMetadataRepository
)) {
updateProviderSyncStatus(
@@ -575,6 +577,7 @@ class ProviderRepositoryImpl @Inject constructor(
providerId,
provider.type,
channelDao,
+ categoryDao,
syncMetadataRepository
)) {
updateProviderSyncStatus(
diff --git a/data/src/main/java/com/streamvault/data/sync/ProviderActivationGuard.kt b/data/src/main/java/com/streamvault/data/sync/ProviderActivationGuard.kt
index d82c4d4e..2812c469 100644
--- a/data/src/main/java/com/streamvault/data/sync/ProviderActivationGuard.kt
+++ b/data/src/main/java/com/streamvault/data/sync/ProviderActivationGuard.kt
@@ -1,6 +1,8 @@
package com.streamvault.data.sync
+import com.streamvault.data.local.dao.CategoryDao
import com.streamvault.data.local.dao.ChannelDao
+import com.streamvault.domain.model.ContentType
import com.streamvault.domain.repository.SyncMetadataRepository
import com.streamvault.domain.model.ProviderType
import kotlinx.coroutines.flow.first
@@ -9,9 +11,10 @@ internal suspend fun hasUsableLiveCatalogForActivation(
providerId: Long,
providerType: ProviderType,
channelDao: ChannelDao,
+ categoryDao: CategoryDao,
syncMetadataRepository: SyncMetadataRepository
): Boolean {
- if (providerType != ProviderType.XTREAM_CODES) {
+ if (providerType != ProviderType.XTREAM_CODES && providerType != ProviderType.STALKER_PORTAL) {
return true
}
@@ -20,5 +23,10 @@ internal suspend fun hasUsableLiveCatalogForActivation(
}
val metadata = syncMetadataRepository.getMetadata(providerId)
- return (metadata?.movieCount ?: 0) > 0 || (metadata?.seriesCount ?: 0) > 0
-}
\ No newline at end of file
+ if ((metadata?.movieCount ?: 0) > 0 || (metadata?.seriesCount ?: 0) > 0) {
+ return true
+ }
+
+ return categoryDao.getByProviderAndTypeSync(providerId, ContentType.MOVIE.name).isNotEmpty() ||
+ categoryDao.getByProviderAndTypeSync(providerId, ContentType.SERIES.name).isNotEmpty()
+}
diff --git a/data/src/main/java/com/streamvault/data/sync/ProviderSyncWorker.kt b/data/src/main/java/com/streamvault/data/sync/ProviderSyncWorker.kt
index a3a2ca96..94f4e556 100644
--- a/data/src/main/java/com/streamvault/data/sync/ProviderSyncWorker.kt
+++ b/data/src/main/java/com/streamvault/data/sync/ProviderSyncWorker.kt
@@ -17,6 +17,7 @@ import androidx.work.WorkerParameters
import androidx.work.workDataOf
import com.streamvault.data.local.dao.ProviderDao
import com.streamvault.data.local.dao.ChannelDao
+import com.streamvault.data.local.dao.CategoryDao
import com.streamvault.data.local.dao.XtreamIndexJobDao
import com.streamvault.data.local.dao.XtreamLiveOnboardingDao
import com.streamvault.domain.model.ProviderStatus
@@ -34,6 +35,7 @@ import java.util.concurrent.TimeUnit
internal suspend fun reconcileTargetedProviderStatus(
providerDao: ProviderDao,
channelDao: ChannelDao,
+ categoryDao: CategoryDao,
syncMetadataRepository: SyncMetadataRepository,
syncManager: SyncManager,
provider: com.streamvault.data.local.entity.ProviderEntity,
@@ -51,6 +53,7 @@ internal suspend fun reconcileTargetedProviderStatus(
provider.id,
provider.type,
channelDao,
+ categoryDao,
syncMetadataRepository
)) {
providerDao.update(
@@ -95,6 +98,7 @@ class ProviderSyncWorker(
interface ProviderSyncWorkerEntryPoint {
fun providerDao(): ProviderDao
fun channelDao(): ChannelDao
+ fun categoryDao(): CategoryDao
fun syncManager(): SyncManager
fun syncMetadataRepository(): SyncMetadataRepository
fun xtreamIndexJobDao(): XtreamIndexJobDao
@@ -362,6 +366,7 @@ class ProviderSyncWorker(
reconcileTargetedProviderStatus(
providerDao = entryPoint.providerDao(),
channelDao = entryPoint.channelDao(),
+ categoryDao = entryPoint.categoryDao(),
syncMetadataRepository = entryPoint.syncMetadataRepository(),
syncManager = entryPoint.syncManager(),
provider = provider,
diff --git a/data/src/main/java/com/streamvault/data/sync/SyncManager.kt b/data/src/main/java/com/streamvault/data/sync/SyncManager.kt
index 9a02cb6f..167b863c 100644
--- a/data/src/main/java/com/streamvault/data/sync/SyncManager.kt
+++ b/data/src/main/java/com/streamvault/data/sync/SyncManager.kt
@@ -1068,50 +1068,26 @@ class SyncManager @Inject constructor(
is CatalogStrategyResult.EmptyValid -> {
val existingChannelCount = channelDao.getCount(provider.id).first()
if (existingChannelCount == 0) {
- throw IllegalStateException("Live TV catalog was empty.")
+ warnings += liveSyncResult.warnings + liveResult.warnings +
+ "Live TV provider exposed no live channels; continuing with VOD and series only."
+ 0
+ } else {
+ warnings += liveSyncResult.warnings + liveResult.warnings +
+ "Live TV refresh returned an empty valid catalog; keeping previous channel library."
+ existingChannelCount
}
- warnings += liveSyncResult.warnings + liveResult.warnings +
- "Live TV refresh returned an empty valid catalog; keeping previous channel library."
- existingChannelCount
}
is CatalogStrategyResult.Failure -> {
val existingChannelCount = channelDao.getCount(provider.id).first()
if (existingChannelCount == 0) {
- throw IllegalStateException(
- "Failed to fetch live streams: ${syncErrorSanitizer.throwableMessage(liveResult.error)}"
- )
+ warnings += liveSyncResult.warnings + liveResult.warnings +
+ "Live TV could not be fetched; continuing with VOD and series only."
+ 0
+ } else {
+ warnings += liveSyncResult.warnings + liveResult.warnings +
+ "Live TV sync degraded; keeping previous channel library."
+ existingChannelCount
}
- warnings += liveSyncResult.warnings + liveResult.warnings +
- "Live TV sync degraded; keeping previous channel library."
- existingChannelCount
- }
- }
-
- if (trackInitialLiveOnboarding) {
- if (acceptedCount > 0) {
- val completedAt = System.currentTimeMillis()
- recordXtreamLiveOnboardingState(
- provider = provider,
- phase = XTREAM_ONBOARDING_PHASE_COMPLETED,
- now = completedAt,
- acceptedRowCount = acceptedCount,
- stagedFlushCount = stagedFlushCountFor(acceptedCount),
- clearError = true,
- completedAt = completedAt,
- clearStagedSession = true,
- runtimeProfile = runtimeProfile,
- syncProfileStrategy = liveSyncResult.profileStrategyName(runtimeProfile, trackInitialLiveOnboarding)
- )
- } else {
- recordXtreamLiveOnboardingState(
- provider = provider,
- phase = XTREAM_ONBOARDING_PHASE_FAILED,
- acceptedRowCount = acceptedCount,
- lastError = "Live TV did not finish with any committed channels.",
- clearStagedSession = true,
- runtimeProfile = runtimeProfile,
- syncProfileStrategy = liveSyncResult.profileStrategyName(runtimeProfile, trackInitialLiveOnboarding)
- )
}
}
@@ -1227,6 +1203,32 @@ class SyncManager @Inject constructor(
scheduleXtreamIndexSync(provider.id, ContentType.SERIES)
}
+ if (trackInitialLiveOnboarding) {
+ if (liveCount > 0 || movieCategoryCount > 0 || seriesCategoryCount > 0) {
+ val completedAt = System.currentTimeMillis()
+ recordXtreamLiveOnboardingState(
+ provider = provider,
+ phase = XTREAM_ONBOARDING_PHASE_COMPLETED,
+ now = completedAt,
+ acceptedRowCount = liveCount,
+ stagedFlushCount = stagedFlushCountFor(liveCount),
+ clearError = true,
+ completedAt = completedAt,
+ clearStagedSession = true,
+ runtimeProfile = runtimeProfile
+ )
+ } else {
+ recordXtreamLiveOnboardingState(
+ provider = provider,
+ phase = XTREAM_ONBOARDING_PHASE_FAILED,
+ acceptedRowCount = liveCount,
+ lastError = "Live TV did not finish with any committed channels.",
+ clearStagedSession = true,
+ runtimeProfile = runtimeProfile
+ )
+ }
+ }
+
metadata = metadata.copy(
lastMovieAttempt = if (movieCategoryCount > 0) now else metadata.lastMovieAttempt,
movieCatalogStale = true,
@@ -3866,6 +3868,9 @@ class SyncManager @Inject constructor(
val now = System.currentTimeMillis()
var queuedMovieIndex = false
var queuedSeriesIndex = false
+ var liveCount = metadata.liveCount
+ var movieCategoryCount = 0
+ var seriesCategoryCount = 0
if (force || ContentCachePolicy.shouldRefresh(metadata.lastLiveSuccess, ContentCachePolicy.CATALOG_TTL_MILLIS, now)) {
upsertXtreamIndexJob(
@@ -3886,6 +3891,7 @@ class SyncManager @Inject constructor(
lastLiveSuccess = now,
liveCount = liveCatalogResult.acceptedCount
)
+ liveCount = liveCatalogResult.acceptedCount
syncMetadataRepository.updateMetadata(metadata)
emitCatalogSyncProgress(
section = Section.LIVE,
@@ -3910,7 +3916,29 @@ class SyncManager @Inject constructor(
if (force || ContentCachePolicy.shouldRefresh(metadata.lastMovieSuccess, ContentCachePolicy.CATALOG_TTL_MILLIS, now)) {
progress(provider.id, onProgress, "Preparing Movies...")
- val categories = requireResult(api.getVodCategories(), "Failed to load movie categories")
+ val categories = when (val categoriesResult = api.getVodCategories()) {
+ is com.streamvault.domain.model.Result.Success -> categoriesResult.data
+ is com.streamvault.domain.model.Result.Error -> {
+ val missingCatalogDiagnostic = if (
+ liveCount == 0 &&
+ warnings.any { warning -> isStalkerEmptyResponse(warning) }
+ ) {
+ stalkerCatalogAccessDiagnostic(
+ api = api,
+ primaryMessage = categoriesResult.message,
+ fallbackMessage = "empty response"
+ )
+ } else {
+ null
+ }
+ throw IllegalStateException(
+ missingCatalogDiagnostic
+ ?: "Failed to load movie categories: ${categoriesResult.message}",
+ categoriesResult.exception
+ )
+ }
+ is com.streamvault.domain.model.Result.Loading -> throw IllegalStateException("Unexpected loading state")
+ }
emitCatalogSyncProgress(
section = Section.VOD,
total = categories.size,
@@ -3934,6 +3962,7 @@ class SyncManager @Inject constructor(
)
}
)
+ movieCategoryCount = categories.size
queueStalkerIndexSection(
providerId = provider.id,
contentType = ContentType.MOVIE,
@@ -3954,7 +3983,29 @@ class SyncManager @Inject constructor(
if (force || ContentCachePolicy.shouldRefresh(metadata.lastSeriesSuccess, ContentCachePolicy.CATALOG_TTL_MILLIS, now)) {
progress(provider.id, onProgress, "Preparing Series...")
- val categories = requireResult(api.getSeriesCategories(), "Failed to load series categories")
+ val categories = when (val categoriesResult = api.getSeriesCategories()) {
+ is com.streamvault.domain.model.Result.Success -> categoriesResult.data
+ is com.streamvault.domain.model.Result.Error -> {
+ val missingCatalogDiagnostic = if (
+ liveCount == 0 &&
+ warnings.any { warning -> isStalkerEmptyResponse(warning) }
+ ) {
+ stalkerCatalogAccessDiagnostic(
+ api = api,
+ primaryMessage = categoriesResult.message,
+ fallbackMessage = "empty response"
+ )
+ } else {
+ null
+ }
+ throw IllegalStateException(
+ missingCatalogDiagnostic
+ ?: "Failed to load series categories: ${categoriesResult.message}",
+ categoriesResult.exception
+ )
+ }
+ is com.streamvault.domain.model.Result.Loading -> throw IllegalStateException("Unexpected loading state")
+ }
emitCatalogSyncProgress(
section = Section.SERIES,
total = categories.size,
@@ -3976,6 +4027,7 @@ class SyncManager @Inject constructor(
)
}
)
+ seriesCategoryCount = categories.size
queueStalkerIndexSection(
providerId = provider.id,
contentType = ContentType.SERIES,
@@ -3990,6 +4042,19 @@ class SyncManager @Inject constructor(
queuedSeriesIndex = true
}
+ if (liveCount == 0 && movieCategoryCount == 0 && seriesCategoryCount == 0) {
+ val missingCatalogDiagnostic = warnings.firstOrNull { warning ->
+ warning.contains("no accessible catalog data", ignoreCase = true)
+ } ?: stalkerCatalogAccessDiagnostic(
+ api = api,
+ primaryMessage = "empty response",
+ fallbackMessage = "empty response"
+ )
+ missingCatalogDiagnostic?.let { diagnostic ->
+ throw IllegalStateException(diagnostic)
+ }
+ }
+
if (provider.epgSyncMode != ProviderEpgSyncMode.SKIP) {
upsertXtreamIndexJob(
providerId = provider.id,
@@ -5415,12 +5480,8 @@ class SyncManager @Inject constructor(
suspend fun finalizeStagedImport(): StagedStalkerLiveCatalogResult {
val sessionId = stagedSessionId
- if (acceptedCount == 0 || sessionId == null) {
- throw IllegalStateException("Stalker live catalog returned no usable channels.")
- }
-
if (hiddenLiveCategoryIds.isNotEmpty()) {
- mergeHiddenChannelsIntoStaging(provider.id, sessionId, hiddenLiveCategoryIds)
+ sessionId?.let { mergeHiddenChannelsIntoStaging(provider.id, it, hiddenLiveCategoryIds) }
}
val hiddenCategories = if (hiddenLiveCategoryIds.isNotEmpty()) {
categoryDao.getByProviderAndTypeSync(provider.id, ContentType.LIVE.name)
@@ -5436,6 +5497,17 @@ class SyncManager @Inject constructor(
)
.distinctBy { it.categoryId to it.type }
.takeIf { it.isNotEmpty() }
+ if (acceptedCount == 0 || sessionId == null) {
+ syncCatalogStore.replaceLiveCatalog(
+ providerId = provider.id,
+ categories = categories,
+ channels = emptyList()
+ )
+ return StagedStalkerLiveCatalogResult(
+ acceptedCount = 0,
+ warnings = (warnings + "Live TV provider exposed no live channels; continuing with VOD and series only.").distinct()
+ )
+ }
syncCatalogStore.applyStagedLiveCatalog(provider.id, sessionId, categories)
return StagedStalkerLiveCatalogResult(acceptedCount, warnings)
}
@@ -5483,7 +5555,17 @@ class SyncManager @Inject constructor(
val fallbackCategories = preferredCategories.orEmpty()
if (fallbackCategories.isEmpty()) {
- throw bulkFailure ?: IllegalStateException("Failed to load live channels")
+ return StagedStalkerLiveCatalogResult(
+ acceptedCount = 0,
+ warnings = (
+ warnings + listOfNotNull(
+ "Live TV provider exposed no live channels; continuing with VOD and series only.",
+ bulkFailure?.let(::sanitizeThrowableMessage)
+ ?.takeIf { it.isNotBlank() }
+ ?.let { "Live TV fetch returned no usable channels: $it" }
+ )
+ ).distinct()
+ )
}
Log.w(
diff --git a/data/src/test/java/com/streamvault/data/repository/ProviderRepositoryImplTest.kt b/data/src/test/java/com/streamvault/data/repository/ProviderRepositoryImplTest.kt
index 661217d0..20440a91 100644
--- a/data/src/test/java/com/streamvault/data/repository/ProviderRepositoryImplTest.kt
+++ b/data/src/test/java/com/streamvault/data/repository/ProviderRepositoryImplTest.kt
@@ -2,12 +2,14 @@ package com.streamvault.data.repository
import com.google.common.truth.Truth.assertThat
import com.streamvault.data.local.DatabaseTransactionRunner
+import com.streamvault.data.local.dao.CategoryDao
import com.streamvault.data.local.dao.ChannelDao
import com.streamvault.data.local.dao.ProgramDao
import com.streamvault.data.local.dao.ProgramReminderDao
import com.streamvault.data.local.dao.ProviderDao
import com.streamvault.data.local.dao.RecordingRunDao
import com.streamvault.data.local.entity.ProviderEntity
+import com.streamvault.data.local.entity.CategoryEntity
import com.streamvault.data.manager.recording.RecordingAlarmScheduler
import com.streamvault.data.manager.reminder.ProgramReminderAlarmScheduler
import com.streamvault.data.preferences.PreferencesRepository
@@ -27,6 +29,7 @@ import com.streamvault.domain.model.ProviderType
import com.streamvault.domain.model.ProviderXtreamLiveSyncMode
import com.streamvault.domain.model.SyncMetadata
import com.streamvault.domain.repository.SyncMetadataRepository
+import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.test.runTest
import org.junit.Test
@@ -44,6 +47,7 @@ import org.mockito.kotlin.whenever
class ProviderRepositoryImplTest {
private val providerDao: ProviderDao = mock()
+ private val categoryDao: CategoryDao = mock()
private val channelDao: ChannelDao = mock()
private val programDao: ProgramDao = mock()
private val recordingRunDao: RecordingRunDao = mock()
@@ -64,6 +68,7 @@ class ProviderRepositoryImplTest {
transactionRunner: DatabaseTransactionRunner = this.transactionRunner
) = ProviderRepositoryImpl(
providerDao = providerDao,
+ categoryDao = categoryDao,
channelDao = channelDao,
programDao = programDao,
recordingRunDao = recordingRunDao,
@@ -83,6 +88,9 @@ class ProviderRepositoryImplTest {
init {
whenever(preferencesRepository.xtreamBase64TextCompatibility).thenReturn(flowOf(false))
+ runBlocking {
+ whenever(categoryDao.getByProviderAndTypeSync(any(), any())).thenReturn(emptyList())
+ }
}
@Test
@@ -502,4 +510,61 @@ class ProviderRepositoryImplTest {
verify(providerDao).setActive(9L)
verify(syncManager, never()).scheduleProviderSyncResume(9L)
}
-}
\ No newline at end of file
+
+ @Test
+ fun `loginXtream does not fail onboarding when provider has no live but committed vod categories`() = runTest {
+ whenever(providerDao.getByUrlAndUser("https://example.com", "user")).thenReturn(null)
+ whenever(credentialCrypto.encryptIfNeeded("pass")).thenReturn("pass")
+ whenever(providerDao.insert(any())).thenReturn(9L)
+ whenever(syncManager.sync(eq(9L), eq(false), anyOrNull(), anyOrNull(), anyOrNull(), eq(true)))
+ .thenReturn(Result.success(Unit))
+ whenever(syncManager.currentSyncState(9L)).thenReturn(SyncState.Success(123L))
+ whenever(channelDao.getCount(9L)).thenReturn(flowOf(0))
+ whenever(syncMetadataRepository.getMetadata(9L)).thenReturn(SyncMetadata(providerId = 9L))
+ whenever(categoryDao.getByProviderAndTypeSync(9L, "MOVIE")).thenReturn(
+ listOf(
+ CategoryEntity(
+ providerId = 9L,
+ categoryId = 42L,
+ name = "Action",
+ parentId = null,
+ type = com.streamvault.domain.model.ContentType.MOVIE
+ )
+ )
+ )
+ whenever(categoryDao.getByProviderAndTypeSync(9L, "SERIES")).thenReturn(emptyList())
+ whenever(xtreamApiService.authenticate(any(), any())).thenReturn(
+ XtreamAuthResponse(
+ userInfo = XtreamUserInfo(
+ username = "user",
+ password = "pass",
+ auth = 1,
+ status = "Active"
+ ),
+ serverInfo = XtreamServerInfo(
+ url = "example.com",
+ port = "80",
+ serverProtocol = "http"
+ )
+ )
+ )
+
+ val result = repository.loginXtream(
+ serverUrl = "https://example.com",
+ username = "user",
+ password = "pass",
+ name = "Xtream",
+ httpUserAgent = "",
+ httpHeaders = "",
+ xtreamFastSyncEnabled = false,
+ epgSyncMode = ProviderEpgSyncMode.UPFRONT,
+ xtreamLiveSyncMode = ProviderXtreamLiveSyncMode.AUTO,
+ onProgress = null,
+ id = null
+ )
+
+ assertThat(result.isSuccess).isTrue()
+ verify(providerDao).setActive(9L)
+ verify(syncManager, never()).scheduleProviderSyncResume(9L)
+ }
+}
diff --git a/data/src/test/java/com/streamvault/data/sync/ProviderSyncWorkerTest.kt b/data/src/test/java/com/streamvault/data/sync/ProviderSyncWorkerTest.kt
index b407c05b..3e3ff856 100644
--- a/data/src/test/java/com/streamvault/data/sync/ProviderSyncWorkerTest.kt
+++ b/data/src/test/java/com/streamvault/data/sync/ProviderSyncWorkerTest.kt
@@ -1,21 +1,26 @@
package com.streamvault.data.sync
import com.google.common.truth.Truth.assertThat
+import com.streamvault.data.local.dao.CategoryDao
import com.streamvault.data.local.dao.ChannelDao
import com.streamvault.data.local.dao.ProviderDao
import com.streamvault.data.local.dao.XtreamLiveOnboardingDao
+import com.streamvault.data.local.entity.CategoryEntity
import com.streamvault.data.local.entity.ProviderEntity
import com.streamvault.data.local.entity.XtreamLiveOnboardingStateEntity
+import com.streamvault.domain.model.ContentType
import com.streamvault.domain.model.ProviderStatus
import com.streamvault.domain.model.SyncMetadata
import com.streamvault.domain.model.ProviderType
import com.streamvault.domain.model.Result
import com.streamvault.domain.model.SyncState
import com.streamvault.domain.repository.SyncMetadataRepository
+import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.test.runTest
import org.junit.Test
import org.mockito.kotlin.argumentCaptor
+import org.mockito.kotlin.any
import org.mockito.kotlin.mock
import org.mockito.kotlin.never
import org.mockito.kotlin.verify
@@ -23,11 +28,18 @@ import org.mockito.kotlin.whenever
class ProviderSyncWorkerTest {
private val providerDao: ProviderDao = mock()
+ private val categoryDao: CategoryDao = mock()
private val channelDao: ChannelDao = mock()
private val xtreamLiveOnboardingDao: XtreamLiveOnboardingDao = mock()
private val syncManager: SyncManager = mock()
private val syncMetadataRepository: SyncMetadataRepository = mock()
+ init {
+ runBlocking {
+ whenever(categoryDao.getByProviderAndTypeSync(any(), any())).thenReturn(emptyList())
+ }
+ }
+
@Test
fun `xtream provider with incomplete onboarding state is tracked for initial live resume`() = runTest {
val provider = ProviderEntity(
@@ -86,6 +98,7 @@ class ProviderSyncWorkerTest {
reconcileTargetedProviderStatus(
providerDao = providerDao,
channelDao = channelDao,
+ categoryDao = categoryDao,
syncMetadataRepository = syncMetadataRepository,
syncManager = syncManager,
provider = provider,
@@ -118,6 +131,7 @@ class ProviderSyncWorkerTest {
reconcileTargetedProviderStatus(
providerDao = providerDao,
channelDao = channelDao,
+ categoryDao = categoryDao,
syncMetadataRepository = syncMetadataRepository,
syncManager = syncManager,
provider = provider,
@@ -153,6 +167,53 @@ class ProviderSyncWorkerTest {
reconcileTargetedProviderStatus(
providerDao = providerDao,
channelDao = channelDao,
+ categoryDao = categoryDao,
+ syncMetadataRepository = syncMetadataRepository,
+ syncManager = syncManager,
+ provider = provider,
+ result = Result.success(Unit),
+ currentTimeMillis = 456L
+ )
+
+ val updatedProvider = argumentCaptor<ProviderEntity>()
+ verify(providerDao).update(updatedProvider.capture())
+ assertThat(updatedProvider.firstValue.isActive).isTrue()
+ assertThat(updatedProvider.firstValue.status).isEqualTo(ProviderStatus.ACTIVE)
+ assertThat(updatedProvider.firstValue.lastSyncedAt).isEqualTo(456L)
+ }
+
+ @Test
+ fun `targeted xtream resume success with no live but vod categories activates provider`() = runTest {
+ val provider = ProviderEntity(
+ id = 9L,
+ name = "Xtream",
+ type = ProviderType.XTREAM_CODES,
+ serverUrl = "https://example.com",
+ username = "user",
+ isActive = false,
+ status = ProviderStatus.PARTIAL,
+ lastSyncedAt = 0L
+ )
+ whenever(syncManager.currentSyncState(9L)).thenReturn(SyncState.Success(123L))
+ whenever(channelDao.getCount(9L)).thenReturn(flowOf(0))
+ whenever(syncMetadataRepository.getMetadata(9L)).thenReturn(SyncMetadata(providerId = 9L))
+ whenever(categoryDao.getByProviderAndTypeSync(9L, ContentType.MOVIE.name)).thenReturn(
+ listOf(
+ CategoryEntity(
+ providerId = 9L,
+ categoryId = 42L,
+ name = "Action",
+ parentId = null,
+ type = ContentType.MOVIE
+ )
+ )
+ )
+ whenever(categoryDao.getByProviderAndTypeSync(9L, ContentType.SERIES.name)).thenReturn(emptyList())
+
+ reconcileTargetedProviderStatus(
+ providerDao = providerDao,
+ channelDao = channelDao,
+ categoryDao = categoryDao,
syncMetadataRepository = syncMetadataRepository,
syncManager = syncManager,
provider = provider,
@@ -182,6 +243,7 @@ class ProviderSyncWorkerTest {
reconcileTargetedProviderStatus(
providerDao = providerDao,
channelDao = channelDao,
+ categoryDao = categoryDao,
syncMetadataRepository = syncMetadataRepository,
syncManager = syncManager,
provider = provider,
diff --git a/data/src/test/java/com/streamvault/data/sync/SyncManagerTest.kt b/data/src/test/java/com/streamvault/data/sync/SyncManagerTest.kt
index 9c242f5f..0c19cb31 100644
--- a/data/src/test/java/com/streamvault/data/sync/SyncManagerTest.kt
+++ b/data/src/test/java/com/streamvault/data/sync/SyncManagerTest.kt
@@ -283,6 +283,7 @@ class SyncManagerTest {
org.mockito.kotlin.whenever(preferencesRepo.getHiddenCategoryIds(any(), any())).thenReturn(flowOf(emptySet()))
runBlocking {
org.mockito.kotlin.whenever(categoryDao.getByProviderAndTypeSync(any(), any())).thenReturn(emptyList())
+ org.mockito.kotlin.whenever(channelDao.getCount(any())).thenReturn(flowOf(0))
org.mockito.kotlin.whenever(channelDao.getByProviderSync(any())).thenReturn(emptyList())
org.mockito.kotlin.whenever(movieDao.getCount(any())).thenReturn(flowOf(0))
org.mockito.kotlin.whenever(movieDao.getCountByCategory(any(), any())).thenReturn(flowOf(0))
@@ -307,6 +308,10 @@ class SyncManagerTest {
// exhaustiveness check in SyncManager with NoWhenBranchMatchedException.
org.mockito.kotlin.whenever(stalkerApiService.streamLiveStreams(any(), any(), any()))
.thenReturn(Result.success(0))
+ org.mockito.kotlin.whenever(stalkerApiService.getVodCategories(any(), any()))
+ .thenReturn(Result.success(emptyList()))
+ org.mockito.kotlin.whenever(stalkerApiService.getSeriesCategories(any(), any()))
+ .thenReturn(Result.success(emptyList()))
org.mockito.kotlin.whenever(
stalkerApiService.streamBulkEpg(any(), any(), any(), any())
).thenReturn(Result.success(0))
@@ -405,19 +410,43 @@ class SyncManagerTest {
// ── Xtream sync failure ─────────────────────────────────────────
@Test
- fun `sync_xtream_networksError_transitionsToError`() = runTest {
+ fun `sync_xtream_networksError_transitionsToPartial`() = runTest {
val mgr = buildManager(providerType = ProviderType.XTREAM_CODES)
// The Xtream path calls XtreamProvider(xtreamApi,...).getLiveCategories()
// Since xtreamApi is a mock with null returns, the call throws → manager catches → Error
- mgr.sync(1L)
+ val result = mgr.sync(1L)
advanceUntilIdle()
- assertThat(mgr.currentSyncState(1L)).isInstanceOf(SyncState.Error::class.java)
+ assertThat(result).isInstanceOf(Result.Success::class.java)
+ assertThat(mgr.currentSyncState(1L)).isInstanceOf(SyncState.Partial::class.java)
}
@Test
- fun `sync_xtream_stateMustPassThroughSyncing`() = runTest {
+ fun `sync_xtream_with_empty_live_catalog_still_queues_vod_and_series`() = runTest {
+ val mgr = buildManager(providerType = ProviderType.XTREAM_CODES)
+
+ xtreamBackend.respond(action = "get_live_categories", body = "[]")
+ xtreamBackend.respond(action = "get_vod_categories", body = """[{"category_id":"42","category_name":"Action"}]""")
+ xtreamBackend.respond(action = "get_series_categories", body = """[{"category_id":"77","category_name":"Drama"}]""")
+
+ val result = mgr.sync(1L)
+
+ assertThat(result).isInstanceOf(Result.Success::class.java)
+ val queuedJobCaptor = argumentCaptor<XtreamIndexJobEntity>()
+ verify(xtreamIndexJobDao, atLeastOnce()).upsert(queuedJobCaptor.capture())
+ assertThat(queuedJobCaptor.allValues.any { job ->
+ job.section == ContentType.MOVIE.name && job.state == "QUEUED"
+ }).isTrue()
+ assertThat(queuedJobCaptor.allValues.any { job ->
+ job.section == ContentType.SERIES.name && job.state == "QUEUED"
+ }).isTrue()
+ assertThat(xtreamBackend.requestedActions).contains("get_vod_categories")
+ assertThat(xtreamBackend.requestedActions).contains("get_series_categories")
+ }
+
+ @Test
+ fun `sync_xtream_stateMustPassThroughSyncing_toPartial`() = runTest {
val mgr = buildManager(providerType = ProviderType.XTREAM_CODES)
// In TestDispatcher, sync() runs synchronously and state transitions complete
@@ -427,16 +456,16 @@ class SyncManagerTest {
advanceUntilIdle()
val finalState = mgr.currentSyncState(1L)
- assertThat(finalState).isInstanceOf(SyncState.Error::class.java)
+ assertThat(finalState).isInstanceOf(SyncState.Partial::class.java)
}
@Test
- fun `sync_xtream_errorHasNonEmptyMessage`() = runTest {
+ fun `sync_xtream_partialHasNonEmptyMessage`() = runTest {
val mgr = buildManager(providerType = ProviderType.XTREAM_CODES)
mgr.sync(1L)
advanceUntilIdle()
- val state = mgr.currentSyncState(1L) as? SyncState.Error
+ val state = mgr.currentSyncState(1L) as? SyncState.Partial
assertThat(state).isNotNull()
assertThat(state!!.message).isNotEmpty()
}
@@ -914,7 +943,7 @@ class SyncManagerTest {
}
@Test
- fun `sync_xtream_empty_valid_live_without_existing_channels_transitions_to_error`() = runTest {
+ fun `sync_xtream_empty_valid_live_without_existing_channels_continues_with_vod_and_series`() = runTest {
val mgr = buildManager(providerType = ProviderType.XTREAM_CODES)
org.mockito.kotlin.whenever(channelDao.getCount(1L)).thenReturn(flowOf(0))
xtreamBackend.respond(action = "get_live_categories", body = """[{"category_id":"1","category_name":"News"}]""")
@@ -924,10 +953,8 @@ class SyncManagerTest {
val result = mgr.sync(1L, force = false)
advanceUntilIdle()
- assertThat(result.isError).isTrue()
- val error = result as Result.Error
- assertThat(error.message).isEqualTo("Provider returned an empty catalog.")
- assertThat(mgr.currentSyncState(1L)).isInstanceOf(SyncState.Error::class.java)
+ assertThat(result.isSuccess).isTrue()
+ assertThat(mgr.currentSyncState(1L)).isInstanceOf(SyncState.Partial::class.java)
}
@Test
@@ -2408,6 +2435,54 @@ class SyncManagerTest {
verify(stalkerApiService, org.mockito.kotlin.times(0)).getSeries(any(), any(), anyOrNull())
}
+ @Test
+ fun sync_stalker_with_empty_live_catalog_still_queues_vod_and_series_categories() = runTest {
+ val providerEntity = sampleProvider(ProviderType.STALKER_PORTAL).copy(
+ serverUrl = "http://example.com",
+ username = "",
+ password = "",
+ stalkerMacAddress = "00:11:22:33:44:55",
+ epgSyncMode = ProviderEpgSyncMode.SKIP
+ )
+ val manager = buildManager(providerType = ProviderType.STALKER_PORTAL, providerEntity = providerEntity)
+
+ org.mockito.kotlin.whenever(stalkerApiService.authenticate(any())).thenReturn(
+ Result.success(
+ StalkerSession(
+ loadUrl = "http://example.com/stalker_portal/server/load.php",
+ portalReferer = "http://example.com/stalker_portal/c/",
+ token = "token"
+ ) to StalkerProviderProfile(accountName = "Stalker")
+ )
+ )
+ org.mockito.kotlin.whenever(stalkerApiService.getLiveCategories(any(), any())).thenReturn(
+ Result.success(emptyList())
+ )
+ stalkerApiService.stubStreamLiveStreams(emptyList())
+ org.mockito.kotlin.whenever(stalkerApiService.getVodCategories(any(), any())).thenReturn(
+ Result.success(listOf(StalkerCategoryRecord(id = "42", name = "Action")))
+ )
+ org.mockito.kotlin.whenever(stalkerApiService.getSeriesCategories(any(), any())).thenReturn(
+ Result.success(listOf(StalkerCategoryRecord(id = "77", name = "Drama")))
+ )
+
+ val result = manager.sync(providerId = 1L, force = false)
+
+ assertThat(result).isInstanceOf(Result.Success::class.java)
+ verify(stalkerApiService).getVodCategories(any(), any())
+ verify(stalkerApiService).getSeriesCategories(any(), any())
+ verify(xtreamIndexJobDao, atLeastOnce()).upsert(check<XtreamIndexJobEntity> { job ->
+ if (job.section == ContentType.MOVIE.name) {
+ assertThat(job.state).isEqualTo("QUEUED")
+ }
+ })
+ verify(xtreamIndexJobDao, atLeastOnce()).upsert(check<XtreamIndexJobEntity> { job ->
+ if (job.section == ContentType.SERIES.name) {
+ assertThat(job.state).isEqualTo("QUEUED")
+ }
+ })
+ }
+
@Test
fun sync_stalker_persists_wildcard_vod_and_series_categories_when_portal_category_lists_are_empty() = runTest {
val providerEntity = sampleProvider(ProviderType.STALKER_PORTAL).copy(
@@ -2773,6 +2848,12 @@ class SyncManagerTest {
Result.error("Portal returned an empty response for get_genres.")
)
stalkerApiService.stubStreamLiveStreamsError("Portal returned an empty response for get_ordered_list.")
+ org.mockito.kotlin.whenever(stalkerApiService.getVodCategories(any(), any())).thenReturn(
+ Result.error("Portal returned an empty response for get_categories.")
+ )
+ org.mockito.kotlin.whenever(stalkerApiService.getSeriesCategories(any(), any())).thenReturn(
+ Result.error("Portal returned an empty response for get_categories.")
+ )
val result = manager.sync(providerId = 1L, force = false)
@@ -3347,12 +3428,12 @@ class SyncManagerTest {
// ── Reset state ─────────────────────────────────────────────────
@Test
- fun `resetState_afterError_returnsToIdle`() = runTest {
+ fun `resetState_afterPartial_returnsToIdle`() = runTest {
val mgr = buildManager()
mgr.sync(1L) // fails → Error
advanceUntilIdle()
- assertThat(mgr.currentSyncState(1L)).isInstanceOf(SyncState.Error::class.java)
+ assertThat(mgr.currentSyncState(1L)).isInstanceOf(SyncState.Partial::class.java)
mgr.resetState()
advanceUntilIdle()
diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
index 80dd1cab..5bcdc890 100644
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -17,6 +17,7 @@ All notable product changes are recorded in this document.
### Fixed
+- Fixed Xtream and Stalker onboarding/sync so VOD-only providers are not treated as failed when Live TV is empty, and Movies/Series loading still continues.
- Fixed player stream-info failures to preserve and surface the underlying error message instead of dropping it.
- Fixed decoder error recovery to retry against alternate stream formats when available.
- Fixed XMLTV parsing for ISO timestamps that include timezone offsets.