StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
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.ktindex 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@Singletonclass 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.ktindex 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.CategoryDaoimport com.streamvault.data.local.dao.ChannelDao+import com.streamvault.domain.model.ContentTypeimport com.streamvault.domain.repository.SyncMetadataRepositoryimport com.streamvault.domain.model.ProviderTypeimport 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.ktindex 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.WorkerParametersimport androidx.work.workDataOfimport com.streamvault.data.local.dao.ProviderDaoimport com.streamvault.data.local.dao.ChannelDao+import com.streamvault.data.local.dao.CategoryDaoimport com.streamvault.data.local.dao.XtreamIndexJobDaoimport com.streamvault.data.local.dao.XtreamLiveOnboardingDaoimport com.streamvault.domain.model.ProviderStatus@@ -34,6 +35,7 @@ import java.util.concurrent.TimeUnitinternal 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(): ProviderDaofun channelDao(): ChannelDao+ fun categoryDao(): CategoryDaofun syncManager(): SyncManagerfun syncMetadataRepository(): SyncMetadataRepositoryfun 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.ktindex 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 = falsevar queuedSeriesIndex = false+ var liveCount = metadata.liveCount+ var movieCategoryCount = 0+ var seriesCategoryCount = 0if (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.acceptedCountsyncMetadataRepository.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.sizequeueStalkerIndexSection(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.sizequeueStalkerIndexSection(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.ktindex 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.repositoryimport com.google.common.truth.Truth.assertThatimport com.streamvault.data.local.DatabaseTransactionRunner+import com.streamvault.data.local.dao.CategoryDaoimport com.streamvault.data.local.dao.ChannelDaoimport com.streamvault.data.local.dao.ProgramDaoimport com.streamvault.data.local.dao.ProgramReminderDaoimport com.streamvault.data.local.dao.ProviderDaoimport com.streamvault.data.local.dao.RecordingRunDaoimport com.streamvault.data.local.entity.ProviderEntity+import com.streamvault.data.local.entity.CategoryEntityimport com.streamvault.data.manager.recording.RecordingAlarmSchedulerimport com.streamvault.data.manager.reminder.ProgramReminderAlarmSchedulerimport com.streamvault.data.preferences.PreferencesRepository@@ -27,6 +29,7 @@ import com.streamvault.domain.model.ProviderTypeimport com.streamvault.domain.model.ProviderXtreamLiveSyncModeimport com.streamvault.domain.model.SyncMetadataimport com.streamvault.domain.repository.SyncMetadataRepository+import kotlinx.coroutines.runBlockingimport kotlinx.coroutines.flow.flowOfimport kotlinx.coroutines.test.runTestimport org.junit.Test@@ -44,6 +47,7 @@ import org.mockito.kotlin.wheneverclass 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.ktindex 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.syncimport com.google.common.truth.Truth.assertThat+import com.streamvault.data.local.dao.CategoryDaoimport com.streamvault.data.local.dao.ChannelDaoimport com.streamvault.data.local.dao.ProviderDaoimport com.streamvault.data.local.dao.XtreamLiveOnboardingDao+import com.streamvault.data.local.entity.CategoryEntityimport com.streamvault.data.local.entity.ProviderEntityimport com.streamvault.data.local.entity.XtreamLiveOnboardingStateEntity+import com.streamvault.domain.model.ContentTypeimport com.streamvault.domain.model.ProviderStatusimport com.streamvault.domain.model.SyncMetadataimport com.streamvault.domain.model.ProviderTypeimport com.streamvault.domain.model.Resultimport com.streamvault.domain.model.SyncStateimport com.streamvault.domain.repository.SyncMetadataRepository+import kotlinx.coroutines.runBlockingimport kotlinx.coroutines.flow.flowOfimport kotlinx.coroutines.test.runTestimport org.junit.Testimport org.mockito.kotlin.argumentCaptor+import org.mockito.kotlin.anyimport org.mockito.kotlin.mockimport org.mockito.kotlin.neverimport org.mockito.kotlin.verify@@ -23,11 +28,18 @@ import org.mockito.kotlin.wheneverclass 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())+ }+ }+@Testfun `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.ktindex 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.PartialassertThat(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")+ }+ })+ }+@Testfun 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 → ErroradvanceUntilIdle()- 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.mdindex 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.