StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
Add unit tests for sync and hydration processes
David Nashashdab75c015718
diff --git a/app/src/main/java/com/streamvault/app/StreamVaultApp.kt b/app/src/main/java/com/streamvault/app/StreamVaultApp.ktindex f9355b85..8fd8333a 100644--- a/app/src/main/java/com/streamvault/app/StreamVaultApp.kt+++ b/app/src/main/java/com/streamvault/app/StreamVaultApp.kt@@ -30,7 +30,7 @@ import androidx.work.WorkManagerimport com.streamvault.data.manager.recording.RecordingReconcileWorkerimport com.streamvault.data.sync.ProviderSyncWorkerimport com.streamvault.data.sync.XtreamIndexWorker-import com.streamvault.data.sync.SyncManager+import com.streamvault.data.sync.ProviderSyncLifecycleimport com.streamvault.player.timeshift.TimeshiftDiskManagerimport javax.inject.Injectimport okhttp3.OkHttpClient@@ -47,7 +47,7 @@ class StreamVaultApp : Application(), SingletonImageLoader.Factory {lateinit var jellyfinImageAuthInterceptor: JellyfinImageAuthInterceptor@Inject- lateinit var syncManager: SyncManager+ lateinit var providerSyncLifecycle: ProviderSyncLifecycle@Injectlateinit var downloadManager: DownloadManager@@ -86,7 +86,7 @@ class StreamVaultApp : Application(), SingletonImageLoader.Factory {programReminderManager.restoreScheduledReminders()}applicationScope.launch {- syncManager.reconcileStalkerIndexWorkAtStartup()+ providerSyncLifecycle.reconcileStalkerIndexWorkAtStartup()}startupWorkRegistry.register()diff --git a/app/src/main/java/com/streamvault/app/di/DatabaseModule.kt b/app/src/main/java/com/streamvault/app/di/DatabaseModule.ktindex 3108f787..30b9e7a2 100644--- a/app/src/main/java/com/streamvault/app/di/DatabaseModule.kt+++ b/app/src/main/java/com/streamvault/app/di/DatabaseModule.kt@@ -6,6 +6,7 @@ import androidx.room.RoomDatabaseimport androidx.sqlite.db.framework.FrameworkSQLiteOpenHelperFactoryimport com.streamvault.app.BuildConfigimport com.streamvault.data.local.StreamVaultDatabase+import com.streamvault.data.local.StreamVaultDatabaseMigrationRegistryimport com.streamvault.data.local.dao.*import com.streamvault.data.remote.jellyfin.JellyfinProviderimport com.google.gson.Gson@@ -41,82 +42,7 @@ object DatabaseModule {FrameworkSQLiteOpenHelperFactory()})- .addMigrations(- StreamVaultDatabase.MIGRATION_1_2,- StreamVaultDatabase.MIGRATION_2_3,- StreamVaultDatabase.MIGRATION_3_4,- StreamVaultDatabase.MIGRATION_4_5,- StreamVaultDatabase.MIGRATION_5_6,- StreamVaultDatabase.MIGRATION_6_7,- StreamVaultDatabase.MIGRATION_7_8,- StreamVaultDatabase.MIGRATION_8_9,- StreamVaultDatabase.MIGRATION_9_10,- StreamVaultDatabase.MIGRATION_10_11,- StreamVaultDatabase.MIGRATION_11_12,- StreamVaultDatabase.MIGRATION_12_13,- StreamVaultDatabase.MIGRATION_13_14,- StreamVaultDatabase.MIGRATION_14_15,- StreamVaultDatabase.MIGRATION_15_16,- StreamVaultDatabase.MIGRATION_16_17,- StreamVaultDatabase.MIGRATION_17_18,- StreamVaultDatabase.MIGRATION_18_19,- StreamVaultDatabase.MIGRATION_19_20,- StreamVaultDatabase.MIGRATION_20_21,- StreamVaultDatabase.MIGRATION_21_22,- StreamVaultDatabase.MIGRATION_22_23,- StreamVaultDatabase.MIGRATION_23_24,- StreamVaultDatabase.MIGRATION_24_25,- StreamVaultDatabase.MIGRATION_25_26,- StreamVaultDatabase.MIGRATION_26_27,- StreamVaultDatabase.MIGRATION_27_28,- StreamVaultDatabase.MIGRATION_28_29,- StreamVaultDatabase.MIGRATION_29_30,- StreamVaultDatabase.MIGRATION_30_31,- StreamVaultDatabase.MIGRATION_31_32,- StreamVaultDatabase.MIGRATION_32_33,- StreamVaultDatabase.MIGRATION_33_34,- StreamVaultDatabase.MIGRATION_34_35,- StreamVaultDatabase.MIGRATION_35_36,- StreamVaultDatabase.MIGRATION_36_37,- StreamVaultDatabase.MIGRATION_37_38,- StreamVaultDatabase.MIGRATION_38_39,- StreamVaultDatabase.MIGRATION_39_40,- StreamVaultDatabase.MIGRATION_40_41,- StreamVaultDatabase.MIGRATION_41_42,- StreamVaultDatabase.MIGRATION_42_43,- StreamVaultDatabase.MIGRATION_43_44,- StreamVaultDatabase.MIGRATION_44_45,- StreamVaultDatabase.MIGRATION_45_46,- StreamVaultDatabase.MIGRATION_46_47,- StreamVaultDatabase.MIGRATION_47_48,- StreamVaultDatabase.MIGRATION_48_49,- StreamVaultDatabase.MIGRATION_49_50,- StreamVaultDatabase.MIGRATION_50_51,- StreamVaultDatabase.MIGRATION_51_52,- StreamVaultDatabase.MIGRATION_52_53,- StreamVaultDatabase.MIGRATION_53_54,- StreamVaultDatabase.MIGRATION_54_55,- StreamVaultDatabase.MIGRATION_55_56,- StreamVaultDatabase.MIGRATION_56_57,- StreamVaultDatabase.MIGRATION_57_58,- StreamVaultDatabase.MIGRATION_58_59,- StreamVaultDatabase.MIGRATION_59_60,- StreamVaultDatabase.MIGRATION_60_61,- StreamVaultDatabase.MIGRATION_61_62,- StreamVaultDatabase.MIGRATION_62_63,- StreamVaultDatabase.MIGRATION_63_64,- StreamVaultDatabase.MIGRATION_64_65,- StreamVaultDatabase.MIGRATION_65_66,- StreamVaultDatabase.MIGRATION_66_67,- StreamVaultDatabase.MIGRATION_67_68,- StreamVaultDatabase.MIGRATION_68_69,- StreamVaultDatabase.MIGRATION_69_70,- StreamVaultDatabase.MIGRATION_70_71,- StreamVaultDatabase.MIGRATION_71_72,- StreamVaultDatabase.MIGRATION_72_73,- StreamVaultDatabase.MIGRATION_73_74,- StreamVaultDatabase.MIGRATION_74_75- )+ .addMigrations(*StreamVaultDatabaseMigrationRegistry.all.toTypedArray())// NOTE: fallbackToDestructiveMigration() intentionally removed.// All future schema changes MUST add a corresponding Migration in StreamVaultDatabase..build()diff --git a/app/src/main/java/com/streamvault/app/di/RepositoryModule.kt b/app/src/main/java/com/streamvault/app/di/RepositoryModule.ktindex 2c9736ee..6fa5d316 100644--- a/app/src/main/java/com/streamvault/app/di/RepositoryModule.kt+++ b/app/src/main/java/com/streamvault/app/di/RepositoryModule.kt@@ -7,6 +7,11 @@ import com.streamvault.data.preferences.PreferencesRepositoryimport com.streamvault.data.security.AndroidKeystoreCredentialCryptoimport com.streamvault.data.security.CredentialCryptoimport com.streamvault.data.sync.ProviderSyncStateReaderImpl+import com.streamvault.data.sync.CatalogHydrationCommands+import com.streamvault.data.sync.ProviderSyncCommands+import com.streamvault.data.sync.ProviderSyncLifecycle+import com.streamvault.data.sync.ProviderSyncStateSource+import com.streamvault.data.sync.SyncManagerimport com.streamvault.data.provider.RoomProviderSnapshotRepositoryimport com.streamvault.data.provider.DefaultProviderCapabilityRegistryimport com.streamvault.data.provider.JellyfinCapabilityFactory@@ -113,6 +118,18 @@ abstract class RepositoryModule {@Binds @Singletonabstract fun bindProviderSyncStateReader(impl: ProviderSyncStateReaderImpl): ProviderSyncStateReader+ @Binds @Singleton+ abstract fun bindProviderSyncCommands(impl: SyncManager): ProviderSyncCommands++ @Binds @Singleton+ abstract fun bindCatalogHydrationCommands(impl: SyncManager): CatalogHydrationCommands++ @Binds @Singleton+ abstract fun bindProviderSyncStateSource(impl: SyncManager): ProviderSyncStateSource++ @Binds @Singleton+ abstract fun bindProviderSyncLifecycle(impl: SyncManager): ProviderSyncLifecycle+@Binds @Singletonabstract fun bindCredentialCrypto(impl: AndroidKeystoreCredentialCrypto): CredentialCryptodiff --git a/app/src/main/java/com/streamvault/app/plugins/StreamVaultPluginManager.kt b/app/src/main/java/com/streamvault/app/plugins/StreamVaultPluginManager.ktindex 5d720d1c..334ccafe 100644--- a/app/src/main/java/com/streamvault/app/plugins/StreamVaultPluginManager.kt+++ b/app/src/main/java/com/streamvault/app/plugins/StreamVaultPluginManager.kt@@ -40,13 +40,17 @@ import javax.inject.Singletonimport kotlinx.coroutines.Dispatchersimport kotlinx.coroutines.CancellationExceptionimport kotlinx.coroutines.CoroutineScope+import kotlinx.coroutines.CoroutineStartimport kotlinx.coroutines.SupervisorJobimport kotlinx.coroutines.asyncimport kotlinx.coroutines.awaitAllimport kotlinx.coroutines.coroutineScope+import kotlinx.coroutines.currentCoroutineContext+import kotlinx.coroutines.Jobimport kotlinx.coroutines.flow.firstimport kotlinx.coroutines.launchimport kotlinx.coroutines.withContext+import kotlinx.coroutines.withTimeoutOrNullimport kotlinx.serialization.json.Jsonimport kotlinx.serialization.json.JsonObjectimport okhttp3.OkHttpClient@@ -67,6 +71,8 @@ class StreamVaultPluginManager @Inject constructor(private val prefs = context.getSharedPreferences("streamvault_plugins", Context.MODE_PRIVATE)private val discoveryLock = Any()private val backgroundScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)+ private val refreshLock = Any()+ private var refreshJob: Job? = null@Volatileprivate var cachedDiscovery: List<InstalledStreamVaultPlugin>? = null@@ -111,10 +117,17 @@ class StreamVaultPluginManager @Inject constructor(suspend fun discoverPlugins(): List<InstalledStreamVaultPlugin> = withContext(Dispatchers.IO) {cachedDiscovery?.takeIf { System.currentTimeMillis() < discoveryExpiresAtMillis }?.let { return@withContext it }- val plugins = queryPluginServices()- .map { resolveInfo -> async { resolvePlugin(resolveInfo) } }- .awaitAll()- .filterNotNull()+ val resolveInfos = queryPluginServices()+ val plugins = (withTimeoutOrNull(DISCOVERY_TOTAL_TIMEOUT_MILLIS) {+ coroutineScope {+ resolveInfos+ .map { resolveInfo -> async { resolvePlugin(resolveInfo) } }+ .awaitAll()+ .filterNotNull()+ }+ } ?: resolveInfos.mapNotNull { resolveInfo ->+ metadataOnlyPlugin(resolveInfo, "Plugin discovery timed out")+ }).sortedBy { it.displayName.lowercase() }migrateLegacyEnabledStates(plugins)plugins.map { plugin -> plugin.copy(enabled = isEnabled(plugin)) }.also { discovered ->@@ -663,7 +676,27 @@ class StreamVaultPluginManager @Inject constructor(}private fun refreshTvInputCatalogInBackground() {- backgroundScope.launchCatching { tvInputChannelSyncManager.refreshTvInputCatalog() }+ synchronized(refreshLock) {+ refreshJob?.cancel()+ val newJob = backgroundScope.launch(start = CoroutineStart.LAZY) {+ try {+ tvInputChannelSyncManager.refreshTvInputCatalog()+ } catch (cancelled: CancellationException) {+ throw cancelled+ } catch (_: Exception) {+ // Best-effort catalog refresh; the next provider/plugin change retries it.+ } finally {+ val completedJob = currentCoroutineContext()[Job]+ synchronized(refreshLock) {+ if (refreshJob === completedJob) {+ refreshJob = null+ }+ }+ }+ }+ refreshJob = newJob+ newJob.start()+ }}private suspend fun resolvePlugin(resolveInfo: ResolveInfo): InstalledStreamVaultPlugin? = coroutineScope {@@ -702,6 +735,30 @@ class StreamVaultPluginManager @Inject constructor()}+ private fun metadataOnlyPlugin(+ resolveInfo: ResolveInfo,+ errorMessage: String+ ): InstalledStreamVaultPlugin? {+ val serviceInfo = resolveInfo.serviceInfo ?: return null+ val packageName = serviceInfo.packageName ?: return null+ val serviceName = serviceInfo.name ?: return null+ val appLabel = serviceInfo.loadLabel(context.packageManager)?.toString().orEmpty()+ val manifest = readManifestFromMetadata(serviceInfo.metaData)+ ?: StreamVaultPluginManifest(+ id = packageName,+ name = appLabel.ifBlank { packageName },+ description = "StreamVault plugin"+ )+ return InstalledStreamVaultPlugin(+ packageName = packageName,+ serviceClassName = serviceName,+ appLabel = appLabel,+ manifest = manifest,+ enabled = false,+ lastMessage = errorMessage+ )+ }+private suspend fun readManifestFromService(packageName: String, serviceName: String): StreamVaultPluginManifest? =runPluginCallOrNull {val response =@@ -870,6 +927,7 @@ class StreamVaultPluginManager @Inject constructor(private companion object {const val DISCOVERY_CACHE_TTL_MILLIS = 30_000Lconst val DISCOVERY_REQUEST_TIMEOUT_MILLIS = 1_500L+ const val DISCOVERY_TOTAL_TIMEOUT_MILLIS = 5_000Lconst val PLAYBACK_HANDLER_TIMEOUT_MILLIS = 5_000Lconst val PLAYBACK_TOTAL_TIMEOUT_MILLIS = 5_000L}diff --git a/app/src/main/java/com/streamvault/app/ui/screens/dashboard/DashboardViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/dashboard/DashboardViewModel.ktindex 2136d337..108324b6 100644--- a/app/src/main/java/com/streamvault/app/ui/screens/dashboard/DashboardViewModel.kt+++ b/app/src/main/java/com/streamvault/app/ui/screens/dashboard/DashboardViewModel.kt@@ -4,7 +4,7 @@ import androidx.lifecycle.ViewModelimport androidx.lifecycle.viewModelScopeimport com.streamvault.app.ui.model.orderedByRequestedRawIdsimport com.streamvault.data.preferences.PreferencesRepository-import com.streamvault.data.sync.SyncManager+import com.streamvault.data.sync.ProviderSyncStateSourceimport com.streamvault.app.update.AppUpdateActionStateimport com.streamvault.app.update.AppUpdateInstallerimport com.streamvault.app.update.isRemoteVersionNewer@@ -74,7 +74,7 @@ class DashboardViewModel @Inject constructor(private val preferencesRepository: PreferencesRepository,private val getContinueWatching: GetContinueWatching,private val getCustomCategories: GetCustomCategories,- private val syncManager: SyncManager,+ private val syncManager: ProviderSyncStateSource,private val appUpdateInstaller: AppUpdateInstaller,private val recordingManager: RecordingManager) : ViewModel() {diff --git a/app/src/main/java/com/streamvault/app/ui/screens/home/HomeViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/home/HomeViewModel.ktindex 41e38528..ac25acd2 100644--- a/app/src/main/java/com/streamvault/app/ui/screens/home/HomeViewModel.kt+++ b/app/src/main/java/com/streamvault/app/ui/screens/home/HomeViewModel.kt@@ -14,7 +14,7 @@ import com.streamvault.app.ui.model.guideLookupKeyimport com.streamvault.app.ui.model.LiveTvChannelModeimport com.streamvault.app.ui.model.LiveTvQuickFilterVisibilityModeimport com.streamvault.data.preferences.PreferencesRepository-import com.streamvault.data.sync.SyncManager+import com.streamvault.data.sync.ProviderSyncStateSourceimport com.streamvault.domain.manager.ParentalControlManagerimport com.streamvault.domain.model.ActiveLiveSourceimport com.streamvault.domain.model.ActiveLiveSourceOption@@ -80,7 +80,7 @@ class HomeViewModel @Inject constructor(private val getCustomCategories: GetCustomCategories,private val unlockParentalCategory: UnlockParentalCategory,private val parentalControlManager: ParentalControlManager,- private val syncManager: SyncManager,+ private val syncManager: ProviderSyncStateSource,private val tvInputChannelSyncManager: TvInputChannelSyncManager,private val multiViewManager: MultiViewManager,private val livePreviewHandoffManager: LivePreviewHandoffManager,diff --git a/app/src/main/java/com/streamvault/app/ui/screens/player/PlaybackSessionCoordinator.kt b/app/src/main/java/com/streamvault/app/ui/screens/player/PlaybackSessionCoordinator.ktnew file mode 100644index 00000000..f2330203--- /dev/null+++ b/app/src/main/java/com/streamvault/app/ui/screens/player/PlaybackSessionCoordinator.kt@@ -0,0 +1,33 @@+package com.streamvault.app.ui.screens.player++import java.util.concurrent.atomic.AtomicLong++/**+ * Immutable identity gate for one player preparation/session.+ *+ * Network, recovery, guide, and token-renewal callbacks may outlive the request that created+ * them. Callers must validate the returned id before applying any result to UI or the player.+ */+internal class PlaybackSessionCoordinator {+ data class Session(val id: Long)++ private val nextId = AtomicLong()++ @Volatile+ private var activeSession = Session(0L)++ val currentId: Long+ get() = activeSession.id++ fun begin(): Session {+ val session = Session(nextId.incrementAndGet())+ activeSession = session+ return session+ }++ fun isCurrent(id: Long): Boolean = activeSession.id == id++ fun invalidate() {+ activeSession = Session(nextId.incrementAndGet())+ }+}diff --git a/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModel.ktindex 7887fdbb..213537b8 100644--- a/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModel.kt+++ b/app/src/main/java/com/streamvault/app/ui/screens/player/PlayerViewModel.kt@@ -16,7 +16,6 @@ import com.streamvault.app.plugins.StreamVaultPluginManagerimport com.streamvault.app.util.isPlaybackCompleteimport com.streamvault.app.tv.LauncherRecommendationsManagerimport com.streamvault.app.tv.WatchNextManager-import com.streamvault.data.sync.SyncManagerimport com.streamvault.data.remote.stalker.StalkerUrlFactoryimport com.streamvault.data.remote.xtream.XtreamStreamUrlResolverimport com.streamvault.data.security.CredentialDecryptionException@@ -113,7 +112,6 @@ class PlayerViewModel @Inject constructor(internal val xtreamStreamUrlResolver: XtreamStreamUrlResolver,internal val seekThumbnailProvider: SeekThumbnailProvider,internal val livePreviewHandoffManager: LivePreviewHandoffManager,- internal val syncManager: SyncManager,private val downloadManager: DownloadManager,internal val okHttpClient: OkHttpClient,) : ViewModel() {@@ -276,7 +274,9 @@ class PlayerViewModel @Inject constructor(private var currentStreamClassLabel: String = "Primary"internal var lastRecordedVariantObservationSignature: String? = nullinternal var lastRecordedVodVariantObservationSignature: String? = null- internal var prepareRequestVersion: Long = 0L+ internal val playbackSessionCoordinator = PlaybackSessionCoordinator()+ internal val prepareRequestVersion: Long+ get() = playbackSessionCoordinator.currentIdinternal var readySideEffectsRequestVersion: Long? = nullinternal var currentArtworkUrl: String? = nullinternal var currentResolvedPlaybackUrl: String = ""@@ -1059,7 +1059,7 @@ class PlayerViewModel @Inject constructor(livePlaybackReadyForCurrentSession = falsereadySideEffectsRequestVersion = nullplayerEngine.setScrubbingMode(false)- return ++prepareRequestVersion+ return playbackSessionCoordinator.begin().id}internal fun clearSeriesEpisodeContext() {@@ -1146,7 +1146,7 @@ class PlayerViewModel @Inject constructor(internal fun isActivePlaybackSession(requestVersion: Long,expectedLogicalUrl: String? = null- ): Boolean = matchesActivePlaybackSession(+ ): Boolean = playbackSessionCoordinator.isCurrent(requestVersion) && matchesActivePlaybackSession(requestVersion = requestVersion,activeRequestVersion = prepareRequestVersion,expectedLogicalUrl = expectedLogicalUrl,@@ -1799,6 +1799,7 @@ class PlayerViewModel @Inject constructor()?.urloverride fun onCleared() {+ playbackSessionCoordinator.invalidate()super.onCleared()cleanupAfterCleared(mainPlayerEngine)}diff --git a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsProviderActions.kt b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsProviderActions.ktindex 0c051a88..14f3c3c1 100644--- a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsProviderActions.kt+++ b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsProviderActions.kt@@ -17,7 +17,7 @@ import com.streamvault.domain.usecase.SyncProviderimport com.streamvault.domain.usecase.SyncProviderCommandimport com.streamvault.domain.usecase.SyncProviderResultimport com.streamvault.domain.util.PersistedTimestampPolicy-import com.streamvault.data.sync.SyncManager+import com.streamvault.data.sync.ProviderSyncCommandsimport com.streamvault.data.preferences.PreferencesRepositoryimport kotlinx.coroutines.CancellationExceptionimport kotlinx.coroutines.CoroutineScope@@ -38,7 +38,7 @@ internal class SettingsProviderActions(private val combinedM3uRepository: CombinedM3uRepository,private val preferencesRepository: PreferencesRepository,private val syncProvider: SyncProvider,- private val syncManager: SyncManager,+ private val syncManager: ProviderSyncCommands,private val syncMetadataRepository: SyncMetadataRepository,private val watchNextManager: WatchNextManager,private val launcherRecommendationsManager: LauncherRecommendationsManager,diff --git a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsSyncActions.kt b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsSyncActions.ktindex b1fb54c8..1d940800 100644--- a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsSyncActions.kt+++ b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsSyncActions.kt@@ -3,7 +3,7 @@ package com.streamvault.app.ui.screens.settingsimport android.app.Applicationimport com.streamvault.app.Rimport com.streamvault.app.tvinput.TvInputChannelSyncManager-import com.streamvault.data.sync.SyncManager+import com.streamvault.data.sync.ProviderSyncCommandsimport com.streamvault.data.sync.SyncRepairSectionimport com.streamvault.domain.model.ProviderTypeimport com.streamvault.domain.model.Result@@ -16,7 +16,7 @@ import kotlinx.coroutines.launchinternal class SettingsSyncActions(private val appContext: Application,- private val syncManager: SyncManager,+ private val syncManager: ProviderSyncCommands,private val tvInputChannelSyncManager: TvInputChannelSyncManager,private val uiState: MutableStateFlow<SettingsUiState>,private val refreshProvider: (CoroutineScope, Long, SettingsProviderSyncMode, String?, Long, String?, Boolean) -> Jobdiff --git a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsViewModel.kt b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsViewModel.ktindex 7fb468a4..17397869 100644--- a/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsViewModel.kt+++ b/app/src/main/java/com/streamvault/app/ui/screens/settings/SettingsViewModel.kt@@ -22,7 +22,7 @@ import com.streamvault.data.local.dao.XtreamIndexJobDaoimport com.streamvault.data.local.dao.XtreamLiveOnboardingDaoimport com.streamvault.data.local.entity.XtreamIndexJobEntityimport com.streamvault.data.preferences.PreferencesRepository-import com.streamvault.data.sync.SyncManager+import com.streamvault.data.sync.ProviderSyncCommandsimport com.streamvault.data.sync.SyncRepairSectionimport com.streamvault.domain.model.VodCategoryLoadModeimport com.streamvault.domain.manager.BackupConflictStrategy@@ -112,7 +112,7 @@ class SettingsViewModel @Inject constructor(private val driveBackupSyncManager: DriveBackupSyncManager,private val recordingManager: RecordingManager,private val parentalControlManager: ParentalControlManager,- private val syncManager: SyncManager,+ private val syncManager: ProviderSyncCommands,private val xtreamIndexJobDao: XtreamIndexJobDao,private val xtreamLiveOnboardingDao: XtreamLiveOnboardingDao,private val syncMetadataRepository: SyncMetadataRepository,diff --git a/data/build.gradle.kts b/data/build.gradle.ktsindex 6c10fe29..87cd8630 100644--- a/data/build.gradle.kts+++ b/data/build.gradle.kts@@ -108,6 +108,7 @@ dependencies {androidTestImplementation(libs.androidx.test.ext.junit)androidTestImplementation(libs.truth)androidTestImplementation(libs.coroutines.test)+ androidTestImplementation(libs.work.testing)}afterEvaluate {diff --git a/data/src/androidTest/java/com/streamvault/data/local/CatalogSyncEquivalenceIntegrationTest.kt b/data/src/androidTest/java/com/streamvault/data/local/CatalogSyncEquivalenceIntegrationTest.ktnew file mode 100644index 00000000..11aa0ea7--- /dev/null+++ b/data/src/androidTest/java/com/streamvault/data/local/CatalogSyncEquivalenceIntegrationTest.kt@@ -0,0 +1,160 @@+package com.streamvault.data.local++import android.content.Context+import androidx.room.Room+import androidx.test.core.app.ApplicationProvider+import androidx.test.ext.junit.runners.AndroidJUnit4+import com.google.common.truth.Truth.assertThat+import com.streamvault.data.local.entity.CategoryEntity+import com.streamvault.data.local.entity.ChannelEntity+import com.streamvault.data.local.entity.MovieEntity+import com.streamvault.data.local.entity.ProviderEntity+import com.streamvault.data.parser.M3uParser+import com.streamvault.data.sync.SyncCatalogStore+import com.streamvault.data.sync.SyncManagerM3uImporter+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.LegacyProvider+import com.streamvault.domain.model.ProviderType+import kotlinx.coroutines.test.runTest+import org.junit.After+import org.junit.Before+import org.junit.Test+import org.junit.runner.RunWith+import okhttp3.MediaType.Companion.toMediaType+import okhttp3.OkHttpClient+import okhttp3.Protocol+import okhttp3.Response+import okhttp3.ResponseBody.Companion.toResponseBody++/** Verifies that full and section-repair activation converge through the production Room DAOs. */+@RunWith(AndroidJUnit4::class)+class CatalogSyncEquivalenceIntegrationTest {+ private lateinit var db: StreamVaultDatabase+ private lateinit var store: SyncCatalogStore++ @Before+ fun createDb() {+ val context = ApplicationProvider.getApplicationContext<Context>()+ db = Room.inMemoryDatabaseBuilder(context, StreamVaultDatabase::class.java).build()+ store = SyncCatalogStore(+ channelDao = db.channelDao(),+ movieDao = db.movieDao(),+ seriesDao = db.seriesDao(),+ categoryDao = db.categoryDao(),+ catalogSyncDao = db.catalogSyncDao(),+ tmdbIdentityDao = db.tmdbIdentityDao(),+ transactionRunner = RoomDatabaseTransactionRunner(db)+ )+ }++ @After+ fun closeDb() = db.close()++ @Test+ fun fullImportAndSectionRepairsConvergeToEquivalentActiveCatalogs() = runTest {+ val fullProviderId = insertProvider("Full")+ val repairProviderId = insertProvider("Repair")+ seedStaleCatalog(fullProviderId)+ seedStaleCatalog(repairProviderId)++ val importer = playlistImporter()+ importer.importPlaylist(provider(fullProviderId), onProgress = null)+ importer.importPlaylist(+ provider(repairProviderId),+ onProgress = null,+ includeLive = true,+ includeMovies = false+ )+ importer.importPlaylist(+ provider(repairProviderId),+ onProgress = null,+ includeLive = false,+ includeMovies = true+ )++ assertThat(channelSnapshot(fullProviderId)).isEqualTo(channelSnapshot(repairProviderId))+ assertThat(movieSnapshot(fullProviderId)).isEqualTo(movieSnapshot(repairProviderId))+ assertThat(categorySnapshot(fullProviderId)).isEqualTo(categorySnapshot(repairProviderId))+ assertThat(channelSnapshot(fullProviderId).map { it.streamId }).doesNotContain(999L)+ assertThat(movieSnapshot(fullProviderId).map { it.streamId }).doesNotContain(999L)+ }++ private suspend fun insertProvider(name: String): Long = db.providerDao().insert(+ ProviderEntity(name = name, type = ProviderType.M3U)+ )++ private suspend fun seedStaleCatalog(providerId: Long) {+ store.replaceLiveCatalog(+ providerId,+ categories = listOf(CategoryEntity(categoryId = 99L, name = "Stale", providerId = providerId)),+ channels = listOf(ChannelEntity(streamId = 999L, name = "Stale", providerId = providerId))+ )+ store.replaceMovieCatalog(+ providerId,+ categories = listOf(+ CategoryEntity(+ categoryId = 99L,+ name = "Stale",+ type = ContentType.MOVIE,+ providerId = providerId+ )+ ),+ movies = sequenceOf(MovieEntity(streamId = 999L, name = "Stale", providerId = providerId))+ )+ }++ private fun playlistImporter(): SyncManagerM3uImporter {+ val client = OkHttpClient.Builder().addInterceptor { chain ->+ Response.Builder()+ .request(chain.request())+ .protocol(Protocol.HTTP_1_1)+ .code(200)+ .message("OK")+ .body(PLAYLIST.toResponseBody("application/x-mpegURL".toMediaType()))+ .build()+ }.build()+ return SyncManagerM3uImporter(+ m3uParser = M3uParser(),+ okHttpClient = client,+ syncCatalogStore = store,+ retryTransient = { block -> block() },+ progress = { _, _, _ -> },+ emitProgress = { _, _ -> }+ )+ }++ private fun provider(providerId: Long) = LegacyProvider(+ id = providerId,+ name = "Provider $providerId",+ type = ProviderType.M3U,+ serverUrl = PLAYLIST_URL,+ m3uUrl = PLAYLIST_URL,+ m3uVodClassificationEnabled = true+ )++ private suspend fun channelSnapshot(providerId: Long) = db.channelDao().getByProviderSync(providerId)+ .sortedBy { it.streamId }+ .map { it.copy(id = 0L, providerId = 0L, syncFingerprint = "") }++ private suspend fun movieSnapshot(providerId: Long) = db.movieDao().getByProviderSync(providerId)+ .sortedBy { it.streamId }+ .map { it.copy(id = 0L, providerId = 0L, syncFingerprint = "") }++ private suspend fun categorySnapshot(providerId: Long) = ContentType.entries+ .flatMap { type -> db.categoryDao().getByProviderAndTypeSync(providerId, type.name) }+ .sortedWith(compareBy(CategoryEntity::type, CategoryEntity::categoryId))+ .map { it.copy(id = 0L, providerId = 0L, syncFingerprint = "") }++ private companion object {+ const val PLAYLIST_URL = "https://catalog.example.test/playlist.m3u"+ val PLAYLIST = """+ #EXTM3U+ #EXTINF:-1 tvg-id="news" group-title="Live",News+ https://stream.example.test/live/10.m3u8+ #EXTINF:-1 tvg-id="sports" group-title="Live",Sports+ https://stream.example.test/live/20.m3u8+ #EXTINF:-1 group-title="Movies",Feature+ https://stream.example.test/movie/30.mp4+ """.trimIndent()+ }+}diff --git a/data/src/androidTest/java/com/streamvault/data/local/ProviderWorkManagerSerializationTest.kt b/data/src/androidTest/java/com/streamvault/data/local/ProviderWorkManagerSerializationTest.ktnew file mode 100644index 00000000..a45b2bde--- /dev/null+++ b/data/src/androidTest/java/com/streamvault/data/local/ProviderWorkManagerSerializationTest.kt@@ -0,0 +1,66 @@+package com.streamvault.data.local++import android.content.Context+import androidx.test.core.app.ApplicationProvider+import androidx.test.ext.junit.runners.AndroidJUnit4+import androidx.work.Configuration+import androidx.work.WorkInfo+import androidx.work.WorkManager+import androidx.work.testing.WorkManagerTestInitHelper+import com.google.common.truth.Truth.assertThat+import com.streamvault.data.sync.BackgroundEpgSyncWorker+import com.streamvault.data.sync.ProviderSyncWorker+import com.streamvault.data.sync.StalkerIndexWorker+import com.streamvault.data.sync.XtreamIndexWorker+import com.streamvault.data.sync.providerWorkUniqueName+import org.junit.Before+import org.junit.Test+import org.junit.runner.RunWith+import java.util.concurrent.Executors+import java.util.concurrent.TimeUnit++/** Exercises the actual worker enqueue APIs against WorkManager's unique-work database. */+@RunWith(AndroidJUnit4::class)+class ProviderWorkManagerSerializationTest {+ private lateinit var context: Context+ private lateinit var workManager: WorkManager++ @Before+ fun setUp() {+ context = ApplicationProvider.getApplicationContext()+ WorkManagerTestInitHelper.initializeTestWorkManager(+ context,+ Configuration.Builder()+ .setExecutor(Executors.newSingleThreadExecutor())+ .build()+ )+ workManager = WorkManager.getInstance(context)+ workManager.cancelAllWork().result.get(10, TimeUnit.SECONDS)+ }++ @Test+ fun everyBackgroundPhaseForAProviderIsAppendedToOneSerialChain() {+ val providerId = 71L+ ProviderSyncWorker.enqueueProvider(context, providerId)+ XtreamIndexWorker.enqueue(context, providerId, initialDelaySeconds = ONE_HOUR_SECONDS)+ StalkerIndexWorker.enqueue(context, providerId, initialDelaySeconds = ONE_HOUR_SECONDS)+ BackgroundEpgSyncWorker.enqueue(context, providerId, initialDelaySeconds = ONE_HOUR_SECONDS)++ val work = workManager.getWorkInfosForUniqueWork(providerWorkUniqueName(providerId))+ .get(10, TimeUnit.SECONDS)++ assertThat(work).hasSize(4)+ assertThat(work.count { it.state == WorkInfo.State.ENQUEUED }).isEqualTo(1)+ assertThat(work.count { it.state == WorkInfo.State.BLOCKED }).isEqualTo(3)+ assertThat(work.flatMap { info -> info.tags }).containsAtLeast(+ ProviderSyncWorker::class.java.name,+ XtreamIndexWorker::class.java.name,+ StalkerIndexWorker::class.java.name,+ BackgroundEpgSyncWorker::class.java.name+ )+ }++ private companion object {+ const val ONE_HOUR_SECONDS = 3_600L+ }+}diff --git a/data/src/main/java/com/streamvault/data/local/StreamVaultDatabase.kt b/data/src/main/java/com/streamvault/data/local/StreamVaultDatabase.ktindex 84fc1fe1..e274d241 100644--- a/data/src/main/java/com/streamvault/data/local/StreamVaultDatabase.kt+++ b/data/src/main/java/com/streamvault/data/local/StreamVaultDatabase.kt@@ -11,6 +11,8 @@ import org.json.JSONObjectimport java.net.URIimport java.security.MessageDigest+internal const val STREAM_VAULT_DATABASE_VERSION = 75+@Database(entities = [ProviderEntity::class,@@ -67,7 +69,7 @@ import java.security.MessageDigestProviderWorkflowEntity::class,ProviderWorkflowPhaseEntity::class],- version = 75,+ version = STREAM_VAULT_DATABASE_VERSION,exportSchema = true // ← was false; schema JSON now tracked in version control)@TypeConverters(RoomEnumConverters::class)diff --git a/data/src/main/java/com/streamvault/data/local/StreamVaultDatabaseMigrationRegistry.kt b/data/src/main/java/com/streamvault/data/local/StreamVaultDatabaseMigrationRegistry.ktnew file mode 100644index 00000000..e3b18f48--- /dev/null+++ b/data/src/main/java/com/streamvault/data/local/StreamVaultDatabaseMigrationRegistry.kt@@ -0,0 +1,112 @@+package com.streamvault.data.local++import androidx.room.migration.Migration++/**+ * The single migration topology for the production database.+ *+ * Bodies remain close to the schema compatibility code in [StreamVaultDatabase], while this+ * registry is version-grouped and is the only list consumed by the database builder. The+ * contiguous-chain check fails at startup/build time if a migration is forgotten.+ */+object StreamVaultDatabaseMigrationRegistry {+ const val CURRENT_VERSION = STREAM_VAULT_DATABASE_VERSION++ val v1To24: List<Migration> = listOf(+ StreamVaultDatabase.MIGRATION_1_2,+ StreamVaultDatabase.MIGRATION_2_3,+ StreamVaultDatabase.MIGRATION_3_4,+ StreamVaultDatabase.MIGRATION_4_5,+ StreamVaultDatabase.MIGRATION_5_6,+ StreamVaultDatabase.MIGRATION_6_7,+ StreamVaultDatabase.MIGRATION_7_8,+ StreamVaultDatabase.MIGRATION_8_9,+ StreamVaultDatabase.MIGRATION_9_10,+ StreamVaultDatabase.MIGRATION_10_11,+ StreamVaultDatabase.MIGRATION_11_12,+ StreamVaultDatabase.MIGRATION_12_13,+ StreamVaultDatabase.MIGRATION_13_14,+ StreamVaultDatabase.MIGRATION_14_15,+ StreamVaultDatabase.MIGRATION_15_16,+ StreamVaultDatabase.MIGRATION_16_17,+ StreamVaultDatabase.MIGRATION_17_18,+ StreamVaultDatabase.MIGRATION_18_19,+ StreamVaultDatabase.MIGRATION_19_20,+ StreamVaultDatabase.MIGRATION_20_21,+ StreamVaultDatabase.MIGRATION_21_22,+ StreamVaultDatabase.MIGRATION_22_23,+ StreamVaultDatabase.MIGRATION_23_24+ )++ val v24To49: List<Migration> = listOf(+ StreamVaultDatabase.MIGRATION_24_25,+ StreamVaultDatabase.MIGRATION_25_26,+ StreamVaultDatabase.MIGRATION_26_27,+ StreamVaultDatabase.MIGRATION_27_28,+ StreamVaultDatabase.MIGRATION_28_29,+ StreamVaultDatabase.MIGRATION_29_30,+ StreamVaultDatabase.MIGRATION_30_31,+ StreamVaultDatabase.MIGRATION_31_32,+ StreamVaultDatabase.MIGRATION_32_33,+ StreamVaultDatabase.MIGRATION_33_34,+ StreamVaultDatabase.MIGRATION_34_35,+ StreamVaultDatabase.MIGRATION_35_36,+ StreamVaultDatabase.MIGRATION_36_37,+ StreamVaultDatabase.MIGRATION_37_38,+ StreamVaultDatabase.MIGRATION_38_39,+ StreamVaultDatabase.MIGRATION_39_40,+ StreamVaultDatabase.MIGRATION_40_41,+ StreamVaultDatabase.MIGRATION_41_42,+ StreamVaultDatabase.MIGRATION_42_43,+ StreamVaultDatabase.MIGRATION_43_44,+ StreamVaultDatabase.MIGRATION_44_45,+ StreamVaultDatabase.MIGRATION_45_46,+ StreamVaultDatabase.MIGRATION_46_47,+ StreamVaultDatabase.MIGRATION_47_48,+ StreamVaultDatabase.MIGRATION_48_49+ )++ val v49To75: List<Migration> = listOf(+ StreamVaultDatabase.MIGRATION_49_50,+ StreamVaultDatabase.MIGRATION_50_51,+ StreamVaultDatabase.MIGRATION_51_52,+ StreamVaultDatabase.MIGRATION_52_53,+ StreamVaultDatabase.MIGRATION_53_54,+ StreamVaultDatabase.MIGRATION_54_55,+ StreamVaultDatabase.MIGRATION_55_56,+ StreamVaultDatabase.MIGRATION_56_57,+ StreamVaultDatabase.MIGRATION_57_58,+ StreamVaultDatabase.MIGRATION_58_59,+ StreamVaultDatabase.MIGRATION_59_60,+ StreamVaultDatabase.MIGRATION_60_61,+ StreamVaultDatabase.MIGRATION_61_62,+ StreamVaultDatabase.MIGRATION_62_63,+ StreamVaultDatabase.MIGRATION_63_64,+ StreamVaultDatabase.MIGRATION_64_65,+ StreamVaultDatabase.MIGRATION_65_66,+ StreamVaultDatabase.MIGRATION_66_67,+ StreamVaultDatabase.MIGRATION_67_68,+ StreamVaultDatabase.MIGRATION_68_69,+ StreamVaultDatabase.MIGRATION_69_70,+ StreamVaultDatabase.MIGRATION_70_71,+ StreamVaultDatabase.MIGRATION_71_72,+ StreamVaultDatabase.MIGRATION_72_73,+ StreamVaultDatabase.MIGRATION_73_74,+ StreamVaultDatabase.MIGRATION_74_75+ )++ val all: List<Migration> = (v1To24 + v24To49 + v49To75).also(::validate)++ private fun validate(migrations: List<Migration>) {+ require(migrations.map { it.startVersion }.distinct().size == migrations.size) {+ "Duplicate Room migration start version"+ }+ val expected = 1 until CURRENT_VERSION+ require(migrations.map { it.startVersion }.toSet() == expected.toSet()) {+ "Room migration registry is incomplete: expected versions $expected"+ }+ require(migrations.all { it.endVersion == it.startVersion + 1 }) {+ "Room migration registry must contain adjacent migrations only"+ }+ }+}diff --git a/data/src/main/java/com/streamvault/data/provider/StalkerPlaybackCapabilityCache.kt b/data/src/main/java/com/streamvault/data/provider/StalkerPlaybackCapabilityCache.ktindex f84ed0a7..9178ce57 100644--- a/data/src/main/java/com/streamvault/data/provider/StalkerPlaybackCapabilityCache.kt+++ b/data/src/main/java/com/streamvault/data/provider/StalkerPlaybackCapabilityCache.kt@@ -3,7 +3,7 @@ package com.streamvault.data.providerimport com.streamvault.domain.model.ProviderSnapshotimport com.streamvault.domain.provider.CapabilityResolutionimport com.streamvault.domain.provider.PlaybackResolver-import java.util.concurrent.ConcurrentHashMap+import com.streamvault.domain.util.BoundedExpiringCacheimport javax.inject.Injectimport javax.inject.Singleton@@ -17,20 +17,23 @@ class StalkerPlaybackCapabilityCache @Inject constructor(val resolver: PlaybackResolver)- private val entries = ConcurrentHashMap<Long, Entry>()+ private val entries = BoundedExpiringCache<Long, Entry>(+ maxEntries = MAX_ENTRIES,+ ttlMillis = ENTRY_TTL_MILLIS+ )fun resolve(snapshot: ProviderSnapshot): CapabilityResolution<PlaybackResolver> {- entries[snapshot.provider.id]+ entries.get(snapshot.provider.id)?.takeIf { it.generation == snapshot.configurationGeneration }?.let { return CapabilityResolution.Available(it.resolver) }+ entries.remove(snapshot.provider.id)val resolver = when (val result = clients.stalker(snapshot)) {is CapabilityResolution.Available -> result.capabilityis CapabilityResolution.ConfigurationError -> return resultis CapabilityResolution.Restricted -> return resultis CapabilityResolution.Unsupported -> return result}- entries[snapshot.provider.id] = Entry(snapshot.configurationGeneration, resolver)- trimToBound()+ entries.put(snapshot.provider.id, Entry(snapshot.configurationGeneration, resolver))return CapabilityResolution.Available(resolver)}@@ -38,12 +41,12 @@ class StalkerPlaybackCapabilityCache @Inject constructor(entries.remove(providerId)}- private fun trimToBound() {- if (entries.size <= MAX_ENTRIES) return- entries.keys.sorted().take(entries.size - MAX_ENTRIES).forEach(entries::remove)- }+ fun invalidateAll() = entries.clear()++ internal fun sizeForTests(): Int = entries.size()private companion object {const val MAX_ENTRIES = 32+ const val ENTRY_TTL_MILLIS = 30L * 60L * 1_000L}}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.ktindex c2bbf1f4..1ba03a87 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@@ -153,6 +153,39 @@ internal companion object {fun clearResolvedStreamUrlCacheForTests() {resolvedStreamUrlCache.clear()}++ /** Provider deletion hook for process-lifetime authentication and URL caches. */+ fun clearCachesForProvider(providerId: Long) {+ if (providerId <= 0L) return+ val authPrefix = "provider:$providerId|"+ sharedAuthCache.keys.filter { it.startsWith(authPrefix) }.forEach(sharedAuthCache::remove)+ sharedAuthFailureCache.keys.filter { it.startsWith(authPrefix) }.forEach(sharedAuthFailureCache::remove)+ sharedAuthMutexes.keys.filter { it.startsWith(authPrefix) }.forEach(sharedAuthMutexes::remove)+ resolvedStreamUrlCache.keys+ .filter { it.startsWith("$providerId|") }+ .forEach(resolvedStreamUrlCache::remove)+ missingVodClassificationLogged.remove(providerId)+ }++ private fun trimSharedCaches() {+ trimMap(sharedAuthCache, MAX_AUTH_CACHE_ENTRIES)+ trimMap(sharedAuthFailureCache, MAX_AUTH_CACHE_ENTRIES)+ trimMap(resolvedStreamUrlCache, MAX_RESOLVED_URL_CACHE_ENTRIES)+ while (missingVodClassificationLogged.size > MAX_MISSING_CLASSIFICATION_ENTRIES) {+ missingVodClassificationLogged.firstOrNull()?.let(missingVodClassificationLogged::remove)+ ?: break+ }+ }++ private fun <K, V> trimMap(map: ConcurrentHashMap<K, V>, maxEntries: Int) {+ if (map.size <= maxEntries) return+ map.keys.take(map.size - maxEntries).forEach(map::remove)+ }++ private const val MAX_AUTH_CACHE_ENTRIES = 256+ private const val MAX_RESOLVED_URL_CACHE_ENTRIES = 2_048+ private const val MAX_MISSING_CLASSIFICATION_ENTRIES = 512+ private const val MAX_REMOTE_IDENTITY_CACHE_ENTRIES = 4_096}private data class CachedAuth(@@ -177,7 +210,10 @@ internal companion object {val name: String)- private val authMutex = sharedAuthMutexes.computeIfAbsent(authCacheKey()) { Mutex() }+ // Authentication lock identity must remain stable for the provider lifetime. Evicting a+ // configuration-scoped lock while an older provider instance still holds it permits a second+ // mutex to be created and defeats same-provider authentication serialization.+ private val authMutex = sharedAuthMutexes.computeIfAbsent(authMutexKey()) { Mutex() }private var sessionCache: StalkerSession? = nullprivate var accountProfileCache: StalkerProviderProfile? = nullprivate var authFailureCache: CachedAuthFailure? = null@@ -218,6 +254,7 @@ internal companion object {?: (now + RESOLVED_URL_CACHE_SOFT_TTL_MILLIS)resolvedStreamUrlCache[resolvedStreamUrlCacheKey(kind, cmd)] =CachedResolvedUrl(url = url, expiresAt = expiry)+ trimSharedCaches()}private fun clearResolvedStreamUrlCache() {@@ -462,7 +499,7 @@ internal companion object {categoryCache[ContentType.SERIES] = categoryCache[ContentType.SERIES].orEmpty().filterNot { it.rawId == rawId } + CategorySeed(projectedId, rawId, name)- remoteIdentityCache[ContentType.SERIES to rawId] = projectedId+ putRemoteIdentity(ContentType.SERIES to rawId, projectedId)return projectedId}@@ -480,7 +517,7 @@ internal companion object {categoryCache[ContentType.MOVIE] = categoryCache[ContentType.MOVIE].orEmpty().filterNot { it.rawId == rawId } + CategorySeed(projectedId, rawId, name)- remoteIdentityCache[ContentType.MOVIE to rawId] = projectedId+ putRemoteIdentity(ContentType.MOVIE to rawId, projectedId)return projectedId}@@ -1310,7 +1347,7 @@ is Result.Success -> {rawId.toLongOrNull()?.takeIf { it > 0L } ?: fallbackStableId(type, rawId)}resolved.forEach { (rawId, surrogateId) ->- remoteIdentityCache[type to rawId] = surrogateId+ putRemoteIdentity(type to rawId, surrogateId)}}@@ -1323,10 +1360,10 @@ is Result.Success -> {if (resolved == null) {records.forEach { record ->val rawId = record.id.ifBlank { record.name }.trim()- remoteIdentityCache[type to rawId] = fallbackStableId(type, rawId)+ putRemoteIdentity(type to rawId, fallbackStableId(type, rawId))}} else {- resolved.forEach { (rawId, surrogateId) -> remoteIdentityCache[type to rawId] = surrogateId }+ resolved.forEach { (rawId, surrogateId) -> putRemoteIdentity(type to rawId, surrogateId) }}}@@ -1497,6 +1534,7 @@ is Result.Success -> {session = authResult.data.first,profile = authResult.data.second)+ trimSharedCaches()portalStateStore?.recordAuthentication(providerId = providerId,session = authResult.data.first,@@ -1519,6 +1557,7 @@ is Result.Success -> {exception = authResult.exception)sharedAuthFailureCache[authCacheKey()] = authFailureCache!!+ trimSharedCaches()Result.error(authResult.message, authResult.exception)}is Result.Loading -> Result.error("Unexpected loading state")@@ -2151,6 +2190,7 @@ private fun playbackTransportChallengeFor(url: String): StalkerTransportChalleng): Movie? {if (item.isSeries) return nullif (!item.hasSeriesMarker && missingVodClassificationLogged.add(providerId)) {+ trimSharedCaches()StalkerTelemetry.missingVodClassification(providerId)}val numericId = stableItemId(ContentType.MOVIE, item.id)@@ -2463,12 +2503,20 @@ private fun playbackTransportChallengeFor(url: String): StalkerTransportChallenggenerateSequence(FALLBACK_SURROGATE_FLOOR) { it + 1L }.first { it !in used }}- remoteIdentityCache[key] = candidate+ putRemoteIdentity(key, candidate)candidate}}}+ private fun putRemoteIdentity(key: Pair<ContentType, String>, value: Long) {+ remoteIdentityCache[key] = value+ if (remoteIdentityCache.size > MAX_REMOTE_IDENTITY_CACHE_ENTRIES) {+ remoteIdentityCache.keys.take(remoteIdentityCache.size - MAX_REMOTE_IDENTITY_CACHE_ENTRIES)+ .forEach(remoteIdentityCache::remove)+ }+ }+private fun normalizedMacAddress(): String =macAddress.trim().uppercase(Locale.ROOT)@@ -2527,11 +2575,14 @@ private fun playbackTransportChallengeFor(url: String): StalkerTransportChallengnormalizedSignature(),stalkerAdvancedOptionsJson).joinToString(separator = "\u001f")- return MessageDigest.getInstance("SHA-256")+ val digest = MessageDigest.getInstance("SHA-256").digest(normalized.toByteArray(Charsets.UTF_8)).joinToString("") { byte -> "%02x".format(byte.toInt() and 0xff) }+ return "provider:$providerId|$digest"}+ private fun authMutexKey(): String = "provider:$providerId|auth"+private fun resolveProviderStatus(profile: StalkerProviderProfile): ProviderStatus {val normalizedStatus = profile.statusLabel?.trim()?.lowercase(Locale.ROOT).orEmpty()if (normalizedStatus in setOf("disabled", "blocked", "banned")) {diff --git a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerRequestCoordinator.kt b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerRequestCoordinator.ktindex 32f55da5..f799e703 100644--- a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerRequestCoordinator.kt+++ b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerRequestCoordinator.kt@@ -97,6 +97,11 @@ class StalkerRequestCoordinator @Inject constructor(private val states = ConcurrentHashMap<Long, ProviderState>()private val tickets = AtomicLong()+ /** Drops idle/adaptive state after the owning provider has been deleted. */+ fun forgetProvider(providerId: Long) {+ if (providerId > 0L) states.remove(providerId)+ }+suspend fun <T> execute(providerId: Long,priority: StalkerRequestPriority,diff --git a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerTrafficCoordinator.kt b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerTrafficCoordinator.ktindex 7e20148a..1250e06e 100644--- a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerTrafficCoordinator.kt+++ b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerTrafficCoordinator.kt@@ -27,6 +27,10 @@ internal object StalkerTrafficCoordinator {fun isPlaybackActive(providerId: Long): Boolean =providerId > 0L && (activePlaybackCountsByProvider[providerId] ?: 0) > 0+ fun forgetProvider(providerId: Long) {+ if (providerId > 0L) activePlaybackCountsByProvider.remove(providerId)+ }+/** Playback never blocks interactive requests; only maintenance slows between pages. */fun backgroundInterPageDelayMillis(providerId: Long): Long =if (isPlaybackActive(providerId)) {diff --git a/data/src/main/java/com/streamvault/data/remote/xtream/PlaybackResolutionCoordinator.kt b/data/src/main/java/com/streamvault/data/remote/xtream/PlaybackResolutionCoordinator.ktnew file mode 100644index 00000000..6cfd63f6--- /dev/null+++ b/data/src/main/java/com/streamvault/data/remote/xtream/PlaybackResolutionCoordinator.kt@@ -0,0 +1,83 @@+package com.streamvault.data.remote.xtream++import com.streamvault.data.provider.ProviderCapabilityResolver+import com.streamvault.data.remote.stalker.StalkerPlaybackResolutionException+import com.streamvault.data.remote.stalker.StalkerUrlFactory+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.Result+import com.streamvault.domain.provider.CapabilityResolution+import com.streamvault.domain.provider.PlaybackRequest+import com.streamvault.domain.provider.ProviderContentReference++/** Resolves a typed provider playback capability without constructing provider sessions itself. */+internal class PlaybackResolutionCoordinator(+ private val providerCapabilities: ProviderCapabilityResolver+) {+ suspend fun resolve(+ sourceUrl: String,+ providerId: Long,+ streamId: Long?,+ contentType: ContentType,+ containerExtension: String?,+ preferStableUrl: Boolean,+ isStalkerSource: Boolean+ ): ResolvedStreamUrl? {+ val capabilitySet = when (val resolution = providerCapabilities.resolve(providerId)) {+ is CapabilityResolution.Available -> resolution.capability+ is CapabilityResolution.ConfigurationError -> return unavailable(sourceUrl, resolution.reason, isStalkerSource)+ is CapabilityResolution.Restricted -> return unavailable(sourceUrl, resolution.reason, isStalkerSource)+ is CapabilityResolution.Unsupported -> return unavailable(sourceUrl, resolution.reason, isStalkerSource)+ }+ val playback = when (val resolution = capabilitySet.playback()) {+ is CapabilityResolution.Available -> resolution.capability+ is CapabilityResolution.ConfigurationError -> return unavailable(sourceUrl, resolution.reason, isStalkerSource)+ is CapabilityResolution.Restricted -> return unavailable(sourceUrl, resolution.reason, isStalkerSource)+ is CapabilityResolution.Unsupported -> return unavailable(sourceUrl, resolution.reason, isStalkerSource)+ }+ return when (val result = playback.resolve(+ PlaybackRequest(+ sourceUrl = sourceUrl,+ content = ProviderContentReference(providerId = providerId, streamId = streamId),+ contentType = contentType,+ containerExtension = containerExtension,+ preferStableUrl = preferStableUrl+ )+ )) {+ is Result.Success -> result.data.let { resolved ->+ ResolvedStreamUrl(+ url = resolved.url,+ expirationTime = resolved.expirationTime ?: extractStreamExpirationTime(resolved.url),+ containerExtension = resolved.containerExtension,+ headers = resolved.headers,+ userAgent = resolved.userAgent,+ playbackTransportPolicy = resolved.playbackTransportPolicy,+ allowInvalidSsl = resolved.allowInvalidSsl,+ proxyHost = resolved.proxyHost,+ proxyPort = resolved.proxyPort+ )+ }+ is Result.Error -> {+ if (isStalkerSource) {+ throw StalkerPlaybackResolutionException(result.message, result.exception)+ }+ null+ }+ is Result.Loading -> null+ }+ }++ private fun unavailable(url: String, reason: String, isStalkerSource: Boolean): ResolvedStreamUrl? {+ if (isStalkerSource) throw StalkerPlaybackResolutionException(reason)+ return url.takeIf {+ it.isNotBlank() &&+ !XtreamUrlFactory.isInternalStreamUrl(it) &&+ !StalkerUrlFactory.isInternalStreamUrl(it)+ }+ ?.let { passthrough ->+ ResolvedStreamUrl(+ url = passthrough,+ expirationTime = extractStreamExpirationTime(passthrough)+ )+ }+ }+}diff --git a/data/src/main/java/com/streamvault/data/remote/xtream/XtreamStreamUrlResolver.kt b/data/src/main/java/com/streamvault/data/remote/xtream/XtreamStreamUrlResolver.ktindex 735b4ef3..7b24e009 100644--- a/data/src/main/java/com/streamvault/data/remote/xtream/XtreamStreamUrlResolver.kt+++ b/data/src/main/java/com/streamvault/data/remote/xtream/XtreamStreamUrlResolver.kt@@ -1,15 +1,9 @@package com.streamvault.data.remote.xtream-import com.streamvault.data.provider.ProviderCapabilityResolver-import com.streamvault.data.remote.stalker.StalkerPlaybackResolutionExceptionimport com.streamvault.data.remote.stalker.StalkerStreamKindimport com.streamvault.data.remote.stalker.StalkerUrlFactoryimport com.streamvault.domain.model.ContentTypeimport com.streamvault.domain.model.PlaybackTransportPolicy-import com.streamvault.domain.model.Result-import com.streamvault.domain.provider.CapabilityResolution-import com.streamvault.domain.provider.PlaybackRequest-import com.streamvault.domain.provider.ProviderContentReferenceimport java.net.URIimport javax.inject.Injectimport javax.inject.Singleton@@ -29,8 +23,10 @@ data class ResolvedStreamUrl(/** Provider-neutral playback entry point. Provider selection is owned by the capability registry. */@Singletonclass XtreamStreamUrlResolver @Inject constructor(- private val providerCapabilities: ProviderCapabilityResolver+ providerCapabilities: com.streamvault.data.provider.ProviderCapabilityResolver) {+ private val playbackCoordinator = PlaybackResolutionCoordinator(providerCapabilities)+fun isInternalStreamUrl(url: String?): Boolean =XtreamUrlFactory.isInternalStreamUrl(url) || StalkerUrlFactory.isInternalStreamUrl(url)@@ -63,7 +59,13 @@ class XtreamStreamUrlResolver @Inject constructor(val providerId = xtreamToken?.providerId?: stalkerToken?.providerId?: fallbackProviderId?.takeIf { it > 0L }- ?: return url.takeIf(String::isNotBlank)?.toPassthrough(fallbackContainerExtension)+ ?: return url.takeIf(String::isNotBlank)?.let {+ ResolvedStreamUrl(+ url = it,+ expirationTime = extractStreamExpirationTime(it),+ containerExtension = fallbackContainerExtension+ )+ }val contentType = fallbackContentType?: xtreamToken?.kind?.toContentType()?: stalkerToken?.kind?.toContentType()@@ -72,66 +74,28 @@ class XtreamStreamUrlResolver @Inject constructor(?: stalkerToken?.itemId?: fallbackStreamId?.takeIf { it > 0L }- val capabilitySet = when (val resolution = providerCapabilities.resolve(providerId)) {- is CapabilityResolution.Available -> resolution.capability- is CapabilityResolution.ConfigurationError -> return unavailable(url, resolution.reason, stalkerToken != null)- is CapabilityResolution.Restricted -> return unavailable(url, resolution.reason, stalkerToken != null)- is CapabilityResolution.Unsupported -> return unavailable(url, resolution.reason, stalkerToken != null)- }- val playback = when (val resolution = capabilitySet.playback()) {- is CapabilityResolution.Available -> resolution.capability- is CapabilityResolution.ConfigurationError -> return unavailable(url, resolution.reason, stalkerToken != null)- is CapabilityResolution.Restricted -> return unavailable(url, resolution.reason, stalkerToken != null)- is CapabilityResolution.Unsupported -> return unavailable(url, resolution.reason, stalkerToken != null)- }- return when (val result = playback.resolve(- PlaybackRequest(- sourceUrl = url,- content = ProviderContentReference(- providerId = providerId,- streamId = streamId- ),- contentType = contentType,- containerExtension = xtreamToken?.containerExtension- ?: stalkerToken?.containerExtension- ?: fallbackContainerExtension,- preferStableUrl = preferStableUrl- )- )) {- is Result.Success -> result.data.let { resolved ->+ if (providerId <= 0L) {+ return url.takeIf(String::isNotBlank)?.let {ResolvedStreamUrl(- url = resolved.url,- expirationTime = resolved.expirationTime ?: extractStreamExpirationTime(resolved.url),- containerExtension = resolved.containerExtension,- headers = resolved.headers,- userAgent = resolved.userAgent,- playbackTransportPolicy = resolved.playbackTransportPolicy,- allowInvalidSsl = resolved.allowInvalidSsl,- proxyHost = resolved.proxyHost,- proxyPort = resolved.proxyPort+ url = it,+ expirationTime = extractStreamExpirationTime(it),+ containerExtension = fallbackContainerExtension)}- is Result.Error -> {- if (stalkerToken != null) {- throw StalkerPlaybackResolutionException(result.message, result.exception)- }- null- }- is Result.Loading -> null}- }- private fun unavailable(url: String, reason: String, stalker: Boolean): ResolvedStreamUrl? {- if (stalker) throw StalkerPlaybackResolutionException(reason)- return url.takeIf { it.isNotBlank() && !isInternalStreamUrl(it) }?.toPassthrough(null)- }-- private fun String.toPassthrough(containerExtension: String?): ResolvedStreamUrl =- ResolvedStreamUrl(- url = this,- expirationTime = extractStreamExpirationTime(this),- containerExtension = containerExtension+ return playbackCoordinator.resolve(+ sourceUrl = url,+ providerId = providerId,+ streamId = streamId,+ contentType = contentType,+ containerExtension = xtreamToken?.containerExtension+ ?: stalkerToken?.containerExtension+ ?: fallbackContainerExtension,+ preferStableUrl = preferStableUrl,+ isStalkerSource = stalkerToken != null)+ }}private fun XtreamStreamKind.toContentType(): ContentType = when (this) {diff --git a/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.ktindex d7e5c44a..79264f3e 100644--- a/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt+++ b/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt@@ -27,7 +27,7 @@ import com.streamvault.data.remote.stalker.StalkerResponseMetricsimport com.streamvault.data.remote.stalker.StalkerTrafficCoordinatorimport com.streamvault.data.remote.xtream.XtreamStreamUrlResolverimport com.streamvault.data.sync.ContentCachePolicy-import com.streamvault.data.sync.SyncManager+import com.streamvault.data.sync.CatalogHydrationCommandsimport com.streamvault.data.util.MoviePresentationSettingsimport com.streamvault.data.util.buildPresentedMoviesimport com.streamvault.data.util.rankSearchResults@@ -97,7 +97,7 @@ class MovieRepositoryImpl @Inject constructor(private val syncMetadataRepository: SyncMetadataRepository,private val xtreamContentIndexDao: XtreamContentIndexDao,private val xtreamIndexJobDao: XtreamIndexJobDao,- private val syncManager: SyncManager,+ private val syncManager: CatalogHydrationCommands,private val transactionRunner: DatabaseTransactionRunner,private val stalkerRequestCoordinator: StalkerRequestCoordinator,private val providerCapabilityResolver: ProviderCapabilityResolver,diff --git a/data/src/main/java/com/streamvault/data/repository/ProviderDeletionCleanupWorker.kt b/data/src/main/java/com/streamvault/data/repository/ProviderDeletionCleanupWorker.ktindex 997f4954..9b618a27 100644--- a/data/src/main/java/com/streamvault/data/repository/ProviderDeletionCleanupWorker.kt+++ b/data/src/main/java/com/streamvault/data/repository/ProviderDeletionCleanupWorker.kt@@ -9,7 +9,7 @@ import androidx.work.WorkerParametersimport com.streamvault.data.local.dao.ProviderDeletionCleanupDaoimport com.streamvault.data.manager.recording.RecordingAlarmSchedulerimport com.streamvault.data.manager.reminder.ProgramReminderAlarmScheduler-import com.streamvault.data.sync.SyncManager+import com.streamvault.data.sync.ProviderSyncLifecycleimport dagger.hilt.EntryPointimport dagger.hilt.InstallInimport dagger.hilt.android.EntryPointAccessors@@ -24,7 +24,7 @@ class ProviderDeletionCleanupWorker(appContext: Context, params: WorkerParameterfun providerDeletionCleanupDao(): ProviderDeletionCleanupDaofun recordingAlarmScheduler(): RecordingAlarmSchedulerfun programReminderAlarmScheduler(): ProgramReminderAlarmScheduler- fun syncManager(): SyncManager+ fun syncLifecycle(): ProviderSyncLifecycle}override suspend fun doWork(): Result {@@ -34,7 +34,7 @@ class ProviderDeletionCleanupWorker(appContext: Context, params: WorkerParameterdao = entry.providerDeletionCleanupDao(),cancelRecordingAlarm = entry.recordingAlarmScheduler()::cancel,cancelReminderAlarm = entry.programReminderAlarmScheduler()::cancel,- cleanupSyncRuntime = entry.syncManager()::onProviderDeleted+ cleanupSyncRuntime = entry.syncLifecycle()::onProviderDeleted)) {ProviderDeletionDrainOutcome.COMPLETE -> Result.success()diff --git a/data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.ktindex 2b73aff0..f28ad145 100644--- a/data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.kt+++ b/data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.kt@@ -42,7 +42,7 @@ import com.streamvault.data.remote.stalker.StalkerApiErrorimport com.streamvault.data.remote.xtream.XtreamProviderimport com.streamvault.data.security.CredentialCryptoimport com.streamvault.data.security.CredentialDecryptionException-import com.streamvault.data.sync.SyncManager+import com.streamvault.data.sync.ProviderSyncCommandsimport com.streamvault.data.sync.ProviderSyncWorkerimport com.streamvault.data.sync.ProviderWorkflowDispositionimport com.streamvault.data.sync.ProviderWorkflowOutcome@@ -104,7 +104,7 @@ class ProviderRepositoryImpl @Inject constructor(private val credentialCrypto: CredentialCrypto,private val providerConfigurationCodec: ProviderConfigurationCodec,private val preferencesRepository: PreferencesRepository,- private val syncManager: SyncManager,+ private val syncManager: ProviderSyncCommands,private val syncMetadataRepository: SyncMetadataRepository,private val transactionRunner: DatabaseTransactionRunner,private val recordingAlarmScheduler: RecordingAlarmScheduler,diff --git a/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.ktindex e1b302d2..532ec50c 100644--- a/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt+++ b/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt@@ -17,7 +17,7 @@ import com.streamvault.data.remote.stalker.StalkerUrlFactoryimport com.streamvault.data.remote.stalker.StalkerVodPlaybackDialectimport com.streamvault.data.remote.xtream.XtreamStreamUrlResolverimport com.streamvault.data.sync.ContentCachePolicy-import com.streamvault.data.sync.SyncManager+import com.streamvault.data.sync.CatalogHydrationCommandsimport com.streamvault.data.util.SeriesPresentationSettingsimport com.streamvault.data.util.buildPresentedSeriesimport com.streamvault.domain.model.*@@ -71,7 +71,7 @@ class SeriesRepositoryImpl @Inject constructor(private val xtreamStreamUrlResolver: XtreamStreamUrlResolver,private val xtreamContentIndexDao: XtreamContentIndexDao,private val xtreamIndexJobDao: XtreamIndexJobDao,- private val syncManager: SyncManager,+ private val syncManager: CatalogHydrationCommands,private val seriesCategoryHydrationDao: SeriesCategoryHydrationDao,private val stalkerRequestCoordinator: StalkerRequestCoordinator,private val providerCapabilityResolver: ProviderCapabilityResolver,diff --git a/data/src/main/java/com/streamvault/data/repository/VodRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/VodRepositoryImpl.ktindex 7effc324..a03ee7e5 100644--- a/data/src/main/java/com/streamvault/data/repository/VodRepositoryImpl.kt+++ b/data/src/main/java/com/streamvault/data/repository/VodRepositoryImpl.kt@@ -7,7 +7,7 @@ import com.streamvault.data.local.dao.VodCatalogEntryDaoimport com.streamvault.data.local.dao.VodCategoryHydrationDaoimport com.streamvault.data.mapper.toDomainimport com.streamvault.data.preferences.PreferencesRepository-import com.streamvault.data.sync.SyncManager+import com.streamvault.data.sync.CatalogHydrationCommandsimport com.streamvault.domain.model.Categoryimport com.streamvault.domain.model.ContentTypeimport com.streamvault.domain.model.Result@@ -41,7 +41,7 @@ class VodRepositoryImpl @Inject constructor(private val vodCatalogEntryDao: VodCatalogEntryDao,private val categoryDao: CategoryDao,private val preferencesRepository: PreferencesRepository,- private val syncManager: SyncManager+ private val syncManager: CatalogHydrationCommands) : VodRepository {private val repositoryScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)diff --git a/data/src/main/java/com/streamvault/data/sync/BackgroundEpgSyncWorker.kt b/data/src/main/java/com/streamvault/data/sync/BackgroundEpgSyncWorker.ktindex e4af904b..de601482 100644--- a/data/src/main/java/com/streamvault/data/sync/BackgroundEpgSyncWorker.kt+++ b/data/src/main/java/com/streamvault/data/sync/BackgroundEpgSyncWorker.kt@@ -28,7 +28,7 @@ class BackgroundEpgSyncWorker(@EntryPoint@InstallIn(SingletonComponent::class)interface BackgroundEpgSyncWorkerEntryPoint {- fun syncManager(): SyncManager+ fun syncCommands(): ProviderSyncCommandsfun providerWorkflowRunner(): ProviderWorkflowRunner}@@ -61,10 +61,10 @@ class BackgroundEpgSyncWorker(reason = ProviderWorkflowReason.PERIODIC,force = force) {- when (val result = entryPoint.syncManager().syncEpg(providerId, force = force)) {+ when (val result = entryPoint.syncCommands().syncEpg(providerId, force = force)) {is com.streamvault.domain.model.Result.Success -> {// A successful EPG sync may still have transient partial failures.- val syncState = entryPoint.syncManager().currentSyncState(providerId)+ val syncState = entryPoint.syncCommands().currentSyncState(providerId)if (syncState is com.streamvault.domain.model.SyncState.Partial &&syncState.hasRetryableEpgFailure) {diff --git a/data/src/main/java/com/streamvault/data/sync/CatalogIndexJobStore.kt b/data/src/main/java/com/streamvault/data/sync/CatalogIndexJobStore.ktnew file mode 100644index 00000000..c20ac92c--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/CatalogIndexJobStore.kt@@ -0,0 +1,97 @@+package com.streamvault.data.sync++import com.streamvault.data.local.dao.ProviderDao+import com.streamvault.data.local.dao.XtreamIndexJobDao+import com.streamvault.data.local.entity.XtreamIndexJobEntity+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.ProviderType++/**+ * Owns durable catalog-index job persistence across the current Xtream and Stalker schemas.+ *+ * The legacy method name is retained at the [SyncManager] facade for source compatibility, but+ * provider-specific row routing and patch/merge semantics belong here rather than in orchestration.+ */+internal class CatalogIndexJobStore(+ private val providerDao: ProviderDao,+ private val xtreamIndexJobDao: XtreamIndexJobDao,+ private val stalkerIndexJobStore: StalkerIndexJobStore+) {+ suspend fun upsert(update: CatalogIndexJobUpdate) {+ val providerType = providerDao.getById(update.providerId)?.type+ val stalkerSection = runCatching { ContentType.valueOf(update.section) }.getOrNull()+ if (+ providerType == ProviderType.STALKER_PORTAL &&+ stalkerSection in setOf(ContentType.MOVIE, ContentType.SERIES)+ ) {+ stalkerIndexJobStore.upsertLegacy(+ providerId = update.providerId,+ section = requireNotNull(stalkerSection),+ state = update.state,+ now = update.now,+ totalCategories = update.totalCategories,+ completedCategories = update.completedCategories,+ nextCategoryIndex = update.nextCategoryIndex,+ failedCategories = update.failedCategories,+ indexedRows = update.indexedRows,+ skippedMalformedRows = update.skippedMalformedRows,+ deletedPrunedRows = update.deletedPrunedRows,+ lastAttemptAt = update.lastAttemptAt,+ lastSuccessAt = update.lastSuccessAt,+ lastError = update.lastError+ )+ return+ }++ val existing = xtreamIndexJobDao.get(update.providerId, update.section)+ xtreamIndexJobDao.upsert(+ (existing ?: XtreamIndexJobEntity(+ providerId = update.providerId,+ section = update.section+ )).copy(+ state = update.state,+ totalCategories = update.totalCategories ?: existing?.totalCategories ?: 0,+ completedCategories = update.completedCategories ?: existing?.completedCategories ?: 0,+ nextCategoryIndex = update.nextCategoryIndex ?: existing?.nextCategoryIndex ?: 0,+ failedCategories = update.failedCategories ?: existing?.failedCategories ?: 0,+ indexedRows = update.indexedRows ?: existing?.indexedRows ?: 0,+ skippedMalformedRows = update.skippedMalformedRows ?: existing?.skippedMalformedRows ?: 0,+ deletedPrunedRows = update.deletedPrunedRows ?: existing?.deletedPrunedRows ?: 0,+ priorityCategoryId = if (update.clearPriority) null+ else update.priorityCategoryId ?: existing?.priorityCategoryId,+ priorityRequestedAt = if (update.clearPriority) 0L+ else update.priorityRequestedAt ?: existing?.priorityRequestedAt ?: 0L,+ lastError = update.lastError,+ lastAttemptAt = update.lastAttemptAt ?: existing?.lastAttemptAt ?: 0L,+ lastSuccessAt = update.lastSuccessAt ?: existing?.lastSuccessAt ?: 0L,+ updatedAt = update.now+ )+ )+ }++ internal fun shouldRunSummary(job: XtreamIndexJobEntity?): Boolean {+ if (job == null) return true+ if (job.state in setOf("QUEUED", "RUNNING", "PARTIAL", "STALE", "FAILED_RETRYABLE")) return true+ return ContentCachePolicy.shouldRefresh(job.lastSuccessAt, ContentCachePolicy.CATALOG_TTL_MILLIS)+ }+}++internal data class CatalogIndexJobUpdate(+ val providerId: Long,+ val section: String,+ val state: String,+ val now: Long,+ val totalCategories: Int? = null,+ val completedCategories: Int? = null,+ val nextCategoryIndex: Int? = null,+ val failedCategories: Int? = null,+ val indexedRows: Int? = null,+ val skippedMalformedRows: Int? = null,+ val deletedPrunedRows: Int? = null,+ val priorityCategoryId: Long? = null,+ val priorityRequestedAt: Long? = null,+ val clearPriority: Boolean = false,+ val lastAttemptAt: Long? = null,+ val lastSuccessAt: Long? = null,+ val lastError: String? = null+)diff --git a/data/src/main/java/com/streamvault/data/sync/CatalogSyncPlans.kt b/data/src/main/java/com/streamvault/data/sync/CatalogSyncPlans.ktnew file mode 100644index 00000000..6a69bf82--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/CatalogSyncPlans.kt@@ -0,0 +1,243 @@+package com.streamvault.data.sync++import com.streamvault.domain.model.ProviderType+import com.streamvault.domain.provider.CapabilityResolution++/** Provider execution port implemented by the sync engine, not by the coordinator. */+internal interface CatalogSyncPlanDelegate {+ suspend fun syncXtreamFull(request: FullProviderSyncRequest): SyncOutcome+ suspend fun syncXtreamLive(request: SectionProviderSyncRequest): SyncOutcome+ suspend fun syncXtreamEpg(request: SectionProviderSyncRequest)+ suspend fun syncXtreamMovies(request: SectionProviderSyncRequest): SyncOutcome+ suspend fun syncXtreamSeries(request: SectionProviderSyncRequest): SyncOutcome+ suspend fun syncXtreamGuide(request: ProviderGuideSyncRequest): ProviderGuideSyncResult++ suspend fun syncM3uFull(request: FullProviderSyncRequest): SyncOutcome+ suspend fun syncM3uLive(request: SectionProviderSyncRequest): SyncOutcome+ suspend fun syncM3uEpg(request: SectionProviderSyncRequest)+ suspend fun syncM3uMovies(request: SectionProviderSyncRequest): SyncOutcome+ suspend fun syncM3uGuide(request: ProviderGuideSyncRequest): ProviderGuideSyncResult++ suspend fun syncStalkerFull(request: FullProviderSyncRequest): SyncOutcome+ suspend fun syncStalkerLive(request: SectionProviderSyncRequest): SyncOutcome+ suspend fun syncStalkerEpg(request: SectionProviderSyncRequest)+ suspend fun syncStalkerMovies(request: SectionProviderSyncRequest): SyncOutcome+ suspend fun syncStalkerSeries(request: SectionProviderSyncRequest): SyncOutcome+ suspend fun syncStalkerGuide(request: ProviderGuideSyncRequest): ProviderGuideSyncResult++ suspend fun syncJellyfinFull(request: FullProviderSyncRequest): SyncOutcome+ suspend fun syncJellyfinMovies(request: SectionProviderSyncRequest): SyncOutcome+ suspend fun syncJellyfinSeries(request: SectionProviderSyncRequest): SyncOutcome+ suspend fun syncJellyfinGuide(request: ProviderGuideSyncRequest): ProviderGuideSyncResult+}++/** Operations supplied by the data layer to the provider-neutral plan objects. */+internal data class XtreamCatalogSyncOperations(+ val full: suspend (FullProviderSyncRequest) -> SyncOutcome,+ val live: suspend (SectionProviderSyncRequest) -> SyncOutcome,+ val epg: suspend (SectionProviderSyncRequest) -> Unit,+ val movies: suspend (SectionProviderSyncRequest) -> SyncOutcome,+ val series: suspend (SectionProviderSyncRequest) -> SyncOutcome,+ val guide: suspend (ProviderGuideSyncRequest) -> ProviderGuideSyncResult+)++internal data class M3uCatalogSyncOperations(+ val full: suspend (FullProviderSyncRequest) -> SyncOutcome,+ val live: suspend (SectionProviderSyncRequest) -> SyncOutcome,+ val epg: suspend (SectionProviderSyncRequest) -> Unit,+ val movies: suspend (SectionProviderSyncRequest) -> SyncOutcome,+ val guide: suspend (ProviderGuideSyncRequest) -> ProviderGuideSyncResult+)++internal data class StalkerCatalogSyncOperations(+ val full: suspend (FullProviderSyncRequest) -> SyncOutcome,+ val live: suspend (SectionProviderSyncRequest) -> SyncOutcome,+ val epg: suspend (SectionProviderSyncRequest) -> Unit,+ val movies: suspend (SectionProviderSyncRequest) -> SyncOutcome,+ val series: suspend (SectionProviderSyncRequest) -> SyncOutcome,+ val guide: suspend (ProviderGuideSyncRequest) -> ProviderGuideSyncResult+)++internal data class JellyfinCatalogSyncOperations(+ val full: suspend (FullProviderSyncRequest) -> SyncOutcome,+ val movies: suspend (SectionProviderSyncRequest) -> SyncOutcome,+ val series: suspend (SectionProviderSyncRequest) -> SyncOutcome,+ val guide: suspend (ProviderGuideSyncRequest) -> ProviderGuideSyncResult+)++internal class XtreamCatalogSyncPlan(+ private val operations: XtreamCatalogSyncOperations+) : CatalogSyncPlan {+ override val providerType: ProviderType = ProviderType.XTREAM_CODES++ override suspend fun syncFull(request: FullProviderSyncRequest): SyncOutcome =+ operations.full(request)++ override suspend fun syncSection(+ request: SectionProviderSyncRequest+ ): CapabilityResolution<SyncOutcome> {+ return CapabilityResolution.Available(+ when (request.section) {+ SyncRepairSection.LIVE -> operations.live(request)+ SyncRepairSection.EPG -> {+ operations.epg(request)+ SyncOutcome()+ }+ SyncRepairSection.MOVIES -> operations.movies(request)+ SyncRepairSection.SERIES -> operations.series(request)+ }+ )+ }++ override suspend fun syncGuide(+ request: ProviderGuideSyncRequest+ ): CapabilityResolution<ProviderGuideSyncResult> =+ CapabilityResolution.Available(operations.guide(request))+}++internal class M3uCatalogSyncPlan(+ private val operations: M3uCatalogSyncOperations+) : CatalogSyncPlan {+ override val providerType: ProviderType = ProviderType.M3U++ override suspend fun syncFull(request: FullProviderSyncRequest): SyncOutcome =+ operations.full(request)++ override suspend fun syncSection(+ request: SectionProviderSyncRequest+ ): CapabilityResolution<SyncOutcome> {+ return when (request.section) {+ SyncRepairSection.LIVE -> CapabilityResolution.Available(operations.live(request))+ SyncRepairSection.MOVIES -> CapabilityResolution.Available(operations.movies(request))+ SyncRepairSection.EPG -> {+ operations.epg(request)+ CapabilityResolution.Available(SyncOutcome())+ }+ SyncRepairSection.SERIES -> CapabilityResolution.Unsupported(+ "Series retry is unavailable for M3U providers"+ )+ }+ }++ override suspend fun syncGuide(+ request: ProviderGuideSyncRequest+ ): CapabilityResolution<ProviderGuideSyncResult> =+ CapabilityResolution.Available(operations.guide(request))+}++internal class StalkerCatalogSyncPlan(+ private val operations: StalkerCatalogSyncOperations+) : CatalogSyncPlan {+ override val providerType: ProviderType = ProviderType.STALKER_PORTAL++ override suspend fun syncFull(request: FullProviderSyncRequest): SyncOutcome =+ operations.full(request)++ override suspend fun syncSection(+ request: SectionProviderSyncRequest+ ): CapabilityResolution<SyncOutcome> {+ return CapabilityResolution.Available(+ when (request.section) {+ SyncRepairSection.LIVE -> operations.live(request)+ SyncRepairSection.EPG -> {+ operations.epg(request)+ SyncOutcome()+ }+ SyncRepairSection.MOVIES -> operations.movies(request)+ SyncRepairSection.SERIES -> operations.series(request)+ }+ )+ }++ override suspend fun syncGuide(+ request: ProviderGuideSyncRequest+ ): CapabilityResolution<ProviderGuideSyncResult> =+ CapabilityResolution.Available(operations.guide(request))+}++internal class JellyfinCatalogSyncPlan(+ private val operations: JellyfinCatalogSyncOperations+) : CatalogSyncPlan {+ override val providerType: ProviderType = ProviderType.JELLYFIN++ override suspend fun syncFull(request: FullProviderSyncRequest): SyncOutcome =+ operations.full(request)++ override suspend fun syncSection(+ request: SectionProviderSyncRequest+ ): CapabilityResolution<SyncOutcome> {+ return when (request.section) {+ SyncRepairSection.MOVIES -> {+ CapabilityResolution.Available(operations.movies(request))+ }+ SyncRepairSection.SERIES -> {+ CapabilityResolution.Available(operations.series(request))+ }+ SyncRepairSection.LIVE -> CapabilityResolution.Unsupported(+ "Live TV retry is unavailable for Jellyfin providers"+ )+ SyncRepairSection.EPG -> CapabilityResolution.Unsupported(+ "Native guide retry is unavailable for Jellyfin providers"+ )+ }+ }++ override suspend fun syncGuide(+ request: ProviderGuideSyncRequest+ ): CapabilityResolution<ProviderGuideSyncResult> =+ CapabilityResolution.Available(operations.guide(request))+}++internal object CatalogSyncPlanFactory {+ fun create(+ xtream: XtreamCatalogSyncOperations,+ m3u: M3uCatalogSyncOperations,+ stalker: StalkerCatalogSyncOperations,+ jellyfin: JellyfinCatalogSyncOperations+ ): CatalogSyncPlanRegistry = CatalogSyncPlanRegistry(+ listOf(+ XtreamCatalogSyncPlan(xtream),+ M3uCatalogSyncPlan(m3u),+ StalkerCatalogSyncPlan(stalker),+ JellyfinCatalogSyncPlan(jellyfin)+ )+ )+}+/** Builds provider plans from execution ports; provider full/live paths bypass the manager delegate. */+internal class CatalogSyncPlanAssembler(+ private val delegate: CatalogSyncPlanDelegate+) {+ fun create(): CatalogSyncPlanRegistry {+ return CatalogSyncPlanFactory.create(+ xtream = XtreamCatalogSyncOperations(+ full = delegate::syncXtreamFull,+ live = delegate::syncXtreamLive,+ epg = delegate::syncXtreamEpg,+ movies = delegate::syncXtreamMovies,+ series = delegate::syncXtreamSeries,+ guide = delegate::syncXtreamGuide+ ),+ m3u = M3uCatalogSyncOperations(+ full = delegate::syncM3uFull,+ live = delegate::syncM3uLive,+ epg = delegate::syncM3uEpg,+ movies = delegate::syncM3uMovies,+ guide = delegate::syncM3uGuide+ ),+ stalker = StalkerCatalogSyncOperations(+ full = delegate::syncStalkerFull,+ live = delegate::syncStalkerLive,+ epg = delegate::syncStalkerEpg,+ movies = delegate::syncStalkerMovies,+ series = delegate::syncStalkerSeries,+ guide = delegate::syncStalkerGuide+ ),+ jellyfin = JellyfinCatalogSyncOperations(+ full = delegate::syncJellyfinFull,+ movies = delegate::syncJellyfinMovies,+ series = delegate::syncJellyfinSeries,+ guide = delegate::syncJellyfinGuide+ )+ )+ }+}diff --git a/data/src/main/java/com/streamvault/data/sync/DatabaseMaintenanceManager.kt b/data/src/main/java/com/streamvault/data/sync/DatabaseMaintenanceManager.ktindex 48f39806..7a73ac6a 100644--- a/data/src/main/java/com/streamvault/data/sync/DatabaseMaintenanceManager.kt+++ b/data/src/main/java/com/streamvault/data/sync/DatabaseMaintenanceManager.kt@@ -26,12 +26,12 @@ class DatabaseMaintenanceManager @Inject constructor(private val favoriteDao: FavoriteDao,private val programReminderDao: ProgramReminderDao,private val searchHistoryDao: SearchHistoryDao,- private val syncManager: SyncManager+ private val providerWorkLocks: ProviderWorkLockRegistry) {suspend fun runDailyMaintenance(now: Long = System.currentTimeMillis()): MaintenanceRunResult {var completedReport: MaintenanceReport? = null- syncManager.runWhenNoSyncActive {+ providerWorkLocks.runWhenNoWorkActive {completedReport = runDailyMaintenanceWhenAdmitted(now)true}diff --git a/data/src/main/java/com/streamvault/data/sync/JellyfinCatalogSyncExecutor.kt b/data/src/main/java/com/streamvault/data/sync/JellyfinCatalogSyncExecutor.ktnew file mode 100644index 00000000..5d08906f--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/JellyfinCatalogSyncExecutor.kt@@ -0,0 +1,310 @@+package com.streamvault.data.sync++import com.streamvault.data.local.dao.CatalogSyncDao+import com.streamvault.data.local.dao.MovieDao+import com.streamvault.data.local.dao.SeriesDao+import com.streamvault.data.local.dao.ProviderWorkflowDao+import com.streamvault.data.local.entity.CategoryEntity+import com.streamvault.data.remote.jellyfin.JellyfinCatalogLimitException+import com.streamvault.data.remote.jellyfin.JellyfinItemLimitException+import com.streamvault.data.remote.jellyfin.JellyfinPaginationException+import com.streamvault.data.remote.jellyfin.JellyfinProvider+import com.streamvault.data.remote.jellyfin.JellyfinResponseTooLargeException+import com.streamvault.data.security.CredentialCrypto+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.LegacyProvider as Provider+import com.streamvault.domain.model.Result+import com.streamvault.domain.model.SyncMetadata+import com.streamvault.domain.repository.SyncMetadataRepository+import kotlinx.coroutines.CancellationException+import kotlinx.coroutines.NonCancellable+import kotlinx.coroutines.flow.first+import kotlinx.coroutines.withContext+import kotlin.coroutines.coroutineContext+import java.io.IOException++/** Owns Jellyfin pagination, checkpoint recovery, staging, and catalog activation. */+internal class JellyfinCatalogSyncExecutor(+ private val jellyfinProvider: JellyfinProvider,+ private val credentialCrypto: CredentialCrypto,+ private val syncCatalogStore: SyncCatalogStore,+ private val catalogSyncDao: CatalogSyncDao,+ private val providerWorkflowDao: ProviderWorkflowDao?,+ private val syncMetadataRepository: SyncMetadataRepository,+ private val movieDao: MovieDao,+ private val seriesDao: SeriesDao,+ private val progress: (Long, ((String) -> Unit)?, String) -> Unit+) {+ suspend fun syncFull(+ provider: Provider,+ force: Boolean,+ onProgress: ((String) -> Unit)?,+ afterCatalogApply: suspend () -> Unit = {}+ ): SyncOutcome {+ val decryptedProvider = provider.copy(password = credentialCrypto.decryptIfNeeded(provider.password))+ val restoredCheckpoint = if (force) null else loadCheckpoint(provider.id)+ val canResume = restoredCheckpoint != null && isCheckpointConsistent(provider.id, restoredCheckpoint)+ var checkpoint = if (canResume) {+ requireNotNull(restoredCheckpoint)+ } else {+ withContext(NonCancellable) { syncCatalogStore.clearProviderStaging(provider.id) }+ JellyfinCatalogCheckpoint(+ movieSessionId = syncCatalogStore.newSessionId(),+ seriesSessionId = syncCatalogStore.newSessionId(),+ phase = JellyfinCatalogPhase.MOVIES+ ).also { saveCheckpoint(provider.id, it) }+ }++ try {+ if (checkpoint.phase == JellyfinCatalogPhase.MOVIES) {+ progress(provider.id, onProgress, "Loading Jellyfin movies...")+ do {+ when (val result = jellyfinProvider.fetchMoviesPage(decryptedProvider, checkpoint.movieStartIndex)) {+ is Result.Error -> throw result.exception ?: IllegalStateException(result.message)+ is Result.Success -> {+ val page = result.data+ syncCatalogStore.stageMovieBatch(provider.id, checkpoint.movieSessionId, page.items)+ checkpoint = checkpoint.afterMoviePage(+ reportedTotal = page.totalRecordCount,+ pageItemCount = page.items.size,+ stagedCount = catalogSyncDao.countMovieStages(provider.id, checkpoint.movieSessionId)+ )+ saveCheckpoint(provider.id, checkpoint)+ }+ is Result.Loading -> throw JellyfinPaginationException("Jellyfin movie page did not complete")+ }+ } while (checkpoint.movieStartIndex < (checkpoint.movieTotal ?: 0))+ checkpoint = checkpoint.copy(phase = JellyfinCatalogPhase.SERIES)+ saveCheckpoint(provider.id, checkpoint)+ }++ if (checkpoint.phase == JellyfinCatalogPhase.SERIES) {+ progress(provider.id, onProgress, "Loading Jellyfin series...")+ do {+ when (val result = jellyfinProvider.fetchSeriesPage(decryptedProvider, checkpoint.seriesStartIndex)) {+ is Result.Error -> throw result.exception ?: IllegalStateException(result.message)+ is Result.Success -> {+ val page = result.data+ syncCatalogStore.stageSeriesBatch(provider.id, checkpoint.seriesSessionId, page.items)+ checkpoint = checkpoint.afterSeriesPage(+ reportedTotal = page.totalRecordCount,+ pageItemCount = page.items.size,+ stagedCount = catalogSyncDao.countSeriesStages(provider.id, checkpoint.seriesSessionId)+ )+ saveCheckpoint(provider.id, checkpoint)+ }+ is Result.Loading -> throw JellyfinPaginationException("Jellyfin series page did not complete")+ }+ } while (checkpoint.seriesStartIndex < (checkpoint.seriesTotal ?: 0))+ checkpoint = checkpoint.copy(phase = JellyfinCatalogPhase.READY)+ saveCheckpoint(provider.id, checkpoint)+ }++ progress(provider.id, onProgress, "Importing Jellyfin library...")+ syncCatalogStore.applyStagedJellyfinCatalog(+ providerId = provider.id,+ movieSessionId = checkpoint.movieSessionId,+ seriesSessionId = checkpoint.seriesSessionId,+ movieCategories = listOf(+ CategoryEntity(+ providerId = provider.id,+ categoryId = 1L,+ name = "Movies",+ type = ContentType.MOVIE+ )+ ),+ seriesCategories = listOf(+ CategoryEntity(+ providerId = provider.id,+ categoryId = 2L,+ name = "Series",+ type = ContentType.SERIES+ )+ ),+ afterCatalogApply = afterCatalogApply+ )+ val activatedMutations = checkpoint.movieStartIndex + checkpoint.seriesStartIndex+ saveCheckpoint(provider.id, null)+ return SyncOutcome(+ stagedMutations = activatedMutations,+ activation = SyncActivation.ACTIVATED_CATALOG+ )+ } catch (cancelled: CancellationException) {+ if (!hasDurableWorkflowContext(provider.id)) {+ withContext(NonCancellable) { syncCatalogStore.clearProviderStaging(provider.id) }+ }+ throw cancelled+ } catch (error: Exception) {+ if (!isResumableFailure(error) || !hasDurableWorkflowContext(provider.id)) {+ withContext(NonCancellable) {+ syncCatalogStore.clearProviderStaging(provider.id)+ saveCheckpoint(provider.id, null)+ }+ }+ throw error+ }+ }++ suspend fun syncMovies(+ provider: Provider,+ onProgress: ((String) -> Unit)?+ ): SyncOutcome {+ progress(provider.id, onProgress, "Retrying Jellyfin movies...")+ val sessionId = syncCatalogStore.newSessionId()+ var startIndex = 0+ var expectedTotal: Int? = null+ try {+ do {+ when (val result = jellyfinProvider.fetchMoviesPage(provider, startIndex)) {+ is Result.Success -> {+ val page = result.data+ expectedTotal = expectedTotal ?: page.totalRecordCount+ if (page.totalRecordCount != expectedTotal) {+ throw JellyfinPaginationException("Jellyfin movie catalog changed during retry")+ }+ syncCatalogStore.stageMovieBatch(provider.id, sessionId, page.items)+ startIndex = page.nextStartIndex+ }+ is Result.Error -> throw result.exception ?: IllegalStateException(result.message)+ is Result.Loading -> throw JellyfinPaginationException("Jellyfin movie retry did not complete")+ }+ } while (startIndex < (expectedTotal ?: 0))+ syncCatalogStore.applyStagedMovieCatalog(+ providerId = provider.id,+ sessionId = sessionId,+ categories = listOf(+ CategoryEntity(+ providerId = provider.id,+ categoryId = 1L,+ name = "Movies",+ type = ContentType.MOVIE+ )+ )+ )+ val now = System.currentTimeMillis()+ val metadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)+ syncMetadataRepository.updateMetadata(+ metadata.copy(+ lastMovieSync = now,+ lastMovieAttempt = now,+ lastMovieSuccess = now,+ movieCount = movieDao.getCount(provider.id).first(),+ movieCatalogStale = false+ )+ )+ return SyncOutcome(+ stagedMutations = startIndex,+ activation = SyncActivation.ACTIVATED_CATALOG+ )+ } catch (cancelled: CancellationException) {+ withContext(NonCancellable) { syncCatalogStore.discardStagedImport(provider.id, sessionId) }+ throw cancelled+ } catch (error: Exception) {+ withContext(NonCancellable) { syncCatalogStore.discardStagedImport(provider.id, sessionId) }+ throw error+ }+ }++ suspend fun syncSeries(+ provider: Provider,+ onProgress: ((String) -> Unit)?+ ): SyncOutcome {+ progress(provider.id, onProgress, "Retrying Jellyfin series...")+ val sessionId = syncCatalogStore.newSessionId()+ var startIndex = 0+ var expectedTotal: Int? = null+ try {+ do {+ when (val result = jellyfinProvider.fetchSeriesPage(provider, startIndex)) {+ is Result.Success -> {+ val page = result.data+ expectedTotal = expectedTotal ?: page.totalRecordCount+ if (page.totalRecordCount != expectedTotal) {+ throw JellyfinPaginationException("Jellyfin series catalog changed during retry")+ }+ syncCatalogStore.stageSeriesBatch(provider.id, sessionId, page.items)+ startIndex = page.nextStartIndex+ }+ is Result.Error -> throw result.exception ?: IllegalStateException(result.message)+ is Result.Loading -> throw JellyfinPaginationException("Jellyfin series retry did not complete")+ }+ } while (startIndex < (expectedTotal ?: 0))+ syncCatalogStore.applyStagedSeriesCatalog(+ providerId = provider.id,+ sessionId = sessionId,+ categories = listOf(+ CategoryEntity(+ providerId = provider.id,+ categoryId = 2L,+ name = "Series",+ type = ContentType.SERIES+ )+ )+ )+ val now = System.currentTimeMillis()+ val metadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)+ syncMetadataRepository.updateMetadata(+ metadata.copy(+ lastSeriesSync = now,+ seriesCount = seriesDao.getCount(provider.id).first()+ )+ )+ return SyncOutcome(+ stagedMutations = startIndex,+ activation = SyncActivation.ACTIVATED_CATALOG+ )+ } catch (cancelled: CancellationException) {+ withContext(NonCancellable) { syncCatalogStore.discardStagedImport(provider.id, sessionId) }+ throw cancelled+ } catch (error: Exception) {+ withContext(NonCancellable) { syncCatalogStore.discardStagedImport(provider.id, sessionId) }+ throw error+ }+ }++ private suspend fun loadCheckpoint(providerId: Long): JellyfinCatalogCheckpoint? {+ val lease = coroutineContext[ProviderWorkflowExecutionContext]?.lease ?: return null+ if (lease.providerId != providerId) return null+ return JellyfinCatalogCheckpoint.decode(+ providerWorkflowDao?.getCheckpoint(providerId, lease.generation, lease.phase)+ )+ }++ private suspend fun saveCheckpoint(providerId: Long, checkpoint: JellyfinCatalogCheckpoint?) {+ val lease = coroutineContext[ProviderWorkflowExecutionContext]?.lease ?: return+ if (lease.providerId != providerId) {+ throw ProviderWorkflowSupersededException(providerId, lease.generation)+ }+ val workflowDao = providerWorkflowDao ?: return+ if (workflowDao.updateRunningCheckpoint(+ providerId = providerId,+ generation = lease.generation,+ phase = lease.phase,+ token = lease.token,+ checkpoint = checkpoint?.encode(),+ now = System.currentTimeMillis()+ ) != 1+ ) {+ throw ProviderWorkflowSupersededException(providerId, lease.generation)+ }+ }++ private suspend fun isCheckpointConsistent(+ providerId: Long,+ checkpoint: JellyfinCatalogCheckpoint+ ): Boolean = checkpoint.isConsistent(+ catalogSyncDao.countMovieStages(providerId, checkpoint.movieSessionId),+ catalogSyncDao.countSeriesStages(providerId, checkpoint.seriesSessionId)+ )++ private suspend fun hasDurableWorkflowContext(providerId: Long): Boolean =+ coroutineContext[ProviderWorkflowExecutionContext]?.lease?.providerId == providerId &&+ providerWorkflowDao != null++ private fun isResumableFailure(error: Exception): Boolean =+ error is IOException &&+ error !is JellyfinPaginationException &&+ error !is JellyfinCatalogLimitException &&+ error !is JellyfinResponseTooLargeException &&+ error !is JellyfinItemLimitException+}diff --git a/data/src/main/java/com/streamvault/data/sync/M3uCatalogSyncExecutor.kt b/data/src/main/java/com/streamvault/data/sync/M3uCatalogSyncExecutor.ktnew file mode 100644index 00000000..b1f526f5--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/M3uCatalogSyncExecutor.kt@@ -0,0 +1,217 @@+package com.streamvault.data.sync++import com.streamvault.domain.model.LegacyProvider as Provider+import com.streamvault.domain.model.ProviderEpgSyncMode+import com.streamvault.domain.model.Result+import com.streamvault.domain.model.SyncMetadata+import com.streamvault.domain.model.VodSyncMode+import com.streamvault.domain.repository.EpgSourceRepository+import com.streamvault.domain.repository.SyncMetadataRepository+import kotlinx.coroutines.CancellationException+import kotlinx.coroutines.Dispatchers+import kotlinx.coroutines.flow.first+import kotlinx.coroutines.withContext++/**+ * Owns the playlist provider's catalog import policy.+ *+ * The manager still supplies shared guide/job callbacks, but playlist admission,+ * metadata updates, and playlist-provided EPG source assignment live here.+ */+internal class M3uCatalogSyncExecutor(+ private val importer: SyncManagerM3uImporter,+ private val syncMetadataRepository: SyncMetadataRepository,+ private val epgSourceRepository: EpgSourceRepository,+ private val countPrograms: suspend (Long) -> Int,+ private val shouldSyncEpgUpfront: (Provider) -> Boolean,+ private val updateEpgJobState: suspend (+ Provider,+ String,+ Long,+ Int?,+ Long?,+ Long?,+ String?+ ) -> Unit,+ private val refreshGuide: suspend (+ Provider,+ SyncMetadata,+ Long,+ Boolean,+ ((String) -> Unit)?+ ) -> ProviderGuideSyncResult,+ private val markBackgroundEpgQueued: suspend (Long, Long) -> Unit,+ private val progress: (Long, ((String) -> Unit)?, String) -> Unit,+ private val sanitizeThrowableMessage: (Throwable) -> String+) {+ suspend fun syncFull(+ provider: Provider,+ force: Boolean,+ onProgress: ((String) -> Unit)?,+ afterCatalogApply: suspend () -> Unit = {}+ ): SyncOutcome {+ val warnings = mutableListOf<String>()+ val continuationWork = mutableListOf<SyncContinuation>()+ var stagedMutations = 0+ var metadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)+ val now = System.currentTimeMillis()++ if (force || ContentCachePolicy.shouldRefresh(metadata.lastLiveSuccess, ContentCachePolicy.CATALOG_TTL_MILLIS, now)) {+ val stats = withContext(Dispatchers.IO) {+ importer.importPlaylist(provider, onProgress, afterCatalogApply = afterCatalogApply)+ }+ if (stats.liveCount == 0 && stats.movieCount == 0) {+ throw IllegalStateException("Playlist is empty or contains no supported entries")+ }+ stagedMutations = stats.liveCount + stats.movieCount+ warnings += stats.warnings+ if (provider.epgUrl.isBlank()) {+ assignPlaylistEpgSources(provider, stats, warnings)+ }+ metadata = metadata.copy(+ lastLiveSync = now,+ lastLiveSuccess = now,+ lastMovieSync = now,+ lastSeriesSync = now,+ lastSeriesSuccess = now,+ lastMovieAttempt = now,+ lastMovieSuccess = now,+ liveCount = stats.liveCount,+ movieCount = stats.movieCount,+ movieSyncMode = VodSyncMode.FULL,+ movieWarningsCount = stats.warnings.size,+ movieCatalogStale = false,+ movieHealthySyncStreak = 0+ )+ syncMetadataRepository.updateMetadata(metadata)+ }++ if (shouldSyncEpgUpfront(provider)) {+ updateEpgJobState(provider, "RUNNING", now, null, now, null, null)+ val epgResult = refreshGuide(provider, metadata, now, force, onProgress)+ val finishedAt = System.currentTimeMillis()+ updateEpgJobState(+ provider,+ when {+ epgResult.warnings.isEmpty() -> "SUCCESS"+ epgResult.hasRetryableFailure -> "FAILED_RETRYABLE"+ else -> "PARTIAL"+ },+ finishedAt,+ countPrograms(provider.id),+ now,+ finishedAt.takeIf { epgResult.warnings.isEmpty() },+ epgResult.warnings.takeIf { it.isNotEmpty() }?.joinToString("; ")+ )+ warnings += epgResult.warnings+ } else if (provider.epgSyncMode != ProviderEpgSyncMode.SKIP) {+ markBackgroundEpgQueued(provider.id, now)+ continuationWork += SyncContinuation(+ operation = SyncContinuationOperation.REFRESH_GUIDE,+ reason = "playlist guide refresh was handed off to background work",+ force = force+ )+ }++ return SyncOutcome(+ partial = warnings.isNotEmpty(),+ warnings = warnings.distinct(),+ stagedMutations = stagedMutations,+ continuationWork = continuationWork,+ activation = if (stagedMutations > 0) {+ SyncActivation.ACTIVATED_CATALOG+ } else {+ SyncActivation.NO_CATALOG_CHANGE+ }+ )+ }++ suspend fun syncLive(+ provider: Provider,+ onProgress: ((String) -> Unit)?+ ): SyncOutcome {+ val now = System.currentTimeMillis()+ progress(provider.id, onProgress, "Retrying Live TV...")+ val stats = withContext(Dispatchers.IO) {+ importer.importPlaylist(provider, onProgress, includeLive = true, includeMovies = false)+ }+ if (stats.liveCount == 0) {+ throw IllegalStateException("Playlist contains no live TV entries")+ }+ val metadata = (syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id))+ .copy(lastLiveSync = now, lastLiveSuccess = now, liveCount = stats.liveCount)+ syncMetadataRepository.updateMetadata(metadata)+ return SyncOutcome(+ partial = stats.warnings.isNotEmpty(),+ warnings = stats.warnings.distinct(),+ stagedMutations = stats.liveCount,+ activation = SyncActivation.ACTIVATED_CATALOG+ )+ }++ suspend fun syncMovies(+ provider: Provider,+ onProgress: ((String) -> Unit)?+ ): SyncOutcome {+ val now = System.currentTimeMillis()+ progress(provider.id, onProgress, "Retrying Movies...")+ val stats = withContext(Dispatchers.IO) {+ importer.importPlaylist(provider, onProgress, includeLive = false, includeMovies = true)+ }+ if (stats.movieCount == 0) {+ throw IllegalStateException("Playlist contains no movie entries")+ }+ val metadata = (syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id))+ .copy(+ lastMovieSync = now,+ lastMovieAttempt = now,+ lastMovieSuccess = now,+ movieCount = stats.movieCount,+ movieSyncMode = VodSyncMode.FULL,+ movieWarningsCount = stats.warnings.size,+ movieCatalogStale = false+ )+ syncMetadataRepository.updateMetadata(metadata)+ return SyncOutcome(+ partial = stats.warnings.isNotEmpty(),+ warnings = stats.warnings.distinct(),+ stagedMutations = stats.movieCount,+ activation = SyncActivation.ACTIVATED_CATALOG+ )+ }++ private suspend fun assignPlaylistEpgSources(+ provider: Provider,+ stats: M3uImportStats,+ warnings: MutableList<String>+ ) {+ val existingSourcesByUrl = epgSourceRepository.getAllSources().first().associateBy { it.url }+ val assignedSourceIds = epgSourceRepository.getAssignmentsForProvider(provider.id)+ .first()+ .mapTo(mutableSetOf()) { it.epgSourceId }+ stats.header.tvgUrls.forEachIndexed { priority, url ->+ try {+ val source = existingSourcesByUrl[url] ?: when (+ val addResult = epgSourceRepository.addSource("Playlist EPG ${priority + 1}", url)+ ) {+ is Result.Success -> addResult.data+ is Result.Error -> {+ warnings += "Could not add playlist EPG source ${priority + 1}: ${addResult.message}"+ null+ }+ Result.Loading -> null+ }+ if (source != null && assignedSourceIds.add(source.id)) {+ when (val assignment = epgSourceRepository.assignSourceToProvider(provider.id, source.id, priority)) {+ is Result.Error -> warnings += "Could not assign playlist EPG source ${priority + 1}: ${assignment.message}"+ else -> Unit+ }+ }+ } catch (e: CancellationException) {+ throw e+ } catch (e: Exception) {+ warnings += "Could not configure playlist EPG source ${priority + 1}: ${sanitizeThrowableMessage(e)}"+ }+ }+ }+}diff --git a/data/src/main/java/com/streamvault/data/sync/ProviderContinuationScheduler.kt b/data/src/main/java/com/streamvault/data/sync/ProviderContinuationScheduler.ktnew file mode 100644index 00000000..63244b89--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/ProviderContinuationScheduler.kt@@ -0,0 +1,39 @@+package com.streamvault.data.sync++import com.streamvault.domain.model.ProviderSnapshot+import com.streamvault.domain.model.ProviderType++/** Maps provider-neutral continuation receipts onto the durable WorkManager scheduler. */+internal class ProviderContinuationScheduler(+ private val workScheduler: ProviderSyncWorkScheduler+) : SyncContinuationScheduler {+ override suspend fun schedule(snapshot: ProviderSnapshot, work: List<SyncContinuation>) {+ val providerId = snapshot.provider.id+ if (work.any { it.operation == SyncContinuationOperation.REFRESH_GUIDE }) {+ workScheduler.scheduleBackgroundEpg(providerId)+ }++ val indexWork = work.filter { it.operation == SyncContinuationOperation.INDEX_CATALOG }+ when (snapshot.provider.type) {+ ProviderType.XTREAM_CODES -> indexWork+ .distinctBy { it.section }+ .forEach { continuation ->+ workScheduler.scheduleXtreamIndex(+ providerId = providerId,+ section = continuation.section,+ force = continuation.force+ )+ }+ ProviderType.STALKER_PORTAL -> if (indexWork.isNotEmpty()) {+ workScheduler.scheduleStalkerIndex(+ providerId = providerId,+ force = indexWork.any { it.force }+ )+ }+ ProviderType.M3U,+ ProviderType.JELLYFIN -> check(indexWork.isEmpty()) {+ "${snapshot.provider.type} declared unsupported catalog index continuation work"+ }+ }+ }+}diff --git a/data/src/main/java/com/streamvault/data/sync/ProviderEpgSyncExecutor.kt b/data/src/main/java/com/streamvault/data/sync/ProviderEpgSyncExecutor.ktnew file mode 100644index 00000000..0facaf75--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/ProviderEpgSyncExecutor.kt@@ -0,0 +1,621 @@+package com.streamvault.data.sync++import android.util.Log+import com.streamvault.data.local.DatabaseTransactionRunner+import com.streamvault.data.local.dao.ChannelDao+import com.streamvault.data.local.dao.ProgramDao+import com.streamvault.data.local.entity.ChannelGuideSyncEntity+import com.streamvault.data.mapper.toEntity+import com.streamvault.data.preferences.PreferencesRepository+import com.streamvault.data.remote.stalker.StalkerApiError+import com.streamvault.data.remote.stalker.StalkerPortalStateStore+import com.streamvault.data.remote.stalker.StalkerProvider+import com.streamvault.data.remote.stalker.StalkerRequestCoordinator+import com.streamvault.data.remote.stalker.StalkerRequestDescriptor+import com.streamvault.data.remote.stalker.StalkerTelemetry+import com.streamvault.data.remote.xtream.XtreamUrlFactory+import com.streamvault.data.util.UrlSecurityPolicy+import com.streamvault.data.util.runSuspendCatching+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.GuideSourcePolicy+import com.streamvault.domain.model.LegacyProvider as Provider+import com.streamvault.domain.model.Result+import com.streamvault.domain.model.SyncMetadata+import com.streamvault.domain.model.StalkerRequestPriority+import com.streamvault.domain.repository.EpgRepository+import com.streamvault.domain.repository.EpgSourceRepository+import com.streamvault.domain.repository.SyncMetadataRepository+import kotlinx.coroutines.CancellationException+import kotlinx.coroutines.flow.first++/** Owns provider-neutral guide policy and the provider-specific XMLTV/native guide handoffs. */+internal class ProviderEpgSyncExecutor(+ private val preferencesRepository: PreferencesRepository,+ private val epgRepository: EpgRepository,+ private val epgSourceRepository: EpgSourceRepository,+ private val channelDao: ChannelDao,+ private val programDao: ProgramDao,+ private val transactionRunner: DatabaseTransactionRunner,+ private val syncMetadataRepository: SyncMetadataRepository,+ private val stalkerPortalStateStore: StalkerPortalStateStore,+ private val stalkerRequestCoordinator: StalkerRequestCoordinator,+ private val createStalkerProvider: (Provider) -> StalkerProvider,+ private val xtreamSupport: SyncManagerXtreamSupport,+ private val progress: (Long, ((String) -> Unit)?, String) -> Unit,+ private val sanitizeThrowableMessage: (Throwable?) -> String+) {+ suspend fun syncXtreamProviderEpg(+ provider: Provider,+ metadata: SyncMetadata,+ now: Long,+ force: Boolean,+ onProgress: ((String) -> Unit)?+ ): ProviderGuideSyncResult = syncProviderEpg(provider, metadata, now, force, onProgress) { warnings ->+ var retryable = false+ if (shouldUseProviderGuide(provider.guideSourcePolicy) &&+ (force || ContentCachePolicy.shouldRefresh(metadata.lastEpgSuccess, ContentCachePolicy.EPG_TTL_MILLIS, now))+ ) {+ try {+ progress(provider.id, onProgress, "Downloading EPG...")+ val xmltvUrl = provider.epgUrl.ifBlank {+ XtreamUrlFactory.buildXmltvUrl(+ provider.serverUrl.trimEnd('/'),+ provider.username,+ provider.password+ )+ }+ UrlSecurityPolicy.validateXtreamEpgUrl(xmltvUrl)?.let { throw IllegalStateException(it) }+ xtreamSupport.retryTransient {+ requireResult(epgRepository.refreshEpg(provider.id, xmltvUrl), "Failed to refresh EPG")+ }+ val epgCount = programDao.countByProvider(provider.id)+ syncMetadataRepository.updateMetadata(+ metadata.copy(lastEpgSync = now, lastEpgSuccess = now, epgCount = epgCount)+ )+ if (epgCount == 0) warnings += "EPG imported zero programs; live guide may require provider fallback."+ } catch (e: CancellationException) {+ throw e+ } catch (e: Exception) {+ Log.e(TAG, "EPG sync failed (non-fatal): ${sanitizeThrowableMessage(e)}")+ retryable = isRetryableEpgException(e)+ warnings += "EPG XMLTV sync failed."+ }+ }+ retryable+ }++ suspend fun syncM3uProviderEpg(+ provider: Provider,+ metadata: SyncMetadata,+ now: Long,+ force: Boolean,+ onProgress: ((String) -> Unit)?+ ): ProviderGuideSyncResult = syncProviderEpg(provider, metadata, now, force, onProgress) { warnings ->+ var retryable = false+ val epgUrl = provider.epgUrl+ if (shouldUseProviderGuide(provider.guideSourcePolicy) && epgUrl.isNotBlank() &&+ (force || ContentCachePolicy.shouldRefresh(metadata.lastEpgSuccess, ContentCachePolicy.EPG_TTL_MILLIS, now))+ ) {+ val validationError = UrlSecurityPolicy.validateOptionalEpgUrl(epgUrl)+ if (validationError != null) {+ warnings += validationError+ } else {+ try {+ progress(provider.id, onProgress, "Downloading EPG...")+ xtreamSupport.retryTransient {+ requireResult(epgRepository.refreshEpg(provider.id, epgUrl), "Failed to refresh EPG")+ }+ syncMetadataRepository.updateMetadata(+ metadata.copy(+ lastEpgSync = now,+ lastEpgSuccess = now,+ epgCount = programDao.countByProvider(provider.id)+ )+ )+ } catch (e: CancellationException) {+ throw e+ } catch (e: Exception) {+ Log.e(TAG, "EPG sync failed (non-fatal): ${sanitizeThrowableMessage(e)}")+ retryable = isRetryableEpgException(e)+ warnings += "EPG sync failed"+ }+ }+ }+ retryable+ }++ suspend fun syncStalkerProviderEpg(+ provider: Provider,+ metadata: SyncMetadata,+ now: Long,+ force: Boolean,+ onProgress: ((String) -> Unit)?+ ): ProviderGuideSyncResult = syncProviderEpg(provider, metadata, now, force, onProgress) { warnings ->+ var retryable = false+ if (shouldUseProviderGuide(provider.guideSourcePolicy) &&+ (force || ContentCachePolicy.shouldRefresh(metadata.lastEpgSuccess, ContentCachePolicy.EPG_TTL_MILLIS, now))+ ) {+ val learnedEpgSupport = stalkerPortalStateStore.getValidated(provider.id)?.epgSupported+ if (learnedEpgSupport == false && provider.epgUrl.isBlank()) {+ StalkerTelemetry.strategySelected(provider.id, "EPG_SKIP", "EPG_KNOWN_UNSUPPORTED")+ warnings += "Stalker portal guide is known to be unsupported; keeping cached guide data."+ } else {+ val stalkerWarnings = syncStalkerPreferredEpg(provider, now, onProgress)+ retryable = stalkerWarnings.isNotEmpty()+ warnings += stalkerWarnings+ }+ }+ retryable+ }++ private suspend fun syncStalkerPreferredEpg(+ provider: Provider,+ now: Long,+ onProgress: ((String) -> Unit)?+ ): List<String> {+ val warnings = mutableListOf<String>()+ val currentEpgUrl = provider.epgUrl+ var shouldUseNativeGuide = currentEpgUrl.isBlank()++ if (currentEpgUrl.isNotBlank()) {+ val epgValidationError = UrlSecurityPolicy.validateOptionalEpgUrl(currentEpgUrl)+ if (epgValidationError != null) {+ Log.w(TAG, "Portal XMLTV URL invalid for provider ${provider.id}: $epgValidationError")+ warnings.add("Portal XMLTV URL is invalid; using the Stalker portal guide instead.")+ shouldUseNativeGuide = true+ } else {+ try {+ progress(provider.id, onProgress, "Downloading EPG...")+ xtreamSupport.retryTransient {+ requireResult(epgRepository.refreshEpg(provider.id, currentEpgUrl), "Failed to refresh EPG")+ }+ val epgCount = programDao.countByProvider(provider.id)+ if (epgCount > 0) {+ syncMetadataRepository.updateMetadata(+ (syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)).copy(+ lastEpgSync = now,+ lastEpgSuccess = now,+ epgCount = epgCount+ )+ )+ } else {+ warnings.add("Portal XMLTV imported zero programs; using the Stalker portal guide instead.")+ shouldUseNativeGuide = true+ }+ } catch (e: CancellationException) {+ throw e+ } catch (e: Exception) {+ Log.e(TAG, "Portal XMLTV sync failed for provider ${provider.id}: ${sanitizeThrowableMessage(e)}")+ warnings.add("Portal XMLTV sync failed; using the Stalker portal guide instead.")+ shouldUseNativeGuide = true+ }+ }+ }++ if (shouldUseNativeGuide) {+ warnings += syncStalkerPortalEpg(+ provider = provider,+ now = now,+ onProgress = onProgress+ )+ }++ return warnings+ }++ private suspend fun syncStalkerPortalEpg(+ provider: Provider,+ now: Long,+ onProgress: ((String) -> Unit)?+ ): List<String> {+ val channels = channelDao.getGuideSyncEntriesByProvider(provider.id)+ if (channels.isEmpty()) return emptyList()++ val guideRequests = channels+ .mapNotNull(::toStalkerGuideRequest)+ .distinctBy(StalkerGuideRequest::channelKey)+ if (guideRequests.isEmpty()) {+ return listOf("Stalker portal guide sync skipped because no valid guide channel IDs were available.")+ }++ val previousProgramCount = programDao.countByProvider(provider.id)+ val api = createStalkerProvider(provider)+ val aliasToChannelKey = buildMap {+ guideRequests.forEach { request ->+ request.aliases.forEach { alias -> putIfAbsent(alias, request.channelKey) }+ }+ }+ val failedChannels = mutableListOf<String>()+ val insertBuffer = ArrayList<com.streamvault.data.local.entity.ProgramEntity>(STALKER_GUIDE_PROGRAM_BATCH_SIZE)+ val replacedChannelKeys = linkedSetOf<String>()+ val bulkCoveredChannelKeys = linkedSetOf<String>()+ var importedProgramCount = 0+ var providerRateLimited = false++ suspend fun flushPrograms() {+ if (insertBuffer.isEmpty()) return+ val chunk = insertBuffer.toList()+ insertBuffer.clear()+ transactionRunner.inTransaction {+ chunk+ .map { it.channelId }+ .distinct()+ .forEach { channelId ->+ if (replacedChannelKeys.add(channelId)) {+ programDao.deleteForChannel(provider.id, channelId)+ }+ }+ programDao.insertAll(chunk)+ importedProgramCount += chunk.size+ }+ }++ runSuspendCatching {+ stalkerRequestCoordinator.execute(+ providerId = provider.id,+ priority = StalkerRequestPriority.EPG,+ descriptor = StalkerRequestDescriptor(+ contentType = "EPG",+ action = "BULK_GUIDE"+ )+ ) {+ api.streamBulkEpg(periodHours = 6) { program ->+ val resolvedChannelKey = aliasToChannelKey[program.channelId] ?: return@streamBulkEpg+ if (program.endTime <= program.startTime) return@streamBulkEpg+ bulkCoveredChannelKeys += resolvedChannelKey+ insertBuffer += program.copy(+ providerId = provider.id,+ channelId = resolvedChannelKey+ ).toEntity()+ if (insertBuffer.size >= STALKER_GUIDE_PROGRAM_BATCH_SIZE) flushPrograms()+ }+ }.let { result ->+ if (result is Result.Error) {+ throw result.exception ?: IllegalStateException(result.message)+ }+ }+ }.onFailure { error ->+ providerRateLimited = error.hasStalkerRateLimit()+ Log.d(TAG, "Bulk Stalker portal EPG fetch unavailable for provider ${provider.id}", error)+ }++ val uncoveredGuideRequests = guideRequests.filterNot { it.channelKey in bulkCoveredChannelKeys }+ val perChannelGuideWindowed = uncoveredGuideRequests.size > STALKER_PER_CHANNEL_EPG_REQUESTS_PER_RUN+ val fallbackGuideRequests = if (providerRateLimited) {+ emptyList()+ } else if (perChannelGuideWindowed) {+ val windowCount = (uncoveredGuideRequests.size + STALKER_PER_CHANNEL_EPG_REQUESTS_PER_RUN - 1) /+ STALKER_PER_CHANNEL_EPG_REQUESTS_PER_RUN+ val windowIndex = ((now / MILLIS_PER_DAY) % windowCount).toInt()+ uncoveredGuideRequests+ .drop(windowIndex * STALKER_PER_CHANNEL_EPG_REQUESTS_PER_RUN)+ .take(STALKER_PER_CHANNEL_EPG_REQUESTS_PER_RUN)+ } else {+ uncoveredGuideRequests+ }++ var ignorePerChannelGuide = false+ fallbackGuideRequests.forEachIndexed { index, request ->+ if (ignorePerChannelGuide) return@forEachIndexed+ progress(provider.id, onProgress, "Downloading portal EPG... ${index + 1} of ${fallbackGuideRequests.size}")+ runSuspendCatching {+ var perChannelRecordCount = 0+ val foreignChannelIds = HashSet<String>()+ val streamResult = stalkerRequestCoordinator.execute(+ providerId = provider.id,+ priority = StalkerRequestPriority.EPG,+ descriptor = StalkerRequestDescriptor(+ contentType = "EPG",+ action = "CHANNEL_GUIDE",+ itemKey = request.channelKey+ )+ ) {+ api.streamEpg(request.channelKey) { program ->+ if (program.endTime <= program.startTime) return@streamEpg+ if (program.channelId != request.channelKey) foreignChannelIds += program.channelId+ insertBuffer += program.copy(+ providerId = provider.id,+ channelId = request.channelKey+ ).toEntity()+ perChannelRecordCount+++ if (perChannelRecordCount >= STALKER_PER_CHANNEL_RECORD_SANITY_CAP || foreignChannelIds.size > 1) {+ throw StalkerBrokenPerChannelEpgException(request.channelName)+ }+ if (insertBuffer.size >= STALKER_GUIDE_PROGRAM_BATCH_SIZE) flushPrograms()+ }+ }+ if (streamResult is Result.Error) {+ throw streamResult.exception ?: IllegalStateException(streamResult.message)+ }+ }.onFailure { error ->+ if (error.hasStalkerRateLimit()) {+ providerRateLimited = true+ ignorePerChannelGuide = true+ Log.w(+ TAG,+ "Stalker provider ${provider.id} entered rate-limit cooldown; cancelling remaining per-channel EPG requests."+ )+ } else if (error is StalkerBrokenPerChannelEpgException) {+ ignorePerChannelGuide = true+ Log.w(+ TAG,+ "Stalker portal returned bulk-shaped payload for per-channel EPG request " ++ "(${request.channelKey}); skipping remaining per-channel guide calls."+ )+ } else {+ failedChannels += request.channelName+ Log.w(+ TAG,+ "Stalker portal EPG fetch failed for provider ${provider.id} channel ${request.channelKey}",+ error+ )+ }+ }+ }++ flushPrograms()++ if (replacedChannelKeys.isEmpty() && failedChannels.isNotEmpty()) {+ api.recordEpgCapability(supported = false)+ return listOf(+ "Stalker portal guide sync failed for all ${failedChannels.size} channels; keeping existing guide data."+ )+ }++ val epgCount = programDao.countByProvider(provider.id)+ if (replacedChannelKeys.isNotEmpty() || bulkCoveredChannelKeys.isNotEmpty()) {+ api.recordEpgCapability(supported = true)+ }+ val guideLooksHealthy = epgCount >= STALKER_MIN_HEALTHY_EPG_PROGRAMS || previousProgramCount == 0+ val existingMetadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)+ syncMetadataRepository.updateMetadata(+ existingMetadata.copy(+ lastEpgSync = now,+ lastEpgSuccess = if (guideLooksHealthy) now else existingMetadata.lastEpgSuccess,+ epgCount = epgCount+ )+ )++ val warnings = mutableListOf<String>()+ if (providerRateLimited) {+ warnings.add("Stalker portal rate limit reached; remaining guide requests were cancelled.")+ }+ if (perChannelGuideWindowed) {+ warnings.add(+ "Portal EPG fallback was limited to $STALKER_PER_CHANNEL_EPG_REQUESTS_PER_RUN channels this run; " ++ "later background runs rotate through the remaining channels."+ )+ }+ if (epgCount == 0) warnings.add("Stalker portal guide import returned zero programs.")+ if (failedChannels.isNotEmpty()) {+ warnings.add(+ "Stalker portal guide imported $epgCount programs, but ${failedChannels.size} channels failed (${summarizeChannelNames(failedChannels)})."+ )+ }+ if (!guideLooksHealthy && previousProgramCount >= STALKER_MIN_HEALTHY_EPG_PROGRAMS) {+ warnings.add(+ "Stalker portal guide import looked incomplete ($importedProgramCount programs across ${replacedChannelKeys.size} channels); preserved untouched prior guide data for the rest."+ )+ }+ return warnings+ }++ private data class StalkerGuideRequest(+ val channelKey: String,+ val channelName: String,+ val aliases: Set<String>+ )++ private fun toStalkerGuideRequest(channel: ChannelGuideSyncEntity): StalkerGuideRequest? {+ val normalizedEpgKey = channel.epgChannelId+ ?.trim()+ ?.takeUnless(::isLikelyPlaceholderStalkerGuideKey)+ val streamKey = channel.streamId.takeIf { it > 0L }?.toString()+ val channelKey = normalizedEpgKey ?: streamKey ?: return null+ val aliases = linkedSetOf<String>().apply {+ normalizedEpgKey?.let(::add)+ streamKey?.let(::add)+ }+ return StalkerGuideRequest(+ channelKey = channelKey,+ channelName = channel.name.ifBlank { channelKey },+ aliases = aliases+ )+ }++ private fun isLikelyPlaceholderStalkerGuideKey(value: String): Boolean =+ when (value.trim().lowercase()) {+ "no details available", "n/a", "null", "none", "unknown" -> true+ else -> false+ }++ private fun summarizeChannelNames(channelNames: List<String>): String {+ val distinctNames = channelNames.distinct()+ if (distinctNames.isEmpty()) return "unknown channels"+ val preview = distinctNames.take(3).joinToString()+ val remaining = distinctNames.size - 3+ return if (remaining > 0) "$preview, and $remaining more" else preview+ }++ suspend fun syncJellyfinProviderEpg(+ provider: Provider,+ metadata: SyncMetadata,+ now: Long,+ force: Boolean,+ onProgress: ((String) -> Unit)?+ ): ProviderGuideSyncResult = syncProviderEpg(provider, metadata, now, force, onProgress) { false }++ suspend fun syncXtreamEpgOnly(provider: Provider, onProgress: ((String) -> Unit)?) =+ syncXmlTvEpgOnly(+ provider = provider,+ epgUrl = provider.epgUrl.ifBlank {+ XtreamUrlFactory.buildXmltvUrl(+ provider.serverUrl.trimEnd('/'),+ provider.username,+ provider.password+ )+ },+ validateUrl = UrlSecurityPolicy::validateXtreamEpgUrl,+ onProgress = onProgress+ )++ suspend fun syncM3uEpgOnly(provider: Provider, onProgress: ((String) -> Unit)?) =+ syncXmlTvEpgOnly(+ provider = provider,+ epgUrl = provider.epgUrl,+ validateUrl = UrlSecurityPolicy::validateOptionalEpgUrl,+ onProgress = onProgress+ )++ suspend fun syncStalkerEpgOnly(provider: Provider, onProgress: ((String) -> Unit)?) {+ progress(provider.id, onProgress, "Retrying EPG...")+ val hiddenLiveCategoryIds = preferencesRepository.getHiddenCategoryIds(provider.id, ContentType.LIVE).first()+ val guidePolicy = provider.guideSourcePolicy+ if (guidePolicy == GuideSourcePolicy.DISABLED) {+ progress(provider.id, onProgress, "Guide data disabled for this provider.")+ epgSourceRepository.resolveForProvider(provider.id, hiddenLiveCategoryIds)+ return+ }+ if (shouldUseProviderGuide(guidePolicy)) {+ syncStalkerPreferredEpg(provider, System.currentTimeMillis(), onProgress)+ }+ if (shouldUseExternalGuide(guidePolicy)) {+ refreshExternalGuide(provider, hiddenLiveCategoryIds, onProgress)+ } else {+ progress(provider.id, onProgress, "Resolving provider EPG mappings...")+ epgSourceRepository.resolveForProvider(provider.id, hiddenLiveCategoryIds)+ }+ }++ private suspend fun syncXmlTvEpgOnly(+ provider: Provider,+ epgUrl: String,+ validateUrl: (String) -> String?,+ onProgress: ((String) -> Unit)?+ ) {+ progress(provider.id, onProgress, "Retrying EPG...")+ val hiddenLiveCategoryIds = preferencesRepository.getHiddenCategoryIds(provider.id, ContentType.LIVE).first()+ val guidePolicy = provider.guideSourcePolicy+ if (guidePolicy == GuideSourcePolicy.DISABLED) {+ progress(provider.id, onProgress, "Guide data disabled for this provider.")+ epgSourceRepository.resolveForProvider(provider.id, hiddenLiveCategoryIds)+ return+ }+ if (!shouldUseProviderGuide(guidePolicy)) {+ if (shouldUseExternalGuide(guidePolicy)) {+ refreshExternalGuide(provider, hiddenLiveCategoryIds, onProgress)+ }+ return+ }+ if (epgUrl.isBlank()) throw IllegalStateException("No EPG URL configured for this provider")+ validateUrl(epgUrl)?.let { throw IllegalStateException(it) }+ xtreamSupport.retryTransient {+ requireResult(epgRepository.refreshEpg(provider.id, epgUrl), "Failed to refresh EPG")+ }+ val now = System.currentTimeMillis()+ val metadata = (syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)).copy(+ lastEpgSync = now,+ lastEpgSuccess = now,+ epgCount = programDao.countByProvider(provider.id)+ )+ syncMetadataRepository.updateMetadata(metadata)+ if (shouldUseExternalGuide(guidePolicy)) {+ refreshExternalGuide(provider, hiddenLiveCategoryIds, onProgress)+ } else {+ progress(provider.id, onProgress, "Resolving provider EPG mappings...")+ epgSourceRepository.resolveForProvider(provider.id, hiddenLiveCategoryIds)+ }+ }++ private suspend fun syncProviderEpg(+ provider: Provider,+ metadata: SyncMetadata,+ now: Long,+ force: Boolean,+ onProgress: ((String) -> Unit)?,+ syncNativeGuide: suspend (MutableList<String>) -> Boolean+ ): ProviderGuideSyncResult {+ val warnings = mutableListOf<String>()+ var hasRetryableFailure = syncNativeGuide(warnings)+ val hiddenLiveCategoryIds = preferencesRepository.getHiddenCategoryIds(provider.id, ContentType.LIVE).first()+ when {+ shouldUseExternalGuide(provider.guideSourcePolicy) -> {+ hasRetryableFailure = hasRetryableFailure ||+ refreshExternalGuide(provider, hiddenLiveCategoryIds, onProgress, warnings)+ }+ provider.guideSourcePolicy == GuideSourcePolicy.DISABLED -> {+ progress(provider.id, onProgress, "Guide data disabled for this provider.")+ epgSourceRepository.resolveForProvider(provider.id, hiddenLiveCategoryIds)+ }+ else -> {+ progress(provider.id, onProgress, "Resolving provider EPG mappings...")+ epgSourceRepository.resolveForProvider(provider.id, hiddenLiveCategoryIds)+ }+ }+ return ProviderGuideSyncResult(warnings, hasRetryableFailure)+ }++ private suspend fun refreshExternalGuide(+ provider: Provider,+ hiddenLiveCategoryIds: Set<Long>,+ onProgress: ((String) -> Unit)?,+ warnings: MutableList<String>? = null+ ): Boolean {+ try {+ progress(provider.id, onProgress, "Refreshing external EPG sources...")+ xtreamSupport.retryTransient {+ requireResult(epgSourceRepository.refreshAllForProvider(provider.id), "External EPG source refresh failed")+ }+ progress(provider.id, onProgress, "Resolving EPG mappings...")+ epgSourceRepository.resolveForProvider(provider.id, hiddenLiveCategoryIds)+ return false+ } catch (e: CancellationException) {+ throw e+ } catch (e: Exception) {+ Log.e(TAG, "External EPG resolution failed (non-fatal): ${sanitizeThrowableMessage(e)}")+ if (warnings == null) throw e+ warnings.add("External EPG source refresh/resolution failed.")+ return isRetryableEpgException(e)+ }+ }++ private fun shouldUseProviderGuide(policy: GuideSourcePolicy): Boolean =+ policy == GuideSourcePolicy.AUTO || policy == GuideSourcePolicy.PROVIDER_ONLY++ private fun shouldUseExternalGuide(policy: GuideSourcePolicy): Boolean =+ policy == GuideSourcePolicy.AUTO || policy == GuideSourcePolicy.EXTERNAL_ONLY++ private fun Throwable.hasStalkerRateLimit(): Boolean =+ generateSequence(this as Throwable?) { it.cause }+ .any { it is StalkerApiError.RateLimited }++ private fun isRetryableEpgException(e: Exception): Boolean =+ e is java.io.IOException ||+ e is java.net.SocketTimeoutException ||+ e is java.net.ConnectException ||+ e is java.net.UnknownHostException ||+ e.cause?.let {+ it is java.io.IOException ||+ it is java.net.SocketTimeoutException ||+ it is java.net.ConnectException ||+ it is java.net.UnknownHostException+ } == true++ private fun <T> requireResult(result: Result<T>, fallbackMessage: String): T = when (result) {+ is Result.Success -> result.data+ is Result.Error -> throw IllegalStateException(result.message.ifBlank { fallbackMessage }, result.exception)+ is Result.Loading -> throw IllegalStateException("Unexpected loading state")+ }++ private class StalkerBrokenPerChannelEpgException(channelName: String) :+ RuntimeException("Stalker portal returned bulk-shaped EPG for per-channel request ($channelName)")++ private companion object {+ const val TAG = "ProviderEpgSync"+ const val STALKER_GUIDE_PROGRAM_BATCH_SIZE = 500+ const val STALKER_MIN_HEALTHY_EPG_PROGRAMS = 3+ const val STALKER_PER_CHANNEL_RECORD_SANITY_CAP = 5_000+ const val STALKER_PER_CHANNEL_EPG_REQUESTS_PER_RUN = 48+ const val MILLIS_PER_DAY = 24L * 60L * 60L * 1000L+ }+}diff --git a/data/src/main/java/com/streamvault/data/sync/ProviderSyncAdapterRegistry.kt b/data/src/main/java/com/streamvault/data/sync/ProviderSyncAdapterRegistry.ktindex 8663d2e3..5f5e0d5d 100644--- a/data/src/main/java/com/streamvault/data/sync/ProviderSyncAdapterRegistry.kt+++ b/data/src/main/java/com/streamvault/data/sync/ProviderSyncAdapterRegistry.kt@@ -36,38 +36,38 @@ internal data class ProviderGuideSyncResult(internal fun ProviderSnapshot.toSyncCompatibilityProvider() =toLegacyProvider()-internal interface ProviderSyncAdapter {+internal interface CatalogSyncPlan {val providerType: ProviderTypesuspend fun syncFull(request: FullProviderSyncRequest): SyncOutcomesuspend fun syncSection(request: SectionProviderSyncRequest): CapabilityResolution<SyncOutcome>suspend fun syncGuide(request: ProviderGuideSyncRequest): CapabilityResolution<ProviderGuideSyncResult>}-internal class ProviderSyncAdapterRegistry(adapters: Collection<ProviderSyncAdapter>) {- private val adaptersByType: Map<ProviderType, ProviderSyncAdapter>+internal class CatalogSyncPlanRegistry(plans: Collection<CatalogSyncPlan>) {+ private val plansByType: Map<ProviderType, CatalogSyncPlan>init {- val duplicates = adapters.groupingBy { it.providerType }.eachCount().filterValues { it != 1 }.keys- require(duplicates.isEmpty()) { "Duplicate provider sync adapters: $duplicates" }- val missing = ProviderType.entries.toSet() - adapters.mapTo(mutableSetOf()) { it.providerType }- require(missing.isEmpty()) { "Missing provider sync adapters: $missing" }- adaptersByType = adapters.associateBy { it.providerType }+ val duplicates = plans.groupingBy { it.providerType }.eachCount().filterValues { it != 1 }.keys+ require(duplicates.isEmpty()) { "Duplicate catalog sync plans: $duplicates" }+ val missing = ProviderType.entries.toSet() - plans.mapTo(mutableSetOf()) { it.providerType }+ require(missing.isEmpty()) { "Missing catalog sync plans: $missing" }+ plansByType = plans.associateBy { it.providerType }}- fun resolve(snapshot: ProviderSnapshot): CapabilityResolution<ProviderSyncAdapter> {+ fun resolve(snapshot: ProviderSnapshot): CapabilityResolution<CatalogSyncPlan> {if (snapshot.provider.type != snapshot.configuration.type) {return CapabilityResolution.ConfigurationError("Provider/configuration type mismatch")}- return CapabilityResolution.Available(adaptersByType.getValue(snapshot.provider.type))+ return CapabilityResolution.Available(plansByType.getValue(snapshot.provider.type))}}-internal class LambdaProviderSyncAdapter(+internal class LambdaCatalogSyncPlan(override val providerType: ProviderType,private val full: suspend (FullProviderSyncRequest) -> SyncOutcome,private val section: suspend (SectionProviderSyncRequest) -> CapabilityResolution<SyncOutcome>,private val guide: suspend (ProviderGuideSyncRequest) -> CapabilityResolution<ProviderGuideSyncResult>-) : ProviderSyncAdapter {+) : CatalogSyncPlan {override suspend fun syncFull(request: FullProviderSyncRequest): SyncOutcome = full(request)override suspend fun syncSection(request: SectionProviderSyncRequest): CapabilityResolution<SyncOutcome> = section(request)override suspend fun syncGuide(request: ProviderGuideSyncRequest): CapabilityResolution<ProviderGuideSyncResult> =diff --git a/data/src/main/java/com/streamvault/data/sync/ProviderSyncLockRegistry.kt b/data/src/main/java/com/streamvault/data/sync/ProviderSyncLockRegistry.ktnew file mode 100644index 00000000..e160d4b6--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/ProviderSyncLockRegistry.kt@@ -0,0 +1,64 @@+package com.streamvault.data.sync++import com.streamvault.domain.model.ContentType+import java.util.concurrent.ConcurrentHashMap+import javax.inject.Inject+import javax.inject.Singleton+import kotlinx.coroutines.sync.Mutex++/**+ * Owns the narrower locks used by interactive hydration and incremental index work.+ *+ * The provider-wide execution lane lives in [ProviderWorkLockRegistry]. These locks deliberately+ * remain separate because category hydration and Stalker summary/index work can be concurrent+ * across independent categories while still requiring same-key serialization.+ */+@Singleton+class ProviderSyncLockRegistry @Inject constructor() {+ private val vodCategoryLocks = ConcurrentHashMap<String, Mutex>()+ private val stalkerSummaryLocks = ConcurrentHashMap<Long, Mutex>()+ private val stalkerIndexSectionLocks = ConcurrentHashMap<String, Mutex>()++ suspend fun <T> withVodCategoryLock(+ providerId: Long,+ categoryId: Long,+ splitCatalog: Boolean,+ block: suspend () -> T+ ): T = withMutexLock(+ lockFor(vodCategoryLocks, vodCategoryKey(providerId, categoryId, splitCatalog)),+ block+ )++ suspend fun <T> withStalkerSummaryLock(+ providerId: Long,+ block: suspend () -> T+ ): T = withMutexLock(lockFor(stalkerSummaryLocks, providerId), block)++ suspend fun <T> withStalkerIndexSectionLock(+ providerId: Long,+ section: ContentType,+ block: suspend () -> T+ ): T = withMutexLock(lockFor(stalkerIndexSectionLocks, "$providerId:${section.name}"), block)++ /** Removes idle keys after durable provider deletion. */+ fun forgetProvider(providerId: Long) {+ stalkerSummaryLocks.remove(providerId)+ vodCategoryLocks.keys.removeIf { it.startsWith("$providerId:") || it.startsWith("split:$providerId:") }+ stalkerIndexSectionLocks.keys.removeIf { it.startsWith("$providerId:") }+ }++ private fun vodCategoryKey(providerId: Long, categoryId: Long, splitCatalog: Boolean): String =+ if (splitCatalog) "split:$providerId:$categoryId" else "$providerId:$categoryId"++ private fun <K> lockFor(locks: ConcurrentHashMap<K, Mutex>, key: K): Mutex =+ locks.computeIfAbsent(key) { Mutex() }++ private suspend fun <T> withMutexLock(mutex: Mutex, block: suspend () -> T): T {+ mutex.lock()+ return try {+ block()+ } finally {+ mutex.unlock()+ }+ }+}diff --git a/data/src/main/java/com/streamvault/data/sync/ProviderSyncPorts.kt b/data/src/main/java/com/streamvault/data/sync/ProviderSyncPorts.ktnew file mode 100644index 00000000..37b1fd13--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/ProviderSyncPorts.kt@@ -0,0 +1,137 @@+package com.streamvault.data.sync++import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.LegacyProvider as Provider+import com.streamvault.domain.model.ProviderEpgSyncMode+import com.streamvault.domain.model.Result+import com.streamvault.domain.model.SyncState+import com.streamvault.domain.model.VodCategoryHydrationRequest+import kotlinx.coroutines.flow.Flow++/** Commands needed by provider repositories and background workers. */+interface ProviderSyncCommands {+ fun currentSyncState(providerId: Long): SyncState++ suspend fun sync(+ providerId: Long,+ force: Boolean = false,+ movieFastSyncOverride: Boolean? = null,+ epgSyncModeOverride: ProviderEpgSyncMode? = null,+ onProgress: ((String) -> Unit)? = null,+ trackInitialLiveOnboarding: Boolean = false+ ): Result<Unit>++ suspend fun syncWithProviderOverride(+ providerId: Long,+ force: Boolean = false,+ movieFastSyncOverride: Boolean? = null,+ epgSyncModeOverride: ProviderEpgSyncMode? = null,+ onProgress: ((String) -> Unit)? = null,+ trackInitialLiveOnboarding: Boolean = false,+ providerOverride: Provider? = null,+ afterCatalogApply: (suspend () -> Unit)? = null+ ): Result<Unit>++ suspend fun syncEpg(+ providerId: Long,+ force: Boolean = true,+ onProgress: ((String) -> Unit)? = null+ ): Result<Unit>++ suspend fun retrySection(+ providerId: Long,+ section: SyncRepairSection,+ movieFastSyncOverride: Boolean? = null,+ syncReason: XtreamLiveSyncReason = XtreamLiveSyncReason.MANUAL_SETTINGS,+ onProgress: ((String) -> Unit)? = null+ ): Result<Unit>++ suspend fun processQueuedXtreamIndexJobs(+ providerId: Long,+ section: ContentType? = null,+ force: Boolean = false,+ maxCategoriesPerSection: Int? = null,+ onProgress: ((String) -> Unit)? = null+ ): Result<Unit>++ suspend fun processQueuedStalkerIndexJobs(+ providerId: Long,+ section: ContentType? = null,+ force: Boolean = false,+ maxCategoriesPerSection: Int? = null,+ onProgress: ((String) -> Unit)? = null+ ): Result<Unit>++ suspend fun rebuildXtreamIndex(+ providerId: Long,+ onProgress: ((String) -> Unit)? = null+ ): Result<Unit>++ fun scheduleProviderSyncResume(providerId: Long, configurationGeneration: Long? = null)++ fun scheduleBackgroundEpgSync(providerId: Long)++ fun scheduleXtreamIndexSync(+ providerId: Long,+ section: ContentType? = null,+ force: Boolean = false+ )++ fun scheduleStalkerIndexSync(+ providerId: Long,+ section: ContentType? = null,+ force: Boolean = false,+ initialDelaySeconds: Long = 0L,+ appendSuccessor: Boolean = false+ )++ fun cancelStalkerIndexSync(providerId: Long)+}++/** Catalog hydration and prioritization commands needed by browse repositories. */+interface CatalogHydrationCommands {+ suspend fun hydrateUnifiedVodCategory(+ providerId: Long,+ categoryId: Long,+ request: VodCategoryHydrationRequest+ ): Result<Unit>++ suspend fun hydrateSplitVodCategory(+ providerId: Long,+ movieCategoryId: Long,+ request: VodCategoryHydrationRequest,+ requestedProjection: ContentType = ContentType.MOVIE+ ): Result<Unit>++ suspend fun hydrateSplitVodSeriesCategory(+ providerId: Long,+ seriesCategoryId: Long,+ request: VodCategoryHydrationRequest+ ): Result<Unit>++ suspend fun prioritizeXtreamIndexCategory(+ providerId: Long,+ section: ContentType,+ categoryId: Long+ )++ suspend fun prioritizeStalkerIndexCategory(+ providerId: Long,+ section: ContentType,+ categoryId: Long+ )+}++/** Narrow state source used by the derived domain sync-state reader. */+interface ProviderSyncStateSource {+ fun currentSyncState(providerId: Long): SyncState++ fun syncStateForProvider(providerId: Long): Flow<SyncState>+}++/** Cleanup hook used by deletion workers without exposing sync policy. */+interface ProviderSyncLifecycle {+ suspend fun onProviderDeleted(providerId: Long)++ suspend fun reconcileStalkerIndexWorkAtStartup()+}diff --git a/data/src/main/java/com/streamvault/data/sync/ProviderSyncStateReaderImpl.kt b/data/src/main/java/com/streamvault/data/sync/ProviderSyncStateReaderImpl.ktindex 3244d736..575f4918 100644--- a/data/src/main/java/com/streamvault/data/sync/ProviderSyncStateReaderImpl.kt+++ b/data/src/main/java/com/streamvault/data/sync/ProviderSyncStateReaderImpl.kt@@ -14,7 +14,7 @@ import kotlinx.coroutines.flow.combine@Singletonclass ProviderSyncStateReaderImpl @Inject constructor(- private val syncManager: SyncManager,+ private val syncManager: ProviderSyncStateSource,private val xtreamIndexJobDao: XtreamIndexJobDao,private val providerWorkflowDao: ProviderWorkflowDao) : ProviderSyncStateReader {diff --git a/data/src/main/java/com/streamvault/data/sync/ProviderSyncWorkScheduler.kt b/data/src/main/java/com/streamvault/data/sync/ProviderSyncWorkScheduler.ktnew file mode 100644index 00000000..0ea7830d--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/ProviderSyncWorkScheduler.kt@@ -0,0 +1,76 @@+package com.streamvault.data.sync++import android.content.Context+import com.streamvault.domain.model.ContentType+import dagger.hilt.android.qualifiers.ApplicationContext+import javax.inject.Inject+import javax.inject.Singleton++/**+ * Owns durable provider-sync work scheduling.+ *+ * Catalog plans may decide what work is needed, but they do not construct+ * WorkManager requests themselves. Keeping this policy here also makes sync+ * orchestration testable without coupling every provider plan to Android.+ */+@Singleton+class ProviderSyncWorkScheduler @Inject constructor(+ @param:ApplicationContext private val applicationContext: Context+) {+ fun cancelBackgroundEpg(providerId: Long) {+ BackgroundEpgSyncWorker.cancel(applicationContext, providerId)+ }++ fun cancelStalkerIndex(providerId: Long) {+ StalkerIndexWorker.cancel(applicationContext, providerId)+ }++ fun scheduleBackgroundEpg(providerId: Long) {+ BackgroundEpgSyncWorker.enqueue(applicationContext, providerId)+ }++ fun scheduleProviderResume(providerId: Long, configurationGeneration: Long? = null) {+ if (configurationGeneration != null) {+ ProviderSyncWorker.enqueueProviderConfigRevision(+ context = applicationContext,+ providerId = providerId,+ revision = configurationGeneration+ )+ } else {+ ProviderSyncWorker.enqueueProvider(applicationContext, providerId)+ }+ }++ fun scheduleXtreamIndex(+ providerId: Long,+ section: ContentType? = null,+ force: Boolean = false+ ) {+ XtreamIndexWorker.enqueue(+ context = applicationContext,+ providerId = providerId,+ section = section?.name,+ force = force+ )+ }++ fun scheduleStalkerIndex(+ providerId: Long,+ force: Boolean = false,+ initialDelaySeconds: Long = 0L,+ appendSuccessor: Boolean = false+ ) {+ // Stalker section requests are intentionally coalesced into the durable+ // provider job. This preserves the existing worker contract: the worker+ // selects the next pending section from its persisted job state.+ StalkerIndexWorker.enqueue(+ context = applicationContext,+ providerId = providerId,+ section = null,+ force = force,+ initialDelaySeconds = initialDelaySeconds,+ appendSuccessor = appendSuccessor+ )+ }++}diff --git a/data/src/main/java/com/streamvault/data/sync/ProviderSyncWorker.kt b/data/src/main/java/com/streamvault/data/sync/ProviderSyncWorker.ktindex 883c66bb..90e3cdd7 100644--- a/data/src/main/java/com/streamvault/data/sync/ProviderSyncWorker.kt+++ b/data/src/main/java/com/streamvault/data/sync/ProviderSyncWorker.kt@@ -58,7 +58,7 @@ internal suspend fun reconcileTargetedProviderStatus(channelDao: ChannelDao,categoryDao: CategoryDao,syncMetadataRepository: SyncMetadataRepository,- syncManager: SyncManager,+ syncManager: ProviderSyncCommands,provider: com.streamvault.data.local.entity.ProviderEntity,result: com.streamvault.domain.model.Result<Unit>,currentTimeMillis: Long = System.currentTimeMillis()@@ -148,7 +148,7 @@ class ProviderSyncWorker(fun providerDao(): ProviderDaofun channelDao(): ChannelDaofun categoryDao(): CategoryDao- fun syncManager(): SyncManager+ fun syncCommands(): ProviderSyncCommandsfun syncMetadataRepository(): SyncMetadataRepositoryfun providerConfigRevisionDao(): ProviderConfigRevisionDaofun credentialCrypto(): CredentialCrypto@@ -227,7 +227,7 @@ class ProviderSyncWorker(onboardingDao = entryPoint.xtreamLiveOnboardingDao())val result = if (requestedProviderId == provider.id) {- entryPoint.syncManager().sync(+ entryPoint.syncCommands().sync(provider.id,force = false,trackInitialLiveOnboarding = trackInitialLiveOnboarding@@ -237,7 +237,7 @@ class ProviderSyncWorker(} else if (provider.type == ProviderType.STALKER_PORTAL) {syncStalkerProviderIfStale(entryPoint, provider)} else {- entryPoint.syncManager().sync(provider.id, force = false)+ entryPoint.syncCommands().sync(provider.id, force = false)}if (requestedProviderId == provider.id) {reconcileTargetedProviderStatusFenced(entryPoint, provider, result)@@ -245,7 +245,7 @@ class ProviderSyncWorker(when (result) {is com.streamvault.domain.model.Result.Success ->ProviderWorkflowOutcome.Success(- partial = entryPoint.syncManager().currentSyncState(provider.id) is SyncState.Partial+ partial = entryPoint.syncCommands().currentSyncState(provider.id) is SyncState.Partial)is com.streamvault.domain.model.Result.Error -> {Log.w(TAG, "Provider sync worker failed for provider ${provider.id}: ${result.message}")@@ -398,7 +398,7 @@ class ProviderSyncWorker(decodedRevision.configurationGeneration}- val result = entryPoint.syncManager().syncWithProviderOverride(+ val result = entryPoint.syncCommands().syncWithProviderOverride(providerId = providerId,// Recovery must revalidate the staged configuration instead of accepting a fresh// cache belonging to the previously committed configuration.@@ -628,7 +628,7 @@ class ProviderSyncWorker(): com.streamvault.domain.model.Result<Unit> {val now = System.currentTimeMillis()if (shouldTrackInitialLiveOnboarding(provider, entryPoint.xtreamLiveOnboardingDao())) {- return entryPoint.syncManager().sync(+ return entryPoint.syncCommands().sync(provider.id,force = false,trackInitialLiveOnboarding = true@@ -654,7 +654,7 @@ class ProviderSyncWorker(}if (liveStale) {- when (val liveResult = entryPoint.syncManager().retrySection(+ when (val liveResult = entryPoint.syncCommands().retrySection(provider.id,SyncRepairSection.LIVE,syncReason = XtreamLiveSyncReason.BACKGROUND_STALE@@ -664,16 +664,16 @@ class ProviderSyncWorker(}}if (epgStale) {- when (val epgResult = entryPoint.syncManager().syncEpg(provider.id, force = false)) {+ when (val epgResult = entryPoint.syncCommands().syncEpg(provider.id, force = false)) {is com.streamvault.domain.model.Result.Error -> return epgResultelse -> Unit}}if (movieIndexDue) {- entryPoint.syncManager().scheduleXtreamIndexSync(provider.id, ContentType.MOVIE)+ entryPoint.syncCommands().scheduleXtreamIndexSync(provider.id, ContentType.MOVIE)}if (seriesIndexDue) {- entryPoint.syncManager().scheduleXtreamIndexSync(provider.id, ContentType.SERIES)+ entryPoint.syncCommands().scheduleXtreamIndexSync(provider.id, ContentType.SERIES)}return com.streamvault.domain.model.Result.success(Unit)}@@ -717,19 +717,19 @@ class ProviderSyncWorker(}if (liveStale) {- when (val liveResult = entryPoint.syncManager().retrySection(provider.id, SyncRepairSection.LIVE)) {+ when (val liveResult = entryPoint.syncCommands().retrySection(provider.id, SyncRepairSection.LIVE)) {is com.streamvault.domain.model.Result.Error -> return liveResultelse -> Unit}}if (movieIndexDue) {- entryPoint.syncManager().scheduleStalkerIndexSync(provider.id, ContentType.MOVIE)+ entryPoint.syncCommands().scheduleStalkerIndexSync(provider.id, ContentType.MOVIE)}if (seriesIndexDue) {- entryPoint.syncManager().scheduleStalkerIndexSync(provider.id, ContentType.SERIES)+ entryPoint.syncCommands().scheduleStalkerIndexSync(provider.id, ContentType.SERIES)}if (epgStale) {- entryPoint.syncManager().scheduleBackgroundEpgSync(provider.id)+ entryPoint.syncCommands().scheduleBackgroundEpgSync(provider.id)}return com.streamvault.domain.model.Result.success(Unit)}@@ -761,7 +761,7 @@ class ProviderSyncWorker(channelDao = entryPoint.channelDao(),categoryDao = entryPoint.categoryDao(),syncMetadataRepository = entryPoint.syncMetadataRepository(),- syncManager = entryPoint.syncManager(),+ syncManager = entryPoint.syncCommands(),provider = provider,result = result)diff --git a/data/src/main/java/com/streamvault/data/sync/ProviderWorkLockRegistry.kt b/data/src/main/java/com/streamvault/data/sync/ProviderWorkLockRegistry.ktindex 3b1ccd55..74d7a8c3 100644--- a/data/src/main/java/com/streamvault/data/sync/ProviderWorkLockRegistry.kt+++ b/data/src/main/java/com/streamvault/data/sync/ProviderWorkLockRegistry.kt@@ -4,12 +4,15 @@ import java.util.concurrent.ConcurrentHashMapimport java.util.concurrent.atomic.AtomicIntegerimport kotlinx.coroutines.sync.Muteximport kotlinx.coroutines.sync.withLock+import javax.inject.Inject+import javax.inject.Singleton/*** Provides one in-process execution lane per provider, regardless of whether work originated* from foreground refresh, catalog indexing, EPG, or a WorkManager recovery entry point.*/-internal class ProviderWorkLockRegistry {+@Singleton+class ProviderWorkLockRegistry @Inject constructor() {private val admissionMutex = Mutex()private val providerMutexes = ConcurrentHashMap<Long, Mutex>()private val admittedCount = AtomicInteger(0)@@ -39,4 +42,11 @@ internal class ProviderWorkLockRegistry {block()}}++ /** Removes idle provider state after durable provider deletion. */+ suspend fun forgetProvider(providerId: Long) {+ admissionMutex.withLock {+ providerMutexes.remove(providerId)+ }+ }}diff --git a/data/src/main/java/com/streamvault/data/sync/StalkerCatalogSectionExecutor.kt b/data/src/main/java/com/streamvault/data/sync/StalkerCatalogSectionExecutor.ktnew file mode 100644index 00000000..af7d8920--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/StalkerCatalogSectionExecutor.kt@@ -0,0 +1,154 @@+package com.streamvault.data.sync++import com.streamvault.data.local.dao.MovieCategoryHydrationDao+import com.streamvault.data.local.dao.SeriesCategoryHydrationDao+import com.streamvault.data.local.dao.MovieDao+import com.streamvault.data.local.dao.SeriesDao+import com.streamvault.data.local.dao.XtreamContentIndexDao+import com.streamvault.data.local.entity.CategoryEntity+import com.streamvault.data.remote.stalker.StalkerProvider+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.LegacyProvider as Provider+import com.streamvault.domain.model.Result+import com.streamvault.domain.model.SyncMetadata+import com.streamvault.domain.model.VodSyncMode+import com.streamvault.domain.repository.SyncMetadataRepository+import com.streamvault.domain.sync.Section+import kotlinx.coroutines.flow.first++/** Owns Stalker movie/series repair setup and durable index continuation handoff. */+internal class StalkerCatalogSectionExecutor(+ private val movieCategoryHydrationDao: MovieCategoryHydrationDao,+ private val seriesCategoryHydrationDao: SeriesCategoryHydrationDao,+ private val xtreamContentIndexDao: XtreamContentIndexDao,+ private val syncCatalogStore: SyncCatalogStore,+ private val movieDao: MovieDao,+ private val seriesDao: SeriesDao,+ private val syncMetadataRepository: SyncMetadataRepository,+ private val createProvider: (Provider) -> StalkerProvider,+ private val updateIndexJob: suspend (Long, ContentType, Int, Long) -> Unit,+ private val emitSectionProgress: (Long, Section, Int, Int) -> Unit,+ private val progress: (Long, ((String) -> Unit)?, String) -> Unit+) {+ suspend fun queueIndexSection(+ providerId: Long,+ contentType: ContentType,+ totalCategories: Int,+ now: Long+ ) {+ require(contentType == ContentType.MOVIE || contentType == ContentType.SERIES) {+ "Unsupported Stalker index section: $contentType"+ }+ when (contentType) {+ ContentType.MOVIE -> movieCategoryHydrationDao.deleteByProvider(providerId)+ ContentType.SERIES -> seriesCategoryHydrationDao.deleteByProvider(providerId)+ else -> Unit+ }+ xtreamContentIndexDao.markRowsStaleForProviderAndType(providerId, contentType.name)+ updateIndexJob(providerId, contentType, totalCategories, now)+ }++ suspend fun syncMovies(+ provider: Provider,+ onProgress: ((String) -> Unit)?+ ): SyncOutcome {+ val now = System.currentTimeMillis()+ progress(provider.id, onProgress, "Queueing Movies index...")+ val api = createProvider(provider)+ val categories = requireResult(api.getVodCategories(), "Failed to load movie categories")+ emitSectionProgress(+ provider.id,+ Section.VOD,+ categories.size,+ movieDao.getCount(provider.id).first()+ )+ syncCatalogStore.replaceCategories(+ providerId = provider.id,+ type = ContentType.MOVIE.name,+ categories = categories.map { category ->+ CategoryEntity(+ providerId = provider.id,+ categoryId = category.id,+ name = category.name,+ parentId = category.parentId,+ type = ContentType.MOVIE,+ isAdult = category.isAdult+ )+ }+ )+ queueIndexSection(provider.id, ContentType.MOVIE, categories.size, now)+ val metadata = (syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id))+ .copy(+ lastMovieSync = now,+ lastMovieAttempt = now,+ movieCount = movieDao.getCount(provider.id).first(),+ movieSyncMode = VodSyncMode.PAGED,+ movieWarningsCount = 0,+ movieCatalogStale = true+ )+ syncMetadataRepository.updateMetadata(metadata)+ return SyncOutcome(+ continuationWork = listOf(+ SyncContinuation(+ operation = SyncContinuationOperation.INDEX_CATALOG,+ section = ContentType.MOVIE,+ reason = "movie category shell is committed; durable item indexing is queued"+ )+ ),+ activation = SyncActivation.DEFERRED_TO_FOLLOW_UP+ )+ }++ suspend fun syncSeries(+ provider: Provider,+ onProgress: ((String) -> Unit)?+ ): SyncOutcome {+ progress(provider.id, onProgress, "Queueing Series index...")+ val api = createProvider(provider)+ val categories = requireResult(api.getSeriesCategories(), "Failed to load series categories")+ emitSectionProgress(+ provider.id,+ Section.SERIES,+ categories.size,+ seriesDao.getCount(provider.id).first()+ )+ syncCatalogStore.replaceCategories(+ providerId = provider.id,+ type = ContentType.SERIES.name,+ categories = categories.map { category ->+ CategoryEntity(+ providerId = provider.id,+ categoryId = category.id,+ name = category.name,+ parentId = category.parentId,+ type = ContentType.SERIES,+ isAdult = category.isAdult+ )+ }+ )+ val now = System.currentTimeMillis()+ queueIndexSection(provider.id, ContentType.SERIES, categories.size, now)+ val metadata = (syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id))+ .copy(+ lastSeriesSync = now,+ seriesCount = seriesDao.getCount(provider.id).first()+ )+ syncMetadataRepository.updateMetadata(metadata)+ return SyncOutcome(+ continuationWork = listOf(+ SyncContinuation(+ operation = SyncContinuationOperation.INDEX_CATALOG,+ section = ContentType.SERIES,+ reason = "series category shell is committed; durable item indexing is queued"+ )+ ),+ activation = SyncActivation.DEFERRED_TO_FOLLOW_UP+ )+ }++ private fun <T> requireResult(result: Result<T>, fallbackMessage: String): T = when (result) {+ is Result.Success -> result.data+ is Result.Error -> throw IllegalStateException(result.message.ifBlank { fallbackMessage }, result.exception)+ is Result.Loading -> throw IllegalStateException("Unexpected loading state")+ }+}diff --git a/data/src/main/java/com/streamvault/data/sync/StalkerCatalogSyncExecutor.kt b/data/src/main/java/com/streamvault/data/sync/StalkerCatalogSyncExecutor.ktnew file mode 100644index 00000000..2726fc87--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/StalkerCatalogSyncExecutor.kt@@ -0,0 +1,707 @@+package com.streamvault.data.sync++import android.content.Context+import android.util.Log+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.MovieCategoryHydrationDao+import com.streamvault.data.local.dao.MovieDao+import com.streamvault.data.local.dao.SeriesCategoryHydrationDao+import com.streamvault.data.local.dao.SeriesDao+import com.streamvault.data.local.dao.VodCategoryHydrationDao+import com.streamvault.data.local.dao.VodCatalogEntryDao+import com.streamvault.data.local.entity.CategoryEntity+import com.streamvault.data.mapper.toEntity+import com.streamvault.data.preferences.PreferencesRepository+import com.streamvault.data.remote.dto.XtreamCategory+import com.streamvault.data.remote.stalker.StalkerApiError+import com.streamvault.data.remote.stalker.StalkerProvider+import com.streamvault.data.remote.stalker.StalkerProviderProfile+import com.streamvault.data.remote.stalker.StalkerTelemetry+import com.streamvault.data.provider.toProviderSnapshot+import com.streamvault.data.util.UrlSecurityPolicy+import com.streamvault.domain.model.CatalogLayout+import com.streamvault.domain.model.Category+import com.streamvault.domain.model.Channel+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.LegacyProvider as Provider+import com.streamvault.domain.model.ProviderEpgSyncMode+import com.streamvault.domain.model.Result+import com.streamvault.domain.model.StalkerCatalogMode+import com.streamvault.domain.model.SyncMetadata+import com.streamvault.domain.model.VodSyncMode+import com.streamvault.domain.repository.ProviderSnapshotRepository+import com.streamvault.domain.repository.SyncMetadataRepository+import com.streamvault.domain.sync.Section+import kotlinx.coroutines.CancellationException+import kotlinx.coroutines.async+import kotlinx.coroutines.coroutineScope+import kotlinx.coroutines.delay+import kotlinx.coroutines.isActive+import kotlinx.coroutines.launch+import kotlinx.coroutines.flow.first+import java.io.IOException+import java.util.concurrent.atomic.AtomicLong++private const val STALKER_EXECUTOR_TAG = "StalkerCatalogSync"+private const val STALKER_MAX_PARALLEL_CATEGORY_FETCHES = 2+private const val STALKER_BULK_LIVE_STALL_TIMEOUT_MILLIS = 30_000L+private const val STALKER_BULK_LIVE_STALL_CHECK_INTERVAL_MILLIS = 1_000L+private const val STALKER_BULK_LIVE_UNSUPPORTED_TTL_MILLIS = 6 * 60 * 60 * 1000L+private const val LIVE_CATEGORY_SEQUENTIAL_MODE_WARNING =+ "Live category sync downgraded to sequential mode after provider stress signals."+private const val FALLBACK_STAGE_BATCH_SIZE = 500++/** Owns Stalker authentication, full catalog orchestration, and Live repair execution. */+internal class StalkerCatalogSyncExecutor(+ private val applicationContext: Context,+ private val preferencesRepository: PreferencesRepository,+ private val syncMetadataRepository: SyncMetadataRepository,+ private val providerSnapshotRepository: ProviderSnapshotRepository?,+ private val transactionRunner: DatabaseTransactionRunner,+ private val categoryDao: CategoryDao,+ private val channelDao: ChannelDao,+ private val movieCategoryHydrationDao: MovieCategoryHydrationDao,+ private val seriesCategoryHydrationDao: SeriesCategoryHydrationDao,+ private val vodCategoryHydrationDao: VodCategoryHydrationDao,+ private val vodCatalogEntryDao: VodCatalogEntryDao,+ private val movieDao: MovieDao,+ private val seriesDao: SeriesDao,+ private val syncCatalogStore: SyncCatalogStore,+ private val catalogStager: SyncManagerCatalogStager,+ private val catalogStrategySupport: SyncManagerCatalogStrategySupport,+ private val categoryRecoverySupport: SyncManagerXtreamSupport,+ private val sectionExecutor: StalkerCatalogSectionExecutor,+ private val readinessTracker: StalkerReadinessTracker,+ private val createProvider: (Provider) -> StalkerProvider,+ private val syncProviderEpg: suspend (Provider, SyncMetadata, Long, Boolean, ((String) -> Unit)?) -> ProviderGuideSyncResult,+ private val progress: (Long, ((String) -> Unit)?, String) -> Unit,+ private val emitCatalogProgress: (Long, Section, Int?, Int?) -> Unit,+ private val categoryFailureWarning: (String, String, Throwable) -> String,+ private val sanitizeThrowableMessage: (Throwable?) -> String+) {+ suspend fun syncFull(+ provider: Provider,+ force: Boolean,+ onProgress: ((String) -> Unit)?,+ afterCatalogApply: suspend () -> Unit = {},+ deferProviderStateUntilCatalogCommit: Boolean = false+ ): SyncOutcome {+ val warnings = mutableListOf<String>()+ val continuationWork = mutableListOf<SyncContinuation>()+ var activatedLiveMutations = 0+ var catalogActivated = false+ var preservedActiveCatalog = false+ readinessTracker.start(provider.id)+ UrlSecurityPolicy.validateStalkerPortalUrl(provider.serverUrl)?.let { message ->+ throw IllegalStateException(message)+ }+ emitCatalogProgress(provider.id, Section.LIVE, null, null)+ progress(provider.id, onProgress, "Connecting to portal...")+ val api = createProvider(provider)+ val authenticatedProvider = requireResult(api.authenticate(), "Failed to authenticate with portal")+ val effectiveCatalogLayout = authenticatedProvider.catalogLayout+ .takeUnless { it == CatalogLayout.UNKNOWN }+ ?: provider.catalogLayout+ val catalogLayoutChanged =+ authenticatedProvider.catalogLayout != CatalogLayout.UNKNOWN &&+ authenticatedProvider.catalogLayout != provider.catalogLayout+ val catalogLayoutDetectionChanged =+ catalogLayoutChanged ||+ authenticatedProvider.catalogLayoutDetectionVersion != provider.catalogLayoutDetectionVersion+ var catalogCommitCallback = afterCatalogApply+ if (catalogLayoutDetectionChanged) {+ suspend fun clearIncompatibleVodCatalog() {+ if (catalogLayoutChanged) {+ categoryDao.deleteByProviderAndType(provider.id, ContentType.MOVIE.name)+ categoryDao.deleteByProviderAndType(provider.id, ContentType.SERIES.name)+ categoryDao.deleteByProviderAndType(provider.id, ContentType.VOD.name)+ movieCategoryHydrationDao.deleteByProvider(provider.id)+ seriesCategoryHydrationDao.deleteByProvider(provider.id)+ vodCategoryHydrationDao.deleteByProvider(provider.id)+ vodCatalogEntryDao.deleteByProvider(provider.id)+ }+ }++ if (deferProviderStateUntilCatalogCommit) {+ val originalCallback = catalogCommitCallback+ catalogCommitCallback = {+ originalCallback()+ clearIncompatibleVodCatalog()+ }+ } else {+ transactionRunner.inTransaction {+ if (authenticatedProvider.catalogLayout != CatalogLayout.UNKNOWN) {+ providerSnapshotRepository?.updateCatalogLayout(+ provider.id,+ authenticatedProvider.catalogLayout,+ authenticatedProvider.catalogLayoutDetectionVersion+ )+ }+ clearIncompatibleVodCatalog()+ }+ }+ }+ readinessTracker.authenticated(provider.id)++ var metadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)+ 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)) {+ progress(provider.id, onProgress, "Downloading Live TV...")+ val hiddenLiveCategoryIds = preferencesRepository.getHiddenCategoryIds(provider.id, ContentType.LIVE).first()+ val liveCatalogResult = syncLiveCatalogStaged(+ api = api,+ provider = provider,+ hiddenLiveCategoryIds = hiddenLiveCategoryIds,+ onProgress = onProgress,+ afterCatalogApply = catalogCommitCallback+ )+ metadata = metadata.copy(+ lastLiveSync = now,+ lastLiveSuccess = now,+ liveCount = liveCatalogResult.acceptedCount+ )+ liveCount = liveCatalogResult.acceptedCount+ activatedLiveMutations = liveCatalogResult.acceptedCount+ if (liveCatalogResult.acceptedCount > 0) {+ catalogActivated = true+ } else {+ preservedActiveCatalog = true+ }+ syncMetadataRepository.updateMetadata(metadata)+ emitCatalogProgress(provider.id, Section.LIVE, null, liveCatalogResult.acceptedCount)+ warnings += liveCatalogResult.warnings+ }+ readinessTracker.liveReady(provider.id)++ if (force || catalogLayoutChanged || ContentCachePolicy.shouldRefresh(metadata.lastMovieSuccess, ContentCachePolicy.CATALOG_TTL_MILLIS, now)) {+ progress(provider.id, onProgress, "Preparing Movies...")+ val categories = when (val categoriesResult = if (effectiveCatalogLayout == CatalogLayout.UNIFIED_VOD) {+ api.getUnifiedVodCategories()+ } else {+ api.getVodCategories()+ }) {+ is Result.Success -> categoriesResult.data+ is Result.Error -> {+ val diagnostic = if (liveCount == 0 && warnings.any(::isStalkerEmptyResponse)) {+ stalkerCatalogAccessDiagnostic(api, categoriesResult.message, "empty response")+ } else null+ throw IllegalStateException(+ diagnostic ?: "Failed to load movie categories: ${categoriesResult.message}",+ categoriesResult.exception+ )+ }+ is Result.Loading -> throw IllegalStateException("Unexpected loading state")+ }+ emitCatalogProgress(provider.id, Section.VOD, categories.size, metadata.liveCount)+ val storedCategoryType = if (effectiveCatalogLayout == CatalogLayout.UNIFIED_VOD) ContentType.VOD else ContentType.MOVIE+ syncCatalogStore.replaceCategories(+ providerId = provider.id,+ type = storedCategoryType.name,+ categories = categories.mapIndexed { index, category ->+ CategoryEntity(+ providerId = provider.id,+ categoryId = category.id,+ name = category.name,+ parentId = category.parentId,+ type = storedCategoryType,+ providerOrder = index,+ isAdult = category.isAdult+ )+ }+ )+ catalogActivated = true+ if (effectiveCatalogLayout == CatalogLayout.SPLIT) {+ movieCategoryHydrationDao.deleteByProvider(provider.id)+ }+ categoryDao.deleteByProviderAndType(+ provider.id,+ if (storedCategoryType == ContentType.VOD) ContentType.MOVIE.name else ContentType.VOD.name+ )+ movieCategoryCount = categories.size+ if (effectiveCatalogLayout != CatalogLayout.UNIFIED_VOD && provider.stalkerCatalogMode == StalkerCatalogMode.BACKGROUND_INDEX) {+ sectionExecutor.queueIndexSection(provider.id, ContentType.MOVIE, categories.size, now)+ }+ metadata = metadata.copy(+ lastMovieSync = now,+ lastMovieAttempt = now,+ movieCount = movieDao.getCount(provider.id).first(),+ movieSyncMode = VodSyncMode.PAGED,+ movieWarningsCount = 0,+ movieCatalogStale = true+ )+ syncMetadataRepository.updateMetadata(metadata)+ queuedMovieIndex = provider.stalkerCatalogMode == StalkerCatalogMode.BACKGROUND_INDEX+ }++ if (effectiveCatalogLayout == CatalogLayout.UNIFIED_VOD) {+ categoryDao.deleteByProviderAndType(provider.id, ContentType.SERIES.name)+ seriesCategoryHydrationDao.deleteByProvider(provider.id)+ } else if (force || catalogLayoutChanged || ContentCachePolicy.shouldRefresh(metadata.lastSeriesSuccess, ContentCachePolicy.CATALOG_TTL_MILLIS, now)) {+ progress(provider.id, onProgress, "Preparing Series...")+ val categories = when (val categoriesResult = api.getSeriesCategories()) {+ is Result.Success -> categoriesResult.data+ is Result.Error -> {+ val diagnostic = if (liveCount == 0 && warnings.any(::isStalkerEmptyResponse)) {+ stalkerCatalogAccessDiagnostic(api, categoriesResult.message, "empty response")+ } else null+ throw IllegalStateException(+ diagnostic ?: "Failed to load series categories: ${categoriesResult.message}",+ categoriesResult.exception+ )+ }+ is Result.Loading -> throw IllegalStateException("Unexpected loading state")+ }+ emitCatalogProgress(provider.id, Section.SERIES, categories.size, metadata.liveCount)+ syncCatalogStore.replaceCategories(+ providerId = provider.id,+ type = ContentType.SERIES.name,+ categories = categories.mapIndexed { index, category ->+ CategoryEntity(+ providerId = provider.id,+ categoryId = category.id,+ name = category.name,+ parentId = category.parentId,+ type = ContentType.SERIES,+ providerOrder = index,+ isAdult = category.isAdult+ )+ }+ )+ catalogActivated = true+ seriesCategoryCount = categories.size+ if (provider.stalkerCatalogMode == StalkerCatalogMode.BACKGROUND_INDEX) {+ sectionExecutor.queueIndexSection(provider.id, ContentType.SERIES, categories.size, now)+ }+ metadata = metadata.copy(+ lastSeriesSync = now,+ seriesCount = seriesDao.getCount(provider.id).first()+ )+ syncMetadataRepository.updateMetadata(metadata)+ queuedSeriesIndex = provider.stalkerCatalogMode == StalkerCatalogMode.BACKGROUND_INDEX+ }++ if (liveCount == 0 && movieCategoryCount == 0 && seriesCategoryCount == 0) {+ val diagnostic = warnings.firstOrNull { it.contains("no accessible catalog data", ignoreCase = true) }+ ?: stalkerCatalogAccessDiagnostic(api, "empty response", "empty response")+ diagnostic?.let { throw IllegalStateException(it) }+ }+ readinessTracker.categoriesReady(provider.id)++ if (queuedMovieIndex) {+ continuationWork += SyncContinuation(+ operation = SyncContinuationOperation.INDEX_CATALOG,+ section = ContentType.MOVIE,+ reason = "movie category shell is committed; durable item indexing is queued",+ force = force+ )+ }+ if (queuedSeriesIndex) {+ continuationWork += SyncContinuation(+ operation = SyncContinuationOperation.INDEX_CATALOG,+ section = ContentType.SERIES,+ reason = "series category shell is committed; durable item indexing is queued",+ force = force+ )+ }+ when (provider.epgSyncMode) {+ ProviderEpgSyncMode.UPFRONT -> warnings += syncProviderEpg(+ provider,+ metadata,+ now,+ force,+ onProgress+ ).warnings+ ProviderEpgSyncMode.BACKGROUND -> {+ continuationWork += SyncContinuation(+ operation = SyncContinuationOperation.REFRESH_GUIDE,+ reason = "guide refresh was handed off to background work",+ force = force+ )+ }+ ProviderEpgSyncMode.SKIP -> Unit+ }+ readinessTracker.ready(provider.id, warnings.size)+ return SyncOutcome(+ partial = warnings.isNotEmpty(),+ warnings = warnings.distinct(),+ stagedMutations = activatedLiveMutations,+ continuationWork = continuationWork,+ activation = when {+ catalogActivated -> SyncActivation.ACTIVATED_CATALOG+ preservedActiveCatalog -> SyncActivation.PRESERVED_ACTIVE_CATALOG+ else -> SyncActivation.NO_CATALOG_CHANGE+ }+ )+ }++ suspend fun syncLive(+ provider: Provider,+ onProgress: ((String) -> Unit)?+ ): SyncOutcome {+ val now = System.currentTimeMillis()+ val warnings = mutableListOf<String>()+ emitCatalogProgress(provider.id, Section.LIVE, null, null)+ progress(provider.id, onProgress, "Retrying Live TV...")+ val api = createProvider(provider)+ val hiddenLiveCategoryIds = preferencesRepository.getHiddenCategoryIds(provider.id, ContentType.LIVE).first()+ val liveCatalogResult = syncLiveCatalogStaged(api, provider, hiddenLiveCategoryIds, onProgress)+ val metadata = (syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)).copy(+ lastLiveSync = now,+ lastLiveSuccess = now,+ liveCount = liveCatalogResult.acceptedCount+ )+ syncMetadataRepository.updateMetadata(metadata)+ emitCatalogProgress(provider.id, Section.LIVE, null, liveCatalogResult.acceptedCount)+ warnings += liveCatalogResult.warnings+ return SyncOutcome(+ partial = warnings.isNotEmpty(),+ warnings = warnings.distinct(),+ stagedMutations = liveCatalogResult.acceptedCount,+ activation = if (liveCatalogResult.acceptedCount > 0) {+ SyncActivation.ACTIVATED_CATALOG+ } else {+ SyncActivation.PRESERVED_ACTIVE_CATALOG+ }+ )+ }++ private suspend fun syncLiveCatalogStaged(+ api: StalkerProvider,+ provider: Provider,+ hiddenLiveCategoryIds: Set<Long>,+ onProgress: ((String) -> Unit)?,+ afterCatalogApply: suspend () -> Unit = {}+ ): StagedStalkerLiveCatalogResult {+ val warnings = mutableListOf<String>()+ var categoriesErrorMessage: String? = null+ val preferredCategories = when (val categoriesResult = api.getLiveCategories()) {+ is Result.Success -> categoriesResult.data+ .map { it.toEntity(provider.id) }+ .filterNot { it.categoryId in hiddenLiveCategoryIds }+ is Result.Error -> {+ Log.w(+ STALKER_EXECUTOR_TAG,+ "Stalker live categories failed for provider ${provider.id}; streaming bulk live channels with fallback categories: ${categoriesResult.message}",+ categoriesResult.exception+ )+ warnings += "Live categories failed; recovered using bulk live channels."+ categoriesErrorMessage = categoriesResult.message+ null+ }+ is Result.Loading -> throw IllegalStateException("Unexpected loading state")+ }++ progress(provider.id, onProgress, "Loading live channels...")+ val fallbackCollector = FallbackCategoryCollector(provider.id, ContentType.LIVE)+ val seenStreamIds = HashSet<Long>()+ val batch = ArrayList<Channel>(FALLBACK_STAGE_BATCH_SIZE)+ var stagedSessionId: Long? = null+ var acceptedCount = 0+ var bulkRowsWithResolvedCategories = 0++ suspend fun flushBatch() {+ if (batch.isEmpty()) return+ val staged = catalogStager.stageChannelItems(+ providerId = provider.id,+ items = batch,+ seenStreamIds = seenStreamIds,+ fallbackCollector = fallbackCollector,+ sessionId = stagedSessionId+ )+ stagedSessionId = staged.sessionId+ acceptedCount += staged.acceptedCount+ batch.clear()+ }++ suspend fun finalizeStagedImport(): StagedStalkerLiveCatalogResult {+ stagedSessionId?.let { sessionId ->+ if (hiddenLiveCategoryIds.isNotEmpty()) {+ mergeHiddenChannelsIntoStaging(provider.id, sessionId, hiddenLiveCategoryIds)+ }+ }+ val hiddenCategories = if (hiddenLiveCategoryIds.isNotEmpty()) {+ categoryDao.getByProviderAndTypeSync(provider.id, ContentType.LIVE.name)+ .filter { it.categoryId in hiddenLiveCategoryIds }+ } else emptyList()+ val categories = (+ catalogStrategySupport.mergePreferredAndFallbackCategories(+ preferredCategories,+ fallbackCollector.entities().takeIf { it.isNotEmpty() }+ ).orEmpty() + hiddenCategories+ ).distinctBy { it.categoryId to it.type }.takeIf { it.isNotEmpty() }+ val sessionId = stagedSessionId+ if (acceptedCount == 0 || sessionId == null) {+ sessionId?.let { syncCatalogStore.discardStagedImport(provider.id, it) }+ return StagedStalkerLiveCatalogResult(+ acceptedCount = 0,+ warnings = (warnings + "Live TV returned no usable channels; keeping the last verified Live catalog.").distinct()+ )+ }+ syncCatalogStore.applyStagedLiveCatalog(provider.id, sessionId, categories, afterCatalogApply)+ return StagedStalkerLiveCatalogResult(acceptedCount, warnings)+ }++ try {+ var bulkFailure: Exception? = null+ val learnedState = api.validatedPortalState()+ val bulkUnsupportedVerdictFresh = learnedState?.bulkLiveSupported == false &&+ learnedState.validatedAt > 0L &&+ System.currentTimeMillis() - learnedState.validatedAt <= STALKER_BULK_LIVE_UNSUPPORTED_TTL_MILLIS+ val shouldTryBulk = (!bulkUnsupportedVerdictFresh && learnedState?.bulkLiveCategoryFidelity != false) ||+ preferredCategories.isNullOrEmpty()+ StalkerTelemetry.strategySelected(+ provider.id,+ if (shouldTryBulk) "BULK_LIVE" else "CATEGORY_LIVE",+ when {+ shouldTryBulk && learnedState?.bulkLiveSupported == true -> "VALIDATED_CACHE"+ shouldTryBulk && learnedState?.bulkLiveSupported == false -> "STALE_UNSUPPORTED_REPROBE"+ !shouldTryBulk && learnedState?.bulkLiveCategoryFidelity == false -> "BULK_CATEGORY_FIDELITY_FAILED"+ !shouldTryBulk -> "BULK_KNOWN_UNSUPPORTED"+ else -> "CAPABILITY_PROBE"+ }+ )+ val streamResult = if (shouldTryBulk) {+ withBulkLiveStallTimeout { markBulkProgress ->+ api.streamLiveStreams { channel ->+ markBulkProgress()+ if (channel.categoryId != null && channel.categoryId in hiddenLiveCategoryIds) return@streamLiveStreams+ if (channel.categoryId != null) bulkRowsWithResolvedCategories+++ batch += channel+ if (batch.size >= FALLBACK_STAGE_BATCH_SIZE) {+ flushBatch()+ progress(provider.id, onProgress, "Loading live channels... $acceptedCount imported")+ }+ }+ }+ } else null+ when (streamResult) {+ is Result.Success -> {+ flushBatch()+ api.recordBulkLiveCapability(true, acceptedCount == 0 || bulkRowsWithResolvedCategories > 0)+ return finalizeStagedImport()+ }+ is Result.Error -> {+ if (isDefinitiveBulkLiveFailure(streamResult.exception)) api.recordBulkLiveCapability(false)+ val diagnostic = stalkerCatalogAccessDiagnostic(api, categoriesErrorMessage.orEmpty(), streamResult.message)+ bulkFailure = IllegalStateException(+ buildString {+ append(streamResult.message.ifBlank { "Failed to load live channels" })+ diagnostic?.let { append(' ').append(it) }+ },+ streamResult.exception+ )+ }+ is Result.Loading -> throw IllegalStateException("Unexpected loading state")+ null -> {+ bulkFailure = IOException("Bulk live request timed out; switching to category requests.")+ progress(provider.id, onProgress, "Bulk live request is slow; loading categories instead...")+ }+ }++ stagedSessionId?.let { syncCatalogStore.discardStagedImport(provider.id, it) }+ stagedSessionId = null+ acceptedCount = 0+ batch.clear()+ seenStreamIds.clear()+ val fallbackCategories = preferredCategories.orEmpty()+ if (fallbackCategories.isEmpty()) {+ return StagedStalkerLiveCatalogResult(+ acceptedCount = 0,+ warnings = (warnings + listOfNotNull(+ "Live TV provider exposed no live channels; continuing with VOD and series only.",+ bulkFailure?.let { error -> sanitizeThrowableMessage(error) }?.takeIf { it.isNotBlank() }+ ?.let { "Live TV fetch returned no usable channels: $it" }+ )).distinct()+ )+ }+ Log.w(STALKER_EXECUTOR_TAG, "Stalker bulk live sync failed for provider ${provider.id}; falling back to category live fetches.", bulkFailure)+ warnings += "Bulk live request failed; recovered using per-category live fetches."+ val fallbackResult = fetchStalkerLiveChannelsByCategory(+ provider,+ api,+ fallbackCategories.map { XtreamCategory(it.categoryId.toString(), it.name, isAdult = it.isAdult) },+ onProgress+ )+ warnings += fallbackResult.warnings+ fallbackResult.channels.forEach { channel ->+ if (channel.categoryId != null && channel.categoryId in hiddenLiveCategoryIds) return@forEach+ batch += channel+ if (batch.size >= FALLBACK_STAGE_BATCH_SIZE) flushBatch()+ }+ flushBatch()+ return finalizeStagedImport()+ } catch (error: CancellationException) {+ stagedSessionId?.let { syncCatalogStore.discardStagedImport(provider.id, it) }+ throw error+ } catch (error: Exception) {+ stagedSessionId?.let { syncCatalogStore.discardStagedImport(provider.id, it) }+ throw error+ }+ }++ private suspend fun mergeHiddenChannelsIntoStaging(+ providerId: Long,+ sessionId: Long,+ hiddenLiveCategoryIds: Set<Long>+ ) {+ val hiddenChannels = channelDao.getByProviderSync(providerId)+ .filter { it.categoryId != null && it.categoryId in hiddenLiveCategoryIds }+ if (hiddenChannels.isNotEmpty()) syncCatalogStore.stageChannelBatch(providerId, sessionId, hiddenChannels)+ }++ private suspend fun fetchStalkerLiveChannelsByCategory(+ provider: Provider,+ api: StalkerProvider,+ categories: List<XtreamCategory>,+ onProgress: ((String) -> Unit)?+ ): StalkerLiveCategoryLoadResult {+ if (categories.isEmpty()) return StalkerLiveCategoryLoadResult(emptyList())+ val runtimeProfile = CatalogSyncRuntimeProfile.from(applicationContext)+ val concurrency = minOf(categories.size, runtimeProfile.maxCategoryConcurrency, STALKER_MAX_PARALLEL_CATEGORY_FETCHES).coerceAtLeast(1)+ val executionPlan = categoryRecoverySupport.executeCategoryRecoveryPlan(+ provider = provider,+ categories = categories,+ initialConcurrency = concurrency,+ sectionLabel = "Live TV",+ sequentialModeWarning = LIVE_CATEGORY_SEQUENTIAL_MODE_WARNING,+ onProgress = onProgress,+ fetch = { category -> fetchStalkerLiveCategoryOutcome(api, category) }+ )+ var timedOutcomes = executionPlan.outcomes+ val categoryOutcomes = timedOutcomes.map { it.outcome }+ val failureCount = timedOutcomes.count { it.outcome is CategoryFetchOutcome.Failure }+ val fastFailureCount = timedOutcomes.count { it.elapsedMs <= 5_000L && it.outcome is CategoryFetchOutcome.Failure }+ val downgradeRecommended = catalogStrategySupport.shouldDowngradeCategorySync(categories.size, failureCount, fastFailureCount, categoryOutcomes)+ var warnings = executionPlan.warnings.toMutableList()+ if (concurrency > 1 && catalogStrategySupport.shouldRetryFailedCategories(+ categories.size,+ failureCount,+ downgradeRecommended,+ categoryOutcomes+ )+ ) {+ val failedRetryTotal = timedOutcomes.count { it.outcome is CategoryFetchOutcome.Failure }+ progress(provider.id, onProgress, "Retrying failed Live TV categories 0/$failedRetryTotal...")+ timedOutcomes = categoryRecoverySupport.continueFailedCategoryOutcomes(+ provider,+ timedOutcomes,+ fetchSequentially = { category -> fetchStalkerLiveCategoryOutcome(api, category) },+ onCategoryRetried = { completed, total, _ ->+ progress(provider.id, onProgress, "Retrying failed Live TV categories $completed/$total...")+ }+ )+ if (downgradeRecommended) warnings += LIVE_CATEGORY_SEQUENTIAL_MODE_WARNING+ }+ val finalOutcomes = timedOutcomes.map { it.outcome }+ val channels = finalOutcomes.filterIsInstance<CategoryFetchOutcome.Success<Channel>>()+ .flatMap { it.items }.distinctBy { it.streamId }+ val outcomeWarnings = finalOutcomes.filterIsInstance<CategoryFetchOutcome.Failure>()+ .map { categoryFailureWarning("Live TV", it.categoryName, it.error) }+ return StalkerLiveCategoryLoadResult(channels, (outcomeWarnings + warnings).distinct())+ }++ private suspend fun fetchStalkerLiveCategoryOutcome(+ api: StalkerProvider,+ category: XtreamCategory+ ): TimedCategoryOutcome<Channel> {+ val startedAt = System.currentTimeMillis()+ val outcome = try {+ val categoryId = category.categoryId.toLongOrNull()+ ?: throw IllegalArgumentException("Invalid Stalker live category id '${category.categoryId}'")+ val channels = requireResult(api.getLiveStreams(categoryId), "Failed to load live channels for ${category.categoryName}")+ .distinctBy { it.streamId }+ if (channels.isEmpty()) CategoryFetchOutcome.Empty(category.categoryName)+ else CategoryFetchOutcome.Success(category.categoryName, channels, channels.size)+ } catch (error: CancellationException) {+ throw error+ } catch (error: Throwable) {+ CategoryFetchOutcome.Failure(category.categoryName, error)+ }+ return TimedCategoryOutcome(category, outcome, System.currentTimeMillis() - startedAt)+ }++ private suspend fun <T> withBulkLiveStallTimeout(block: suspend (() -> Unit) -> T): T? = coroutineScope {+ val lastProgressAt = AtomicLong(System.currentTimeMillis())+ val streamDeferred = async { block { lastProgressAt.set(System.currentTimeMillis()) } }+ val watchdog = launch {+ while (isActive) {+ delay(STALKER_BULK_LIVE_STALL_CHECK_INTERVAL_MILLIS)+ if (System.currentTimeMillis() - lastProgressAt.get() >= STALKER_BULK_LIVE_STALL_TIMEOUT_MILLIS) {+ streamDeferred.cancel()+ break+ }+ }+ }+ try {+ try {+ streamDeferred.await()+ } catch (cancelled: CancellationException) {+ if (!isActive) throw cancelled+ null+ }+ } finally {+ watchdog.cancel()+ streamDeferred.cancel()+ }+ }++ private fun isDefinitiveBulkLiveFailure(error: Throwable?): Boolean = when (error) {+ is StalkerApiError.Authorization,+ is StalkerApiError.ModelRejected,+ is StalkerApiError.AccountBlocked,+ is StalkerApiError.Malformed,+ is StalkerApiError.ResponseTooLarge,+ is StalkerApiError.CatalogTruncated,+ is StalkerApiError.BlockedOrConfiguration -> true+ else -> false+ }++ private suspend fun stalkerCatalogAccessDiagnostic(+ api: StalkerProvider,+ primaryMessage: String,+ fallbackMessage: String?+ ): String? {+ if (!isStalkerEmptyResponse(primaryMessage) || !isStalkerEmptyResponse(fallbackMessage)) return null+ val profile = when (val result = api.getAccountProfile()) {+ is Result.Success -> result.data+ else -> return null+ }+ if (profile.ambiguousState) {+ return "Portal profile is ambiguous; playback/session validation failed. Check that the MAC is activated and that this portal supports MAG-style playback for the assigned account."+ }+ if (profile.authAccess == false &&+ (profile.accountId?.trim().orEmpty().isBlank() || profile.accountId?.trim() == "0") &&+ (profile.accountName?.trim().orEmpty().isBlank() || profile.accountName?.trim() == "0")+ ) {+ return "Portal authenticated, but the returned Stalker profile indicates this account has no accessible catalog data. Check that the MAC is activated and assigned a live/VOD package on the provider side."+ }+ return null+ }++ private fun isStalkerEmptyResponse(message: String?): Boolean =+ !message.isNullOrBlank() && message.contains("empty response", ignoreCase = true)++ private fun <T> requireResult(result: Result<T>, fallbackMessage: String): T = when (result) {+ is Result.Success -> result.data+ is Result.Error -> throw IllegalStateException(result.message.ifBlank { fallbackMessage }, result.exception)+ is Result.Loading -> throw IllegalStateException("Unexpected loading state")+ }++ private data class StalkerLiveCategoryLoadResult(+ val channels: List<Channel>,+ val warnings: List<String> = emptyList()+ )++ private data class StagedStalkerLiveCatalogResult(+ val acceptedCount: Int,+ val warnings: List<String> = emptyList()+ )+}diff --git a/data/src/main/java/com/streamvault/data/sync/StalkerIncrementalIndexExecutor.kt b/data/src/main/java/com/streamvault/data/sync/StalkerIncrementalIndexExecutor.ktnew file mode 100644index 00000000..cc070c14--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/StalkerIncrementalIndexExecutor.kt@@ -0,0 +1,889 @@+package com.streamvault.data.sync++import com.streamvault.data.local.entity.CategoryEntity+import com.streamvault.data.local.entity.StalkerIndexJobEntity+import com.streamvault.data.remote.stalker.StalkerPagedResult+import com.streamvault.data.remote.stalker.StalkerProvider+import com.streamvault.data.remote.stalker.StalkerTelemetry+import com.streamvault.data.remote.stalker.StalkerTrafficCoordinator+import com.streamvault.data.remote.stalker.StalkerVodCatalogItem+import com.streamvault.domain.model.CatalogLayout+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.LegacyProvider as Provider+import com.streamvault.domain.model.Movie+import com.streamvault.domain.model.Result+import com.streamvault.domain.model.Series+import com.streamvault.domain.model.VodCatalogItem+import kotlinx.coroutines.async+import kotlinx.coroutines.awaitAll+import kotlinx.coroutines.coroutineScope+import kotlinx.coroutines.delay+import java.util.Locale+import kotlin.math.min++private const val STALKER_INCREMENTAL_WILDCARD_PAGE_SLICE_SIZE = 192+private const val STALKER_INCREMENTAL_MAX_PARALLEL_CATEGORY_FETCHES = 2+private const val STALKER_INCREMENTAL_MAX_SECTION_RUN_MILLIS = 240_000L+private const val TAG = "StalkerIncrementalIndexExecutor"++/**+ * Narrow port used by [StalkerIncrementalIndexExecutor]. The executor owns the incremental+ * summary/wildcard state machine; the port keeps persistence, transport recovery, and catalog+ * writes in the existing data-layer collaborators until those concerns can be split further.+ */+internal interface StalkerIncrementalIndexOperations {+ val runtimeProfile: CatalogSyncRuntimeProfile++ suspend fun allVisibleCategories(providerId: Long, contentType: ContentType): List<CategoryEntity>++ suspend fun visibleCategories(+ contentType: ContentType,+ categories: List<CategoryEntity>,+ api: StalkerProvider+ ): List<CategoryEntity>++ suspend fun getJob(providerId: Long, contentType: ContentType): StalkerIndexJobEntity?++ suspend fun getHydration(+ providerId: Long,+ contentType: ContentType,+ categoryId: Long+ ): StalkerHydrationSnapshot?++ suspend fun currentIndexedRowCount(providerId: Long, contentType: ContentType): Int++ suspend fun pruneStaleRows(providerId: Long, contentType: ContentType): Int++ suspend fun updateSummaryMetadata(+ providerId: Long,+ contentType: ContentType,+ indexedRows: Int,+ finalState: String,+ now: Long+ )++ suspend fun fetchSummaryPage(+ provider: Provider,+ api: StalkerProvider,+ contentType: ContentType,+ categoryId: Long,+ page: Int+ ): Result<StalkerPagedResult<out Any>>++ suspend fun fetchWildcardPage(+ provider: Provider,+ api: StalkerProvider,+ contentType: ContentType,+ categoryId: Long,+ page: Int+ ): Result<StalkerPagedResult<out Any>>++ suspend fun markAttemptStarted(+ providerId: Long,+ contentType: ContentType,+ categoryId: Long,+ hydration: StalkerHydrationSnapshot?,+ attemptedPage: Int,+ now: Long+ )++ suspend fun markAttemptSucceeded(+ providerId: Long,+ contentType: ContentType,+ categoryId: Long,+ hydration: StalkerHydrationSnapshot?,+ attemptedPage: Int,+ now: Long,+ itemCount: Int,+ totalPages: Int,+ pageSize: Int,+ advertisedTotalItems: Int?,+ advertisedTotalPages: Int?,+ pageComplete: Boolean,+ truncated: Boolean,+ terminationReason: String?,+ pageFingerprint: String?+ )++ suspend fun markAttemptFailed(+ providerId: Long,+ contentType: ContentType,+ categoryId: Long,+ hydration: StalkerHydrationSnapshot?,+ attemptedPage: Int,+ now: Long,+ message: String,+ retryable: Boolean,+ pageFingerprint: String?+ )++ suspend fun upsertMovieSummaryBatch(+ providerId: Long,+ movies: List<Movie>,+ indexedAt: Long+ )++ suspend fun upsertSeriesSummaryBatch(+ providerId: Long,+ series: List<Series>,+ indexedAt: Long+ )++ suspend fun upsertVodDerivedSeriesSummaryBatch(+ providerId: Long,+ series: List<Series>,+ indexedAt: Long+ )++ suspend fun recordRequestFailure(providerId: Long, error: Throwable?)++ fun failureState(error: Throwable): String++ fun progress(providerId: Long, callback: ((String) -> Unit)?, message: String)++ suspend fun restoreMovieWatchProgress(providerId: Long)++ suspend fun upsertJob(update: CatalogIndexJobUpdate)++ fun log(message: String)+}++/**+ * Runs the durable, incremental Stalker movie/series index sections.+ *+ * This is intentionally separate from [StalkerIndexContinuationCoordinator]: that collaborator+ * chooses and schedules sections, while this class owns page fetching, retry decisions, anomaly+ * handling, and page-level catalog commits.+ */+internal class StalkerIncrementalIndexExecutor(+ private val operations: StalkerIncrementalIndexOperations+) {+ suspend fun processSummary(+ provider: Provider,+ api: StalkerProvider,+ contentType: ContentType,+ maxCategories: Int,+ onProgress: ((String) -> Unit)?+ ) {+ require(contentType == ContentType.MOVIE || contentType == ContentType.SERIES) {+ "Unsupported Stalker summary index section: $contentType"+ }+ val now = System.currentTimeMillis()+ val allVisibleCategories = operations.allVisibleCategories(provider.id, contentType)+ val visibleCategories = operations.visibleCategories(contentType, allVisibleCategories, api)+ val wildcardCategory = allVisibleCategories.firstOrNull { category ->+ api.isWildcardCategory(contentType, category.categoryId)+ }+ if (visibleCategories.isEmpty()) {+ val deletedRows = operations.pruneStaleRows(provider.id, contentType)+ val indexedRows = operations.currentIndexedRowCount(provider.id, contentType)+ upsertIndexJob(+ providerId = provider.id,+ section = contentType.name,+ state = "SUCCESS",+ now = now,+ totalCategories = 0,+ completedCategories = 0,+ nextCategoryIndex = 0,+ failedCategories = 0,+ indexedRows = indexedRows,+ deletedPrunedRows = deletedRows,+ clearPriority = true,+ lastAttemptAt = now,+ lastSuccessAt = now,+ lastError = null+ )+ operations.updateSummaryMetadata(provider.id, contentType, indexedRows, "SUCCESS", now)+ return+ }++ val initialJob = operations.getJob(provider.id, contentType)+ val learnedWildcardSupport = api.validatedPortalState()?.let { state ->+ when (contentType) {+ ContentType.MOVIE -> state.movieWildcardSupported+ ContentType.SERIES -> state.seriesWildcardSupported+ else -> null+ }+ }+ if (+ wildcardCategory != null &&+ learnedWildcardSupport != false &&+ visibleCategories.size == 1 &&+ visibleCategories.first().categoryId == wildcardCategory.categoryId+ ) {+ StalkerTelemetry.strategySelected(+ provider.id,+ "${contentType.name}_WILDCARD",+ if (learnedWildcardSupport == true) "VALIDATED_CACHE" else "CAPABILITY_PROBE"+ )+ if (processWildcard(+ provider = provider,+ api = api,+ contentType = contentType,+ wildcardCategory = wildcardCategory,+ visibleCategories = allVisibleCategories,+ maxPages = STALKER_INCREMENTAL_WILDCARD_PAGE_SLICE_SIZE,+ initialJob = initialJob,+ onProgress = onProgress+ )) {+ api.recordWildcardCapability(contentType, supported = true)+ return+ }+ } else if (wildcardCategory != null && learnedWildcardSupport == false) {+ StalkerTelemetry.strategySelected(provider.id, "${contentType.name}_CATEGORY", "WILDCARD_KNOWN_UNSUPPORTED")+ }++ val hydrationByCategory = visibleCategories.associate { category ->+ category.categoryId to operations.getHydration(provider.id, contentType, category.categoryId)+ }+ val completedBefore = hydrationByCategory.values.count { it?.isComplete == true }+ val failedBefore = hydrationByCategory.values.count { it?.isTerminalFailure == true }+ val indexedBefore = operations.currentIndexedRowCount(provider.id, contentType)+ upsertIndexJob(+ providerId = provider.id,+ section = contentType.name,+ state = "RUNNING",+ now = now,+ totalCategories = visibleCategories.size,+ completedCategories = completedBefore,+ failedCategories = failedBefore,+ indexedRows = indexedBefore,+ lastAttemptAt = now,+ lastError = null+ )++ var restoreMovieWatchProgressPending = false+ try {+ val pending = buildList {+ visibleCategories.forEach { category ->+ if (size >= maxCategories) return@forEach+ val hydration = hydrationByCategory[category.categoryId]+ if (!canAttempt(hydration, now)) return@forEach+ add(category)+ }+ }++ data class CategoryFetchAttempt(+ val category: CategoryEntity,+ val hydration: StalkerHydrationSnapshot?,+ val nextPage: Int+ )++ data class CategoryFetchResult(+ val attempt: CategoryFetchAttempt,+ val result: Result<StalkerPagedResult<out Any>>+ )++ data class SuccessfulPage(+ val category: CategoryEntity,+ val hydration: StalkerHydrationSnapshot?,+ val requestedPage: Int,+ val items: List<Any>,+ val totalPages: Int,+ val pageSize: Int,+ val advertisedTotalItems: Int?,+ val advertisedTotalPages: Int?,+ val isComplete: Boolean,+ val isTruncated: Boolean,+ val terminationReason: String?,+ val pageFingerprint: String?+ )++ var clearPriority = false+ var skippedMalformedRows = initialJob?.skippedMalformedRows ?: 0+ var pagesCommitted = 0+ var rowsCommitted = 0+ val sectionStartedAt = System.currentTimeMillis()+ val parallelFetchLimit = categoryFetchConcurrencyLimit(provider, maxCategories)+ val runDeadlineAt = System.currentTimeMillis() + STALKER_INCREMENTAL_MAX_SECTION_RUN_MILLIS+ val pendingQueue = ArrayDeque(pending)+ var forceSequential = parallelFetchLimit <= 1+ val retriedImmediately = mutableSetOf<Long>()+ while (pendingQueue.isNotEmpty() && System.currentTimeMillis() < runDeadlineAt) {+ if (pagesCommitted > 0) {+ delay(StalkerTrafficCoordinator.backgroundInterPageDelayMillis(provider.id))+ }+ val windowSize = minOf(+ if (forceSequential) 1 else parallelFetchLimit,+ pendingQueue.size+ )+ val window = buildList {+ repeat(windowSize) { add(pendingQueue.removeFirst()) }+ }+ val attempts = window.mapNotNull { category ->+ val hydration = operations.getHydration(provider.id, contentType, category.categoryId)+ if (!canAttempt(hydration, System.currentTimeMillis())) return@mapNotNull null+ val nextPage = nextAttemptPage(hydration)+ operations.progress(+ provider.id,+ onProgress,+ "Indexing ${indexSectionLabel(contentType)}: ${category.name} page $nextPage"+ )+ operations.markAttemptStarted(+ providerId = provider.id,+ contentType = contentType,+ categoryId = category.categoryId,+ hydration = hydration,+ attemptedPage = nextPage,+ now = System.currentTimeMillis()+ )+ CategoryFetchAttempt(category, hydration, nextPage)+ }+ if (attempts.isEmpty()) continue+ val fetchedResults = coroutineScope {+ attempts.map { attempt ->+ async {+ CategoryFetchResult(+ attempt = attempt,+ result = operations.fetchSummaryPage(+ provider = provider,+ api = api,+ contentType = contentType,+ categoryId = attempt.category.categoryId,+ page = attempt.nextPage+ )+ )+ }+ }.awaitAll()+ }++ var windowRetryableFailures = 0+ val successfulPages = mutableListOf<SuccessfulPage>()+ for (fetched in fetchedResults) {+ val category = fetched.attempt.category+ val hydration = fetched.attempt.hydration+ val nextPage = fetched.attempt.nextPage+ if (fetched.result is Result.Error) {+ operations.recordRequestFailure(provider.id, fetched.result.exception)+ }+ when (val result = fetched.result) {+ is Result.Success -> {+ val pageFingerprint = StalkerIndexPolicy.pageFingerprint(result.data.items, contentType)+ val anomaly = StalkerIndexPolicy.detectPageAnomaly(+ hydration = hydration,+ requestedPage = nextPage,+ pagedResult = result.data,+ pageFingerprint = pageFingerprint+ )+ if (anomaly != null) {+ val indexedAt = System.currentTimeMillis()+ skippedMalformedRows += result.data.items.size+ val shouldRetryImmediately = category.categoryId !in retriedImmediately &&+ ((hydration?.failureCount ?: 0) == 0)+ operations.markAttemptFailed(+ providerId = provider.id,+ contentType = contentType,+ categoryId = category.categoryId,+ hydration = hydration,+ attemptedPage = nextPage,+ now = indexedAt,+ message = anomaly,+ retryable = true,+ pageFingerprint = pageFingerprint+ )+ if (shouldRetryImmediately) {+ retriedImmediately += category.categoryId+ pendingQueue.addLast(category)+ }+ upsertIndexJob(+ providerId = provider.id,+ section = contentType.name,+ state = "RUNNING",+ now = indexedAt,+ skippedMalformedRows = skippedMalformedRows,+ lastAttemptAt = indexedAt,+ lastError = anomaly+ )+ continue+ }+ val dedupedItems = StalkerIndexPolicy.dedupePageItems(result.data.items, contentType)+ skippedMalformedRows += (result.data.items.size - dedupedItems.size).coerceAtLeast(0)+ successfulPages += SuccessfulPage(+ category = category,+ hydration = hydration,+ requestedPage = nextPage,+ items = dedupedItems,+ totalPages = result.data.totalPages,+ pageSize = result.data.pageSize,+ advertisedTotalItems = result.data.advertisedTotalItems,+ advertisedTotalPages = result.data.advertisedTotalPages,+ isComplete = result.data.isComplete,+ isTruncated = result.data.isTruncated,+ terminationReason = result.data.terminationReason,+ pageFingerprint = pageFingerprint+ )+ }+ is Result.Error -> {+ val failedAt = System.currentTimeMillis()+ val retryable = operations.failureState(+ result.exception ?: IllegalStateException(result.message)+ ) != "FAILED_PERMANENT"+ if (retryable) windowRetryableFailures += 1+ val shouldRetryImmediately = retryable &&+ category.categoryId !in retriedImmediately &&+ ((hydration?.failureCount ?: 0) == 0)+ operations.markAttemptFailed(+ providerId = provider.id,+ contentType = contentType,+ categoryId = category.categoryId,+ hydration = hydration,+ attemptedPage = nextPage,+ now = failedAt,+ message = result.message,+ retryable = retryable,+ pageFingerprint = hydration?.lastPageFingerprint+ )+ if (shouldRetryImmediately) {+ retriedImmediately += category.categoryId+ pendingQueue.addLast(category)+ }+ if (!retryable) throw IllegalStateException(result.message, result.exception)+ upsertIndexJob(+ providerId = provider.id,+ section = contentType.name,+ state = "RUNNING",+ now = failedAt,+ skippedMalformedRows = skippedMalformedRows,+ lastAttemptAt = now,+ lastError = result.message+ )+ }+ is Result.Loading -> Unit+ }+ }+ if (successfulPages.isNotEmpty()) {+ val indexedAt = System.currentTimeMillis()+ when (contentType) {+ ContentType.MOVIE -> {+ val rawItems = successfulPages.flatMap { page -> page.items }+ val classified = rawItems.filterIsInstance<StalkerVodCatalogItem>()+ val movies = if (classified.isEmpty()) {+ rawItems.filterIsInstance<Movie>()+ } else {+ classified.mapNotNull { (it.item as? VodCatalogItem.MovieItem)?.movie }+ }+ operations.upsertMovieSummaryBatch(provider.id, movies, indexedAt)+ if (classified.isNotEmpty()) {+ operations.upsertVodDerivedSeriesSummaryBatch(+ provider.id,+ classified.mapNotNull { (it.item as? VodCatalogItem.SeriesItem)?.series },+ indexedAt+ )+ }+ }+ ContentType.SERIES -> operations.upsertSeriesSummaryBatch(+ provider.id,+ successfulPages.flatMap { page -> page.items.filterIsInstance<Series>() },+ indexedAt+ )+ else -> Unit+ }+ if (contentType == ContentType.MOVIE) restoreMovieWatchProgressPending = true+ for (page in successfulPages) {+ pagesCommitted += 1+ rowsCommitted += page.items.size+ val pageComplete = !page.isTruncated && (+ page.isComplete || (page.items.isEmpty() && page.totalPages in 1..page.requestedPage)+ )+ val categoryCount = (page.hydration?.itemCount ?: 0) + page.items.size+ operations.markAttemptSucceeded(+ providerId = provider.id,+ contentType = contentType,+ categoryId = page.category.categoryId,+ hydration = page.hydration,+ attemptedPage = page.requestedPage,+ now = indexedAt,+ itemCount = categoryCount,+ totalPages = page.totalPages,+ pageSize = page.pageSize,+ advertisedTotalItems = page.advertisedTotalItems,+ advertisedTotalPages = page.advertisedTotalPages,+ pageComplete = pageComplete,+ truncated = page.isTruncated,+ terminationReason = page.terminationReason,+ pageFingerprint = page.pageFingerprint+ )+ if (!pageComplete && !page.isTruncated && System.currentTimeMillis() < runDeadlineAt) {+ pendingQueue.addLast(page.category)+ }+ }+ }+ if (!forceSequential && windowRetryableFailures >= minOf(2, attempts.size)) {+ forceSequential = true+ operations.log(+ "Stalker ${contentType.name} category fetch downgraded to sequential mode for provider ${provider.id} after retryable parallel failures."+ )+ }+ }++ val refreshedHydration = visibleCategories.associate { category ->+ category.categoryId to operations.getHydration(provider.id, contentType, category.categoryId)+ }+ val finishedAt = System.currentTimeMillis()+ val completedCategories = refreshedHydration.values.count { it?.isComplete == true }+ val failedCategories = refreshedHydration.values.count { it?.isTerminalFailure == true }+ val truncatedCategories = refreshedHydration.values.count { it?.isTruncated == true }+ val hasMoreCategories = refreshedHydration.values.any { hydration -> canAttempt(hydration, finishedAt) }+ val retryDelaySeconds = StalkerIndexPolicy.nextRetryDelaySeconds(refreshedHydration.values, finishedAt)+ val indexedRows = operations.currentIndexedRowCount(provider.id, contentType)+ val pruneSuppressed = refreshedHydration.values.any { hydration ->+ hydration?.hasPruneSuppressionRisk == true+ }+ val deletedRows = if (!hasMoreCategories && failedCategories == 0 && !pruneSuppressed) {+ operations.pruneStaleRows(provider.id, contentType)+ } else {+ 0+ }+ val finalState = when {+ hasMoreCategories -> "QUEUED"+ truncatedCategories > 0 -> "TRUNCATED"+ failedCategories > 0 -> "PARTIAL"+ pruneSuppressed -> "PARTIAL"+ else -> "SUCCESS"+ }+ upsertIndexJob(+ providerId = provider.id,+ section = contentType.name,+ state = finalState,+ now = finishedAt,+ totalCategories = visibleCategories.size,+ completedCategories = completedCategories,+ nextCategoryIndex = completedCategories,+ failedCategories = failedCategories,+ indexedRows = indexedRows,+ skippedMalformedRows = skippedMalformedRows,+ deletedPrunedRows = deletedRows,+ clearPriority = clearPriority || finalState in setOf("SUCCESS", "TRUNCATED"),+ lastAttemptAt = now,+ lastSuccessAt = finishedAt.takeIf { finalState == "SUCCESS" },+ lastError = refreshedHydration.values.firstOrNull {+ it?.lastStatus in setOf("ERROR", "TRUNCATED")+ }?.lastError+ )+ operations.updateSummaryMetadata(provider.id, contentType, indexedRows, finalState, finishedAt)+ operations.log(+ "Stalker ${contentType.name} indexing finished for provider ${provider.id}: state=$finalState completed=$completedCategories failed=$failedCategories rows=$indexedRows committedPages=$pagesCommitted committedRows=$rowsCommitted throughput=${throughputSummary(sectionStartedAt, pagesCommitted, rowsCommitted)} retryDelay=${retryDelaySeconds}s"+ )+ } finally {+ if (contentType == ContentType.MOVIE && restoreMovieWatchProgressPending) {+ operations.restoreMovieWatchProgress(provider.id)+ }+ }+ }++ private suspend fun processWildcard(+ provider: Provider,+ api: StalkerProvider,+ contentType: ContentType,+ wildcardCategory: CategoryEntity,+ visibleCategories: List<CategoryEntity>,+ maxPages: Int,+ initialJob: StalkerIndexJobEntity?,+ onProgress: ((String) -> Unit)?+ ): Boolean {+ val now = System.currentTimeMillis()+ val normalVisibleCategoryIds = mutableSetOf<Long>()+ visibleCategories.forEach { category ->+ if (!api.isWildcardCategory(contentType, category.categoryId)) {+ normalVisibleCategoryIds += category.categoryId+ }+ }+ val visibleCategoryIds = normalVisibleCategoryIds.takeIf { it.isNotEmpty() }+ val hydration = operations.getHydration(provider.id, contentType, wildcardCategory.categoryId)+ if (!canAttempt(hydration, now)) return false++ upsertIndexJob(+ providerId = provider.id,+ section = contentType.name,+ state = "RUNNING",+ now = now,+ totalCategories = visibleCategories.size,+ completedCategories = 0,+ failedCategories = 0,+ indexedRows = operations.currentIndexedRowCount(provider.id, contentType),+ lastAttemptAt = now,+ lastError = null+ )++ var skippedMalformedRows = initialJob?.skippedMalformedRows ?: 0+ val seenPageFingerprints = mutableSetOf<String>()+ var pagesProcessed = 0+ var rowsCommitted = 0+ var lastError: String? = null+ var restoreMovieWatchProgressPending = false+ var indexedRowsEstimate = operations.currentIndexedRowCount(provider.id, contentType)+ val sectionStartedAt = System.currentTimeMillis()++ try {+ while (pagesProcessed < maxPages) {+ if (pagesProcessed > 0) {+ delay(StalkerTrafficCoordinator.backgroundInterPageDelayMillis(provider.id))+ }+ val currentHydration = operations.getHydration(provider.id, contentType, wildcardCategory.categoryId)+ if (!canAttempt(currentHydration, System.currentTimeMillis())) break+ val nextPage = nextAttemptPage(currentHydration)+ operations.progress(provider.id, onProgress, "Indexing ${indexSectionLabel(contentType)}: All page $nextPage")+ operations.markAttemptStarted(+ providerId = provider.id,+ contentType = contentType,+ categoryId = wildcardCategory.categoryId,+ hydration = currentHydration,+ attemptedPage = nextPage,+ now = System.currentTimeMillis()+ )+ val coordinatedResult = operations.fetchWildcardPage(+ provider = provider,+ api = api,+ contentType = contentType,+ categoryId = wildcardCategory.categoryId,+ page = nextPage+ )+ if (coordinatedResult is Result.Error) {+ operations.recordRequestFailure(provider.id, coordinatedResult.exception)+ }+ when (val result = coordinatedResult) {+ is Result.Success -> {+ val indexedAt = System.currentTimeMillis()+ val dedupedItems = StalkerIndexPolicy.dedupePageItems(result.data.items, contentType)+ val visibleItems = StalkerIndexPolicy.filterToVisibleCategories(+ dedupedItems,+ contentType,+ visibleCategoryIds+ )+ skippedMalformedRows += (result.data.items.size - visibleItems.size).coerceAtLeast(0)+ if (nextPage == 1 && visibleItems.isEmpty()) {+ val message = "Stalker wildcard catalog did not return usable visible ${indexSectionLabel(contentType)} rows."+ operations.markAttemptFailed(+ providerId = provider.id,+ contentType = contentType,+ categoryId = wildcardCategory.categoryId,+ hydration = currentHydration,+ attemptedPage = nextPage,+ now = indexedAt,+ message = message,+ retryable = false,+ pageFingerprint = null+ )+ operations.log("$message Falling back to per-category indexing for provider ${provider.id}.")+ api.recordWildcardCapability(contentType, supported = false)+ return false+ }++ val pageFingerprint = StalkerIndexPolicy.pageFingerprint(visibleItems, contentType)+ val anomaly = StalkerIndexPolicy.detectPageAnomaly(+ hydration = currentHydration,+ requestedPage = nextPage,+ pagedResult = StalkerPagedResult(+ items = visibleItems,+ page = result.data.page,+ totalPages = result.data.totalPages,+ pageSize = result.data.pageSize,+ advertisedTotalItems = result.data.advertisedTotalItems,+ advertisedTotalPages = result.data.advertisedTotalPages,+ hasAdvertisedTotal = result.data.hasAdvertisedTotal,+ isTruncated = result.data.isTruncated,+ terminationReason = result.data.terminationReason+ ),+ pageFingerprint = pageFingerprint+ ) ?: pageFingerprint+ ?.takeIf { !seenPageFingerprints.add(it) }+ ?.let { "Portal repeated a wildcard page payload." }++ if (anomaly != null) {+ operations.markAttemptFailed(+ providerId = provider.id,+ contentType = contentType,+ categoryId = wildcardCategory.categoryId,+ hydration = currentHydration,+ attemptedPage = nextPage,+ now = indexedAt,+ message = anomaly,+ retryable = false,+ pageFingerprint = pageFingerprint+ )+ operations.log("Stalker wildcard ${contentType.name} indexing disabled for provider ${provider.id}: $anomaly")+ api.recordWildcardCapability(contentType, supported = false)+ return false+ }++ when (contentType) {+ ContentType.MOVIE -> operations.upsertMovieSummaryBatch(+ provider.id,+ visibleItems.filterIsInstance<Movie>(),+ indexedAt+ )+ ContentType.SERIES -> operations.upsertSeriesSummaryBatch(+ provider.id,+ visibleItems.filterIsInstance<Series>(),+ indexedAt+ )+ else -> Unit+ }+ if (contentType == ContentType.MOVIE && visibleItems.isNotEmpty()) {+ restoreMovieWatchProgressPending = true+ }+ indexedRowsEstimate += visibleItems.size+ rowsCommitted += visibleItems.size+ val pageComplete = !result.data.isTruncated && (+ result.data.isComplete ||+ (result.data.items.isEmpty() && result.data.totalPages in 1..nextPage)+ )+ operations.markAttemptSucceeded(+ providerId = provider.id,+ contentType = contentType,+ categoryId = wildcardCategory.categoryId,+ hydration = currentHydration,+ attemptedPage = nextPage,+ now = indexedAt,+ itemCount = indexedRowsEstimate,+ totalPages = result.data.totalPages,+ pageSize = result.data.pageSize,+ advertisedTotalItems = result.data.advertisedTotalItems,+ advertisedTotalPages = result.data.advertisedTotalPages,+ pageComplete = pageComplete,+ truncated = result.data.isTruncated,+ terminationReason = result.data.terminationReason,+ pageFingerprint = pageFingerprint+ )+ pagesProcessed += 1+ if (pageComplete || result.data.isTruncated) break+ }+ is Result.Error -> {+ val failedAt = System.currentTimeMillis()+ lastError = result.message+ val retryable = operations.failureState(+ result.exception ?: IllegalStateException(result.message)+ ) != "FAILED_PERMANENT"+ operations.markAttemptFailed(+ providerId = provider.id,+ contentType = contentType,+ categoryId = wildcardCategory.categoryId,+ hydration = currentHydration,+ attemptedPage = nextPage,+ now = failedAt,+ message = result.message,+ retryable = retryable,+ pageFingerprint = currentHydration?.lastPageFingerprint+ )+ api.recordWildcardCapability(contentType, supported = false)+ return false+ }+ is Result.Loading -> Unit+ }+ }++ val finishedAt = System.currentTimeMillis()+ val refreshedHydration = operations.getHydration(provider.id, contentType, wildcardCategory.categoryId)+ val hasMorePages = canAttempt(refreshedHydration, finishedAt)+ val indexedRows = operations.currentIndexedRowCount(provider.id, contentType)+ val finalState = when {+ hasMorePages -> "QUEUED"+ refreshedHydration?.isTruncated == true -> "TRUNCATED"+ refreshedHydration?.isTerminalFailure == true -> "PARTIAL"+ refreshedHydration?.hasPruneSuppressionRisk == true -> "PARTIAL"+ else -> "SUCCESS"+ }+ val deletedRows = if (finalState == "SUCCESS") {+ operations.pruneStaleRows(provider.id, contentType)+ } else {+ 0+ }+ upsertIndexJob(+ providerId = provider.id,+ section = contentType.name,+ state = finalState,+ now = finishedAt,+ totalCategories = visibleCategories.size,+ completedCategories = if (finalState == "SUCCESS") visibleCategories.size else 0,+ nextCategoryIndex = if (finalState in setOf("SUCCESS", "TRUNCATED")) visibleCategories.size else 0,+ failedCategories = if (finalState == "PARTIAL") 1 else 0,+ indexedRows = indexedRows,+ skippedMalformedRows = skippedMalformedRows,+ deletedPrunedRows = deletedRows,+ clearPriority = finalState in setOf("SUCCESS", "TRUNCATED"),+ lastAttemptAt = now,+ lastSuccessAt = finishedAt.takeIf { finalState == "SUCCESS" },+ lastError = lastError ?: refreshedHydration?.lastError+ )+ operations.updateSummaryMetadata(provider.id, contentType, indexedRows, finalState, finishedAt)+ operations.log(+ "Stalker wildcard ${contentType.name} indexing finished for provider ${provider.id}: state=$finalState pages=$pagesProcessed rows=$rowsCommitted totalRows=$indexedRows throughput=${throughputSummary(sectionStartedAt, pagesProcessed, rowsCommitted)}"+ )+ return true+ } finally {+ if (contentType == ContentType.MOVIE && restoreMovieWatchProgressPending) {+ operations.restoreMovieWatchProgress(provider.id)+ }+ }+ }++ private fun canAttempt(hydration: StalkerHydrationSnapshot?, now: Long): Boolean =+ StalkerIndexPolicy.canAttempt(hydration, now)++ private fun nextAttemptPage(hydration: StalkerHydrationSnapshot?): Int =+ StalkerIndexPolicy.nextAttemptPage(hydration)++ private fun categoryFetchConcurrencyLimit(provider: Provider, maxCategories: Int): Int =+ minOf(+ maxCategories.coerceAtLeast(1),+ operations.runtimeProfile.maxCategoryConcurrency.coerceAtLeast(1),+ STALKER_INCREMENTAL_MAX_PARALLEL_CATEGORY_FETCHES+ ).coerceAtLeast(1)++ private fun throughputSummary(startedAt: Long, pages: Int, rows: Int): String {+ val elapsedSeconds = ((System.currentTimeMillis() - startedAt).coerceAtLeast(1L)) / 1000.0+ return "%.2f pages/s, %.2f rows/s".format(+ Locale.US,+ pages / elapsedSeconds,+ rows / elapsedSeconds+ )+ }++ private suspend fun upsertIndexJob(+ providerId: Long,+ section: String,+ state: String,+ now: Long,+ totalCategories: Int? = null,+ completedCategories: Int? = null,+ nextCategoryIndex: Int? = null,+ failedCategories: Int? = null,+ indexedRows: Int? = null,+ skippedMalformedRows: Int? = null,+ deletedPrunedRows: Int? = null,+ priorityCategoryId: Long? = null,+ priorityRequestedAt: Long? = null,+ clearPriority: Boolean = false,+ lastAttemptAt: Long? = null,+ lastSuccessAt: Long? = null,+ lastError: String? = null+ ) {+ operations.upsertJob(+ CatalogIndexJobUpdate(+ providerId = providerId,+ section = section,+ state = state,+ now = now,+ totalCategories = totalCategories,+ completedCategories = completedCategories,+ nextCategoryIndex = nextCategoryIndex,+ failedCategories = failedCategories,+ indexedRows = indexedRows,+ skippedMalformedRows = skippedMalformedRows,+ deletedPrunedRows = deletedPrunedRows,+ priorityCategoryId = priorityCategoryId,+ priorityRequestedAt = priorityRequestedAt,+ clearPriority = clearPriority,+ lastAttemptAt = lastAttemptAt,+ lastSuccessAt = lastSuccessAt,+ lastError = lastError+ )+ )+ }++ private fun indexSectionLabel(contentType: ContentType): String = when (contentType) {+ ContentType.MOVIE -> "movies"+ ContentType.SERIES -> "series"+ else -> contentType.name.lowercase()+ }+}diff --git a/data/src/main/java/com/streamvault/data/sync/StalkerIncrementalIndexOperationsAdapter.kt b/data/src/main/java/com/streamvault/data/sync/StalkerIncrementalIndexOperationsAdapter.ktnew file mode 100644index 00000000..8c638605--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/StalkerIncrementalIndexOperationsAdapter.kt@@ -0,0 +1,206 @@+package com.streamvault.data.sync++import com.streamvault.data.local.entity.CategoryEntity+import com.streamvault.data.local.entity.StalkerIndexJobEntity+import com.streamvault.data.remote.stalker.StalkerPagedResult+import com.streamvault.data.remote.stalker.StalkerProvider+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.LegacyProvider as Provider+import com.streamvault.domain.model.Movie+import com.streamvault.domain.model.Result+import com.streamvault.domain.model.Series++internal data class StalkerIncrementalIndexCallbacks(+ val runtimeProfile: () -> CatalogSyncRuntimeProfile,+ val allVisibleCategories: suspend (Long, ContentType) -> List<CategoryEntity>,+ val visibleCategories: suspend (ContentType, List<CategoryEntity>, StalkerProvider) -> List<CategoryEntity>,+ val getJob: suspend (Long, ContentType) -> StalkerIndexJobEntity?,+ val getHydration: suspend (Long, ContentType, Long) -> StalkerHydrationSnapshot?,+ val currentIndexedRowCount: suspend (Long, ContentType) -> Int,+ val pruneStaleRows: suspend (Long, ContentType) -> Int,+ val updateSummaryMetadata: suspend (Long, ContentType, Int, String, Long) -> Unit,+ val fetchSummaryPage: suspend (Provider, StalkerProvider, ContentType, Long, Int) -> Result<StalkerPagedResult<out Any>>,+ val fetchWildcardPage: suspend (Provider, StalkerProvider, ContentType, Long, Int) -> Result<StalkerPagedResult<out Any>>,+ val markAttemptStarted: suspend (Long, ContentType, Long, StalkerHydrationSnapshot?, Int, Long) -> Unit,+ val markAttemptSucceeded: suspend (+ Long,+ ContentType,+ Long,+ StalkerHydrationSnapshot?,+ Int,+ Long,+ Int,+ Int,+ Int,+ Int?,+ Int?,+ Boolean,+ Boolean,+ String?,+ String?+ ) -> Unit,+ val markAttemptFailed: suspend (+ Long,+ ContentType,+ Long,+ StalkerHydrationSnapshot?,+ Int,+ Long,+ String,+ Boolean,+ String?+ ) -> Unit,+ val upsertMovieSummaryBatch: suspend (Long, List<Movie>, Long) -> Unit,+ val upsertSeriesSummaryBatch: suspend (Long, List<Series>, Long) -> Unit,+ val upsertVodDerivedSeriesSummaryBatch: suspend (Long, List<Series>, Long) -> Unit,+ val recordRequestFailure: suspend (Long, Throwable?) -> Unit,+ val failureState: (Throwable) -> String,+ val progress: (Long, ((String) -> Unit)?, String) -> Unit,+ val restoreMovieWatchProgress: suspend (Long) -> Unit,+ val upsertJob: suspend (CatalogIndexJobUpdate) -> Unit,+ val log: (String) -> Unit+)++internal class CallbackStalkerIncrementalIndexOperations(+ private val callbacks: StalkerIncrementalIndexCallbacks+) : StalkerIncrementalIndexOperations {+ override val runtimeProfile: CatalogSyncRuntimeProfile+ get() = callbacks.runtimeProfile()++ override suspend fun allVisibleCategories(providerId: Long, contentType: ContentType): List<CategoryEntity> =+ callbacks.allVisibleCategories(providerId, contentType)++ override suspend fun visibleCategories(+ contentType: ContentType,+ categories: List<CategoryEntity>,+ api: StalkerProvider+ ): List<CategoryEntity> = callbacks.visibleCategories(contentType, categories, api)++ override suspend fun getJob(providerId: Long, contentType: ContentType): StalkerIndexJobEntity? =+ callbacks.getJob(providerId, contentType)++ override suspend fun getHydration(+ providerId: Long,+ contentType: ContentType,+ categoryId: Long+ ): StalkerHydrationSnapshot? = callbacks.getHydration(providerId, contentType, categoryId)++ override suspend fun currentIndexedRowCount(providerId: Long, contentType: ContentType): Int =+ callbacks.currentIndexedRowCount(providerId, contentType)++ override suspend fun pruneStaleRows(providerId: Long, contentType: ContentType): Int =+ callbacks.pruneStaleRows(providerId, contentType)++ override suspend fun updateSummaryMetadata(+ providerId: Long,+ contentType: ContentType,+ indexedRows: Int,+ finalState: String,+ now: Long+ ) = callbacks.updateSummaryMetadata(providerId, contentType, indexedRows, finalState, now)++ override suspend fun fetchSummaryPage(+ provider: Provider,+ api: StalkerProvider,+ contentType: ContentType,+ categoryId: Long,+ page: Int+ ): Result<StalkerPagedResult<out Any>> = callbacks.fetchSummaryPage(provider, api, contentType, categoryId, page)++ override suspend fun fetchWildcardPage(+ provider: Provider,+ api: StalkerProvider,+ contentType: ContentType,+ categoryId: Long,+ page: Int+ ): Result<StalkerPagedResult<out Any>> = callbacks.fetchWildcardPage(provider, api, contentType, categoryId, page)++ override suspend fun markAttemptStarted(+ providerId: Long,+ contentType: ContentType,+ categoryId: Long,+ hydration: StalkerHydrationSnapshot?,+ attemptedPage: Int,+ now: Long+ ) = callbacks.markAttemptStarted(providerId, contentType, categoryId, hydration, attemptedPage, now)++ override suspend fun markAttemptSucceeded(+ providerId: Long,+ contentType: ContentType,+ categoryId: Long,+ hydration: StalkerHydrationSnapshot?,+ attemptedPage: Int,+ now: Long,+ itemCount: Int,+ totalPages: Int,+ pageSize: Int,+ advertisedTotalItems: Int?,+ advertisedTotalPages: Int?,+ pageComplete: Boolean,+ truncated: Boolean,+ terminationReason: String?,+ pageFingerprint: String?+ ) = callbacks.markAttemptSucceeded(+ providerId,+ contentType,+ categoryId,+ hydration,+ attemptedPage,+ now,+ itemCount,+ totalPages,+ pageSize,+ advertisedTotalItems,+ advertisedTotalPages,+ pageComplete,+ truncated,+ terminationReason,+ pageFingerprint+ )++ override suspend fun markAttemptFailed(+ providerId: Long,+ contentType: ContentType,+ categoryId: Long,+ hydration: StalkerHydrationSnapshot?,+ attemptedPage: Int,+ now: Long,+ message: String,+ retryable: Boolean,+ pageFingerprint: String?+ ) = callbacks.markAttemptFailed(+ providerId,+ contentType,+ categoryId,+ hydration,+ attemptedPage,+ now,+ message,+ retryable,+ pageFingerprint+ )++ override suspend fun upsertMovieSummaryBatch(providerId: Long, movies: List<Movie>, indexedAt: Long) =+ callbacks.upsertMovieSummaryBatch(providerId, movies, indexedAt)++ override suspend fun upsertSeriesSummaryBatch(providerId: Long, series: List<Series>, indexedAt: Long) =+ callbacks.upsertSeriesSummaryBatch(providerId, series, indexedAt)++ override suspend fun upsertVodDerivedSeriesSummaryBatch(providerId: Long, series: List<Series>, indexedAt: Long) =+ callbacks.upsertVodDerivedSeriesSummaryBatch(providerId, series, indexedAt)++ override suspend fun recordRequestFailure(providerId: Long, error: Throwable?) =+ callbacks.recordRequestFailure(providerId, error)++ override fun failureState(error: Throwable): String = callbacks.failureState(error)++ override fun progress(providerId: Long, callback: ((String) -> Unit)?, message: String) =+ callbacks.progress(providerId, callback, message)++ override suspend fun restoreMovieWatchProgress(providerId: Long) =+ callbacks.restoreMovieWatchProgress(providerId)++ override suspend fun upsertJob(update: CatalogIndexJobUpdate) = callbacks.upsertJob(update)++ override fun log(message: String) = callbacks.log(message)+}diff --git a/data/src/main/java/com/streamvault/data/sync/StalkerIndexCheckpointStore.kt b/data/src/main/java/com/streamvault/data/sync/StalkerIndexCheckpointStore.ktnew file mode 100644index 00000000..6bad4717--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/StalkerIndexCheckpointStore.kt@@ -0,0 +1,266 @@+package com.streamvault.data.sync++import com.streamvault.data.local.dao.MovieCategoryHydrationDao+import com.streamvault.data.local.dao.SeriesCategoryHydrationDao+import com.streamvault.data.local.entity.MovieCategoryHydrationEntity+import com.streamvault.data.local.entity.SeriesCategoryHydrationEntity+import com.streamvault.domain.model.ContentType++/** Owns durable per-category Stalker index checkpoints and their recovery projections. */+internal class StalkerIndexCheckpointStore(+ private val movieHydrationDao: MovieCategoryHydrationDao,+ private val seriesHydrationDao: SeriesCategoryHydrationDao+) {+ suspend fun getHydrationSnapshot(+ providerId: Long,+ contentType: ContentType,+ categoryId: Long+ ): StalkerHydrationSnapshot? = when (contentType) {+ ContentType.MOVIE -> movieHydrationDao.get(providerId, categoryId)?.let { hydration ->+ StalkerHydrationSnapshot(+ lastHydratedAt = hydration.lastHydratedAt,+ itemCount = hydration.itemCount,+ lastStatus = hydration.lastStatus,+ lastError = hydration.lastError,+ lastLoadedPage = hydration.lastLoadedPage,+ lastAttemptedPage = hydration.lastAttemptedPage,+ lastSuccessfulPage = hydration.lastSuccessfulPage,+ totalPages = hydration.totalPages,+ advertisedTotalItems = hydration.advertisedTotalItems,+ advertisedTotalPages = hydration.advertisedTotalPages,+ isComplete = hydration.isComplete,+ pageSize = hydration.pageSize,+ retryAfterMs = hydration.retryAfterMs,+ failureCount = hydration.failureCount,+ retryBudgetRemaining = hydration.retryBudgetRemaining,+ lastPageFingerprint = hydration.lastPageFingerprint+ )+ }+ ContentType.SERIES -> seriesHydrationDao.get(providerId, categoryId)?.let { hydration ->+ StalkerHydrationSnapshot(+ lastHydratedAt = hydration.lastHydratedAt,+ itemCount = hydration.itemCount,+ lastStatus = hydration.lastStatus,+ lastError = hydration.lastError,+ lastLoadedPage = hydration.lastLoadedPage,+ lastAttemptedPage = hydration.lastAttemptedPage,+ lastSuccessfulPage = hydration.lastSuccessfulPage,+ totalPages = hydration.totalPages,+ advertisedTotalItems = hydration.advertisedTotalItems,+ advertisedTotalPages = hydration.advertisedTotalPages,+ isComplete = hydration.isComplete,+ pageSize = hydration.pageSize,+ retryAfterMs = hydration.retryAfterMs,+ failureCount = hydration.failureCount,+ retryBudgetRemaining = hydration.retryBudgetRemaining,+ lastPageFingerprint = hydration.lastPageFingerprint+ )+ }+ else -> null+ }++ suspend fun markAttemptStarted(+ providerId: Long,+ contentType: ContentType,+ categoryId: Long,+ hydration: StalkerHydrationSnapshot?,+ attemptedPage: Int,+ now: Long+ ) {+ when (contentType) {+ ContentType.MOVIE -> movieHydrationDao.upsert(+ MovieCategoryHydrationEntity(+ providerId = providerId,+ categoryId = categoryId,+ lastHydratedAt = hydration?.lastHydratedAt ?: 0L,+ itemCount = hydration?.itemCount ?: 0,+ lastStatus = "RUNNING",+ lastError = null,+ lastLoadedPage = hydration?.lastLoadedPage ?: 0,+ lastAttemptedPage = attemptedPage,+ lastSuccessfulPage = hydration?.lastSuccessfulPage ?: 0,+ totalPages = hydration?.totalPages ?: 0,+ advertisedTotalItems = hydration?.advertisedTotalItems,+ advertisedTotalPages = hydration?.advertisedTotalPages,+ isComplete = hydration?.isComplete ?: false,+ pageSize = hydration?.pageSize ?: 0,+ retryAfterMs = 0L,+ failureCount = hydration?.failureCount ?: 0,+ retryBudgetRemaining = hydration?.retryBudgetRemaining ?: STALKER_CATEGORY_RETRY_BUDGET,+ lastPageFingerprint = hydration?.lastPageFingerprint+ )+ )+ ContentType.SERIES -> seriesHydrationDao.upsert(+ SeriesCategoryHydrationEntity(+ providerId = providerId,+ categoryId = categoryId,+ lastHydratedAt = hydration?.lastHydratedAt ?: 0L,+ itemCount = hydration?.itemCount ?: 0,+ lastStatus = "RUNNING",+ lastError = null,+ lastLoadedPage = hydration?.lastLoadedPage ?: 0,+ lastAttemptedPage = attemptedPage,+ lastSuccessfulPage = hydration?.lastSuccessfulPage ?: 0,+ totalPages = hydration?.totalPages ?: 0,+ advertisedTotalItems = hydration?.advertisedTotalItems,+ advertisedTotalPages = hydration?.advertisedTotalPages,+ isComplete = hydration?.isComplete ?: false,+ pageSize = hydration?.pageSize ?: 0,+ retryAfterMs = 0L,+ failureCount = hydration?.failureCount ?: 0,+ retryBudgetRemaining = hydration?.retryBudgetRemaining ?: STALKER_CATEGORY_RETRY_BUDGET,+ lastPageFingerprint = hydration?.lastPageFingerprint+ )+ )+ else -> Unit+ }+ }++ suspend fun markAttemptSucceeded(+ providerId: Long,+ contentType: ContentType,+ categoryId: Long,+ hydration: StalkerHydrationSnapshot?,+ attemptedPage: Int,+ now: Long,+ itemCount: Int,+ totalPages: Int,+ pageSize: Int,+ advertisedTotalItems: Int?,+ advertisedTotalPages: Int?,+ pageComplete: Boolean,+ truncated: Boolean,+ terminationReason: String?,+ pageFingerprint: String?+ ) {+ val status = if (truncated) "TRUNCATED" else "SUCCESS"+ when (contentType) {+ ContentType.MOVIE -> movieHydrationDao.upsert(+ MovieCategoryHydrationEntity(+ providerId = providerId,+ categoryId = categoryId,+ lastHydratedAt = now,+ itemCount = itemCount,+ lastStatus = status,+ lastError = terminationReason,+ lastLoadedPage = attemptedPage,+ lastAttemptedPage = attemptedPage,+ lastSuccessfulPage = attemptedPage,+ totalPages = totalPages,+ advertisedTotalItems = advertisedTotalItems,+ advertisedTotalPages = advertisedTotalPages,+ isComplete = pageComplete && !truncated,+ pageSize = pageSize,+ retryAfterMs = 0L,+ failureCount = 0,+ retryBudgetRemaining = STALKER_CATEGORY_RETRY_BUDGET,+ lastPageFingerprint = pageFingerprint+ )+ )+ ContentType.SERIES -> seriesHydrationDao.upsert(+ SeriesCategoryHydrationEntity(+ providerId = providerId,+ categoryId = categoryId,+ lastHydratedAt = now,+ itemCount = itemCount,+ lastStatus = status,+ lastError = terminationReason,+ lastLoadedPage = attemptedPage,+ lastAttemptedPage = attemptedPage,+ lastSuccessfulPage = attemptedPage,+ totalPages = totalPages,+ advertisedTotalItems = advertisedTotalItems,+ advertisedTotalPages = advertisedTotalPages,+ isComplete = pageComplete && !truncated,+ pageSize = pageSize,+ retryAfterMs = 0L,+ failureCount = 0,+ retryBudgetRemaining = STALKER_CATEGORY_RETRY_BUDGET,+ lastPageFingerprint = pageFingerprint+ )+ )+ else -> Unit+ }+ }++ suspend fun markAttemptFailed(+ providerId: Long,+ contentType: ContentType,+ categoryId: Long,+ hydration: StalkerHydrationSnapshot?,+ attemptedPage: Int,+ now: Long,+ message: String,+ retryable: Boolean,+ pageFingerprint: String?+ ) {+ val priorFailures = hydration?.failureCount ?: 0+ val remainingBudget = if (retryable) {+ ((hydration?.retryBudgetRemaining ?: STALKER_CATEGORY_RETRY_BUDGET) - 1).coerceAtLeast(0)+ } else {+ 0+ }+ val nextStatus = when {+ !retryable -> "FAILED_PERMANENT"+ remainingBudget <= 0 -> "FAILED_BUDGET_EXHAUSTED"+ else -> "FAILED_RETRYABLE"+ }+ val retryAfterMs = if (nextStatus == "FAILED_RETRYABLE" && priorFailures > 0) {+ now + STALKER_CATEGORY_RETRY_COOLDOWN_MILLIS * (priorFailures + 1).coerceAtLeast(1)+ } else {+ 0L+ }+ when (contentType) {+ ContentType.MOVIE -> movieHydrationDao.upsert(+ MovieCategoryHydrationEntity(+ providerId = providerId,+ categoryId = categoryId,+ lastHydratedAt = hydration?.lastHydratedAt ?: 0L,+ itemCount = hydration?.itemCount ?: 0,+ lastStatus = nextStatus,+ lastError = message,+ lastLoadedPage = hydration?.lastLoadedPage ?: 0,+ lastAttemptedPage = attemptedPage,+ lastSuccessfulPage = hydration?.lastSuccessfulPage ?: 0,+ totalPages = hydration?.totalPages ?: 0,+ advertisedTotalItems = hydration?.advertisedTotalItems,+ advertisedTotalPages = hydration?.advertisedTotalPages,+ isComplete = hydration?.isComplete ?: false,+ pageSize = hydration?.pageSize ?: 0,+ retryAfterMs = retryAfterMs,+ failureCount = priorFailures + 1,+ retryBudgetRemaining = remainingBudget,+ lastPageFingerprint = pageFingerprint+ )+ )+ ContentType.SERIES -> seriesHydrationDao.upsert(+ SeriesCategoryHydrationEntity(+ providerId = providerId,+ categoryId = categoryId,+ lastHydratedAt = hydration?.lastHydratedAt ?: 0L,+ itemCount = hydration?.itemCount ?: 0,+ lastStatus = nextStatus,+ lastError = message,+ lastLoadedPage = hydration?.lastLoadedPage ?: 0,+ lastAttemptedPage = attemptedPage,+ lastSuccessfulPage = hydration?.lastSuccessfulPage ?: 0,+ totalPages = hydration?.totalPages ?: 0,+ advertisedTotalItems = hydration?.advertisedTotalItems,+ advertisedTotalPages = hydration?.advertisedTotalPages,+ isComplete = hydration?.isComplete ?: false,+ pageSize = hydration?.pageSize ?: 0,+ retryAfterMs = retryAfterMs,+ failureCount = priorFailures + 1,+ retryBudgetRemaining = remainingBudget,+ lastPageFingerprint = pageFingerprint+ )+ )+ else -> Unit+ }+ }++ private companion object {+ const val STALKER_CATEGORY_RETRY_BUDGET = 3+ const val STALKER_CATEGORY_RETRY_COOLDOWN_MILLIS = 5 * 60 * 1000L+ }+}diff --git a/data/src/main/java/com/streamvault/data/sync/StalkerIndexContinuationCoordinator.kt b/data/src/main/java/com/streamvault/data/sync/StalkerIndexContinuationCoordinator.ktnew file mode 100644index 00000000..f18aea93--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/StalkerIndexContinuationCoordinator.kt@@ -0,0 +1,161 @@+package com.streamvault.data.sync++import com.streamvault.data.local.entity.CategoryEntity+import com.streamvault.data.remote.stalker.StalkerProvider+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.LegacyProvider as Provider+import com.streamvault.domain.model.ProviderEpgSyncMode+import com.streamvault.domain.model.ProviderType+import com.streamvault.domain.model.StalkerCatalogMode+import com.streamvault.domain.model.StalkerIndexState++/**+ * Owns durable Stalker index continuation decisions around the section executor.+ *+ * The section executor commits pages; this collaborator decides whether a section is runnable,+ * which successor should be scheduled, when retry delay should be applied, and how startup+ * reconciles persisted Stalker work with the configured catalog mode.+ */+internal class StalkerIndexContinuationCoordinator(+ private val stalkerIndexJobStore: StalkerIndexJobStore,+ private val loadCategories: suspend (Long, ContentType) -> List<CategoryEntity>,+ private val loadHydration: suspend (Long, ContentType, Long) -> StalkerHydrationSnapshot?,+ private val visibleCategories: suspend (+ Long,+ ContentType,+ List<CategoryEntity>,+ StalkerProvider+ ) -> List<CategoryEntity>,+ private val loadProvider: suspend (Long) -> Provider?,+ private val loadStalkerProviders: suspend () -> List<Long>,+ private val deleteLegacyJobs: suspend (Long) -> Unit,+ private val cancelIndex: (Long) -> Unit,+ private val scheduleIndex: (Long, Long, Boolean) -> Unit,+ private val scheduleBackgroundEpg: (Long) -> Unit,+ private val log: (String) -> Unit = {}+) {+ suspend fun chooseNextSection(+ provider: Provider,+ api: StalkerProvider,+ requestedSection: ContentType?,+ force: Boolean,+ now: Long+ ): StalkerCatalogDecision {+ val movie = sectionState(provider, api, ContentType.MOVIE, force, now)+ val series = sectionState(provider, api, ContentType.SERIES, force, now)+ return StalkerIndexPolicy.chooseNextSection(+ layout = provider.catalogLayout,+ requestedSection = requestedSection,+ movie = movie,+ series = series+ )+ }++ suspend fun scheduleNextSection(provider: Provider, api: StalkerProvider) {+ val decision = chooseNextSection(+ provider = provider,+ api = api,+ requestedSection = null,+ force = false,+ now = System.currentTimeMillis()+ )+ when {+ decision.contentType != null -> {+ log("Scheduling next Stalker catalog step for provider ${provider.id}: ${decision.contentType.name}")+ scheduleIndex(provider.id, 0L, true)+ }+ decision.retryDelaySeconds > 0L -> {+ log("Scheduling Stalker catalog retry for provider ${provider.id} in ${decision.retryDelaySeconds}s")+ scheduleIndex(provider.id, decision.retryDelaySeconds, true)+ }+ }+ }++ fun scheduleEpgIfCatalogIdle(provider: Provider) {+ if (+ provider.type != ProviderType.STALKER_PORTAL ||+ provider.epgSyncMode != ProviderEpgSyncMode.BACKGROUND+ ) return+ log("Scheduling Stalker EPG independently of catalog indexing for provider ${provider.id}.")+ scheduleBackgroundEpg(provider.id)+ }++ suspend fun reconcileAtStartup() {+ loadStalkerProviders().forEach { providerId ->+ val provider = loadProvider(providerId) ?: return@forEach+ // v62 and older reused Xtream rows. They are never valid Stalker owners now.+ deleteLegacyJobs(provider.id)+ val hasPendingOneTime = listOf(ContentType.MOVIE, ContentType.SERIES).any { section ->+ stalkerIndexJobStore.get(provider.id, section)?.state in setOf(+ StalkerIndexState.QUEUED,+ StalkerIndexState.RUNNING,+ StalkerIndexState.RETRY_WAIT,+ StalkerIndexState.PARTIAL+ )+ }+ if (provider.stalkerCatalogMode == StalkerCatalogMode.ON_DEMAND && !hasPendingOneTime) {+ cancelIndex(provider.id)+ } else if (provider.stalkerCatalogMode == StalkerCatalogMode.BACKGROUND_INDEX || hasPendingOneTime) {+ scheduleIndex(provider.id, 0L, false)+ }+ }+ }++ private suspend fun sectionState(+ provider: Provider,+ api: StalkerProvider,+ contentType: ContentType,+ force: Boolean,+ now: Long+ ): StalkerCatalogSectionState {+ val job = stalkerIndexJobStore.get(provider.id, contentType)+ if (!force && !stalkerIndexJobStore.shouldRunSummary(job)) {+ return StalkerCatalogSectionState(+ contentType = contentType,+ runnable = false,+ retryDelaySeconds = 0L,+ pending = false,+ jobState = job?.state?.let(stalkerIndexJobStore::toLegacyState),+ updatedAt = job?.updatedAt ?: 0L+ )+ }++ val categories = loadCategories(provider.id, contentType)+ val visible = visibleCategories(provider.id, contentType, categories, api)+ if (visible.isEmpty()) {+ return StalkerCatalogSectionState(+ contentType = contentType,+ runnable = true,+ retryDelaySeconds = 0L,+ pending = true,+ jobState = job?.state?.let(stalkerIndexJobStore::toLegacyState),+ updatedAt = job?.updatedAt ?: 0L+ )+ }++ val hydrations = visible.map { category ->+ loadHydration(provider.id, contentType, category.categoryId)+ }+ val hasAttemptableWork = hydrations.any { hydration ->+ StalkerIndexPolicy.canAttempt(hydration, now)+ }+ val retryDelaySeconds = StalkerIndexPolicy.nextRetryDelaySeconds(hydrations, now)+ val hasUnresolvedWork = hydrations.any { hydration ->+ hydration == null ||+ (!hydration.isComplete && !hydration.isTerminalFailure && hydration.retryBudgetRemaining > 0)+ }+ val needsStateReconciliation = job?.state in setOf(+ StalkerIndexState.QUEUED,+ StalkerIndexState.RUNNING,+ StalkerIndexState.RETRY_WAIT+ ) && !hasUnresolvedWork+ return StalkerCatalogSectionState(+ contentType = contentType,+ runnable = hasAttemptableWork || needsStateReconciliation,+ retryDelaySeconds = retryDelaySeconds,+ pending = hasUnresolvedWork || needsStateReconciliation,+ jobState = job?.state?.let(stalkerIndexJobStore::toLegacyState),+ updatedAt = job?.updatedAt ?: 0L+ )+ }+}diff --git a/data/src/main/java/com/streamvault/data/sync/StalkerIndexJobStore.kt b/data/src/main/java/com/streamvault/data/sync/StalkerIndexJobStore.ktnew file mode 100644index 00000000..2e2a22e6--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/StalkerIndexJobStore.kt@@ -0,0 +1,132 @@+package com.streamvault.data.sync++import com.streamvault.data.local.dao.StalkerIndexJobDao+import com.streamvault.data.local.entity.StalkerIndexJobEntity+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.StalkerIndexState+import javax.inject.Inject+import javax.inject.Singleton++/** Owns the durable Stalker movie/series index-job representation and state mapping. */+@Singleton+class StalkerIndexJobStore @Inject constructor(+ private val dao: StalkerIndexJobDao+) {+ suspend fun get(providerId: Long, section: ContentType): StalkerIndexJobEntity? =+ dao.get(providerId, section.name)++ suspend fun deleteByProvider(providerId: Long): Int = dao.deleteByProvider(providerId)++ internal fun shouldRunSummary(job: StalkerIndexJobEntity?): Boolean {+ if (job == null) return true+ if (job.state in setOf(+ StalkerIndexState.QUEUED,+ StalkerIndexState.RUNNING,+ StalkerIndexState.PARTIAL,+ StalkerIndexState.RETRY_WAIT+ )) return true+ return ContentCachePolicy.shouldRefresh(job.lastSuccessAt, ContentCachePolicy.CATALOG_TTL_MILLIS)+ }++ internal fun toLegacyState(state: StalkerIndexState): String = when (state) {+ StalkerIndexState.DISABLED -> "DISABLED"+ StalkerIndexState.QUEUED -> "QUEUED"+ StalkerIndexState.RUNNING -> "RUNNING"+ StalkerIndexState.RETRY_WAIT -> "FAILED_RETRYABLE"+ StalkerIndexState.PARTIAL -> "PARTIAL"+ StalkerIndexState.COMPLETE -> "SUCCESS"+ StalkerIndexState.TRUNCATED -> "TRUNCATED"+ StalkerIndexState.FAILED -> "FAILED_PERMANENT"+ }++ internal suspend fun upsertLegacy(+ providerId: Long,+ section: ContentType,+ state: String,+ now: Long,+ totalCategories: Int? = null,+ completedCategories: Int? = null,+ nextCategoryIndex: Int? = null,+ failedCategories: Int? = null,+ indexedRows: Int? = null,+ skippedMalformedRows: Int? = null,+ deletedPrunedRows: Int? = null,+ lastAttemptAt: Long? = null,+ lastSuccessAt: Long? = null,+ lastError: String? = null+ ) {+ upsert(+ StalkerIndexJobUpdate(+ providerId = providerId,+ section = section,+ state = state.toStalkerState(),+ now = now,+ totalCategories = totalCategories,+ completedCategories = completedCategories,+ nextCategoryIndex = nextCategoryIndex,+ failedCategories = failedCategories,+ indexedRows = indexedRows,+ skippedMalformedRows = skippedMalformedRows,+ deletedPrunedRows = deletedPrunedRows,+ lastAttemptAt = lastAttemptAt,+ lastSuccessAt = lastSuccessAt,+ lastError = lastError+ )+ )+ }++ internal suspend fun upsert(update: StalkerIndexJobUpdate) {+ require(update.section in setOf(ContentType.MOVIE, ContentType.SERIES)) {+ "Unsupported Stalker index section: ${update.section}"+ }+ val existing = dao.get(update.providerId, update.section.name)+ dao.upsert(+ (existing ?: StalkerIndexJobEntity(+ providerId = update.providerId,+ section = update.section+ )).copy(+ state = update.state,+ totalCategories = update.totalCategories ?: existing?.totalCategories ?: 0,+ completedCategories = update.completedCategories ?: existing?.completedCategories ?: 0,+ nextCategoryIndex = update.nextCategoryIndex ?: existing?.nextCategoryIndex ?: 0,+ failedCategories = update.failedCategories ?: existing?.failedCategories ?: 0,+ indexedRows = update.indexedRows ?: existing?.indexedRows ?: 0,+ skippedMalformedRows = update.skippedMalformedRows ?: existing?.skippedMalformedRows ?: 0,+ deletedPrunedRows = update.deletedPrunedRows ?: existing?.deletedPrunedRows ?: 0,+ lastError = update.lastError,+ lastAttemptAt = update.lastAttemptAt ?: existing?.lastAttemptAt ?: 0L,+ lastSuccessAt = update.lastSuccessAt ?: existing?.lastSuccessAt ?: 0L,+ updatedAt = update.now+ )+ )+ }++ private fun String.toStalkerState(): StalkerIndexState = when (this) {+ "QUEUED", "STALE" -> StalkerIndexState.QUEUED+ "RUNNING" -> StalkerIndexState.RUNNING+ "FAILED_RETRYABLE" -> StalkerIndexState.RETRY_WAIT+ "PARTIAL" -> StalkerIndexState.PARTIAL+ "SUCCESS", "COMPLETE" -> StalkerIndexState.COMPLETE+ "TRUNCATED" -> StalkerIndexState.TRUNCATED+ "FAILED_PERMANENT", "FAILED" -> StalkerIndexState.FAILED+ "DISABLED", "IDLE" -> StalkerIndexState.DISABLED+ else -> StalkerIndexState.PARTIAL+ }+}++internal data class StalkerIndexJobUpdate(+ val providerId: Long,+ val section: ContentType,+ val state: StalkerIndexState,+ val now: Long,+ val totalCategories: Int? = null,+ val completedCategories: Int? = null,+ val nextCategoryIndex: Int? = null,+ val failedCategories: Int? = null,+ val indexedRows: Int? = null,+ val skippedMalformedRows: Int? = null,+ val deletedPrunedRows: Int? = null,+ val lastAttemptAt: Long? = null,+ val lastSuccessAt: Long? = null,+ val lastError: String? = null+)diff --git a/data/src/main/java/com/streamvault/data/sync/StalkerIndexPolicy.kt b/data/src/main/java/com/streamvault/data/sync/StalkerIndexPolicy.ktnew file mode 100644index 00000000..88f17439--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/StalkerIndexPolicy.kt@@ -0,0 +1,236 @@+package com.streamvault.data.sync++import com.streamvault.data.remote.stalker.StalkerVodCatalogItem+import com.streamvault.data.remote.stalker.StalkerPagedResult+import com.streamvault.domain.model.CatalogLayout+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.Movie+import com.streamvault.domain.model.Series+import java.security.MessageDigest++/** Durable state projected into the decisions made by the Stalker index worker. */+internal data class StalkerHydrationSnapshot(+ val lastHydratedAt: Long,+ val itemCount: Int,+ val lastStatus: String,+ val lastError: String?,+ val lastLoadedPage: Int,+ val lastAttemptedPage: Int,+ val lastSuccessfulPage: Int,+ val totalPages: Int,+ val advertisedTotalItems: Int?,+ val advertisedTotalPages: Int?,+ val isComplete: Boolean,+ val pageSize: Int,+ val retryAfterMs: Long,+ val failureCount: Int,+ val retryBudgetRemaining: Int,+ val lastPageFingerprint: String?+)++internal val StalkerHydrationSnapshot.isTerminalFailure: Boolean+ get() = lastStatus in setOf("FAILED_PERMANENT", "FAILED_BUDGET_EXHAUSTED")++internal val StalkerHydrationSnapshot.isTruncated: Boolean+ get() = lastStatus == "TRUNCATED"++internal val StalkerHydrationSnapshot.hasPruneSuppressionRisk: Boolean+ get() = lastStatus in setOf("ANOMALY", "FAILED_RETRYABLE", "COOLDOWN", "TRUNCATED")++internal data class StalkerCatalogDecision(+ val contentType: ContentType?,+ val retryDelaySeconds: Long = 0L,+ val reason: String+)++internal data class StalkerCatalogSectionState(+ val contentType: ContentType,+ val runnable: Boolean,+ val retryDelaySeconds: Long,+ val pending: Boolean,+ val jobState: String?,+ val updatedAt: Long+)++/**+ * Pure Stalker index policy. It owns page continuation, retry gating, anomaly detection, and+ * selection order; database/network orchestration remains in the worker coordinator.+ */+internal object StalkerIndexPolicy {+ fun chooseNextSection(+ layout: CatalogLayout,+ requestedSection: ContentType?,+ movie: StalkerCatalogSectionState,+ series: StalkerCatalogSectionState+ ): StalkerCatalogDecision {+ if (requestedSection == ContentType.MOVIE && movie.runnable) {+ return StalkerCatalogDecision(+ ContentType.MOVIE,+ reason = "explicit movie section is runnable (${movie.jobState ?: "no job"})"+ )+ }+ if (requestedSection == ContentType.SERIES && series.runnable) {+ return StalkerCatalogDecision(+ ContentType.SERIES,+ reason = "explicit series section is runnable (${series.jobState ?: "no job"})"+ )+ }+ if (movie.runnable && series.runnable) {+ // In split mode, finish the native Series projection before VOD-derived+ // supplementation so disappeared native rows can fall back safely.+ val selected = if (layout == CatalogLayout.SPLIT) {+ series+ } else {+ listOf(movie, series).minWith(+ compareBy<StalkerCatalogSectionState>({ it.updatedAt }, { it.contentType.ordinal })+ )+ }+ return StalkerCatalogDecision(+ selected.contentType,+ reason = "oldest pending section is ${selected.contentType.name.lowercase()} (${selected.jobState ?: "no job"})"+ )+ }+ if (movie.runnable) {+ return StalkerCatalogDecision(ContentType.MOVIE, reason = "movies are runnable (${movie.jobState ?: "no job"})")+ }+ if (series.runnable) {+ val reason = if (movie.pending && movie.retryDelaySeconds > 0L) {+ "movies are waiting ${movie.retryDelaySeconds}s for retry; series is runnable"+ } else {+ "movies are complete or terminal; series is runnable (${series.jobState ?: "no job"})"+ }+ return StalkerCatalogDecision(ContentType.SERIES, reason = reason)+ }++ val retryDelaySeconds = listOf(movie.retryDelaySeconds, series.retryDelaySeconds)+ .filter { it > 0L }+ .minOrNull()+ ?: 0L+ return StalkerCatalogDecision(+ contentType = null,+ retryDelaySeconds = retryDelaySeconds,+ reason = when {+ retryDelaySeconds > 0L -> "catalog is waiting ${retryDelaySeconds}s for retry"+ movie.pending || series.pending -> "catalog has no attemptable work"+ requestedSection == ContentType.MOVIE -> "requested movie section is not pending"+ requestedSection == ContentType.SERIES -> "requested series section is not pending"+ else -> "catalog is idle"+ }+ )+ }++ fun canAttempt(hydration: StalkerHydrationSnapshot?, now: Long): Boolean {+ if (hydration == null) return true+ if (hydration.isComplete || hydration.isTruncated || hydration.isTerminalFailure) return false+ if (hydration.retryBudgetRemaining <= 0) return false+ return hydration.retryAfterMs <= now+ }++ fun nextAttemptPage(hydration: StalkerHydrationSnapshot?): Int {+ if (hydration == null) return 1+ if (hydration.lastStatus in setOf("FAILED_RETRYABLE", "COOLDOWN", "ANOMALY")) {+ return hydration.lastAttemptedPage.coerceAtLeast(1)+ }+ return (hydration.lastSuccessfulPage + 1).coerceAtLeast(1)+ }++ fun nextRetryDelaySeconds(+ hydrations: Iterable<StalkerHydrationSnapshot?>,+ now: Long+ ): Long {+ val retryAt = hydrations+ .filterNotNull()+ .filter { hydration ->+ !hydration.isComplete &&+ !hydration.isTerminalFailure &&+ hydration.retryBudgetRemaining > 0 &&+ hydration.retryAfterMs > now+ }+ .minOfOrNull { it.retryAfterMs }+ ?: return 0L+ return ((retryAt - now + 999L) / 1000L).coerceAtLeast(1L)+ }++ fun detectPageAnomaly(+ hydration: StalkerHydrationSnapshot?,+ requestedPage: Int,+ pagedResult: StalkerPagedResult<out Any>,+ pageFingerprint: String?+ ): String? {+ if (pagedResult.page != requestedPage) {+ return "Portal returned page ${pagedResult.page} while page $requestedPage was requested."+ }+ if (hydration != null && hydration.totalPages > 0 && pagedResult.totalPages > 0) {+ if (pagedResult.totalPages < hydration.lastSuccessfulPage) {+ return "Portal page count regressed below the last successful page."+ }+ if (+ hydration.advertisedTotalPages != null &&+ pagedResult.advertisedTotalPages != null &&+ hydration.advertisedTotalPages != pagedResult.advertisedTotalPages+ ) {+ return "Portal changed its advertised catalog page count while indexing."+ }+ if (+ hydration.lastAttemptedPage == requestedPage &&+ hydration.lastPageFingerprint != null &&+ hydration.lastPageFingerprint == pageFingerprint &&+ hydration.lastStatus in setOf("FAILED_RETRYABLE", "RUNNING", "ANOMALY")+ ) {+ return "Portal repeated the same page payload for page $requestedPage."+ }+ }+ return null+ }++ fun pageFingerprint(items: List<out Any>, contentType: ContentType): String? {+ if (items.isEmpty()) return "empty"+ val classifiedSeeds = items.filterIsInstance<StalkerVodCatalogItem>()+ .map { entry -> "${entry.rawItemId}:${entry.item.stableId}" }+ if (classifiedSeeds.isNotEmpty()) return sha1Hex(classifiedSeeds.joinToString("|"))+ val seeds = when (contentType) {+ ContentType.MOVIE -> items.filterIsInstance<Movie>().map { movie ->+ "${movie.streamId}:${movie.categoryId}:${movie.addedAt}"+ }+ ContentType.SERIES -> items.filterIsInstance<Series>().map { series ->+ "${series.providerSeriesId ?: series.seriesId}:${series.categoryId}:${series.lastModified}"+ }+ else -> emptyList()+ }+ if (seeds.isEmpty()) return null+ return sha1Hex(seeds.joinToString("|"))+ }++ fun dedupePageItems(items: List<out Any>, contentType: ContentType): List<out Any> {+ val classified = items.filterIsInstance<StalkerVodCatalogItem>()+ if (classified.isNotEmpty()) return classified.distinctBy(StalkerVodCatalogItem::rawItemId)+ return when (contentType) {+ ContentType.MOVIE -> items.filterIsInstance<Movie>().distinctBy(Movie::streamId)+ ContentType.SERIES -> items.filterIsInstance<Series>().distinctBy {+ it.providerSeriesId ?: it.seriesId.toString()+ }+ else -> items+ }+ }++ fun filterToVisibleCategories(+ items: List<out Any>,+ contentType: ContentType,+ visibleCategoryIds: Set<Long>?+ ): List<out Any> = when (contentType) {+ ContentType.MOVIE -> items.filterIsInstance<Movie>().filter { movie ->+ visibleCategoryIds == null || movie.categoryId in visibleCategoryIds+ }+ ContentType.SERIES -> items.filterIsInstance<Series>().filter { series ->+ visibleCategoryIds == null || series.categoryId in visibleCategoryIds+ }+ else -> items+ }++ private fun sha1Hex(value: String): String {+ val bytes = MessageDigest.getInstance("SHA-1").digest(value.toByteArray(Charsets.UTF_8))+ return buildString(bytes.size * 2) {+ bytes.forEach { byte -> append("%02x".format(byte)) }+ }+ }+}diff --git a/data/src/main/java/com/streamvault/data/sync/StalkerIndexRecoveryPolicy.kt b/data/src/main/java/com/streamvault/data/sync/StalkerIndexRecoveryPolicy.ktnew file mode 100644index 00000000..cc1efb9a--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/StalkerIndexRecoveryPolicy.kt@@ -0,0 +1,19 @@+package com.streamvault.data.sync++/** Keeps durable Stalker index failure classification out of the sync façade. */+internal object StalkerIndexRecoveryPolicy {+ fun isLikelyAuthFailure(message: String, exception: Throwable?): Boolean =+ com.streamvault.data.remote.stalker.isStalkerAuthorizationFailure(message, exception)++ fun failureState(error: Throwable, sanitize: (Throwable?) -> String): String {+ if (isLikelyAuthFailure(sanitize(error), error)) {+ return "FAILED_PERMANENT"+ }+ val message = sanitize(error).lowercase()+ return if (message.contains("not accessible") || message.contains("no accessible catalog")) {+ "FAILED_PERMANENT"+ } else {+ "FAILED_RETRYABLE"+ }+ }+}diff --git a/data/src/main/java/com/streamvault/data/sync/StalkerIndexWorker.kt b/data/src/main/java/com/streamvault/data/sync/StalkerIndexWorker.ktindex 0861c4ac..422397e0 100644--- a/data/src/main/java/com/streamvault/data/sync/StalkerIndexWorker.kt+++ b/data/src/main/java/com/streamvault/data/sync/StalkerIndexWorker.kt@@ -40,7 +40,7 @@ class StalkerIndexWorker(@InstallIn(SingletonComponent::class)interface StalkerIndexWorkerEntryPoint {fun providerDao(): ProviderDao- fun syncManager(): SyncManager+ fun syncCommands(): ProviderSyncCommandsfun providerWorkflowRunner(): ProviderWorkflowRunner}@@ -77,7 +77,7 @@ class StalkerIndexWorker(reason = ProviderWorkflowReason.PERIODIC,force = force) {- when (val result = entryPoint.syncManager().processQueuedStalkerIndexJobs(+ when (val result = entryPoint.syncCommands().processQueuedStalkerIndexJobs(providerId = provider.id,section = requestedSection,force = force,diff --git a/data/src/main/java/com/streamvault/data/sync/SyncCoordinator.kt b/data/src/main/java/com/streamvault/data/sync/SyncCoordinator.ktnew file mode 100644index 00000000..2883b3f6--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/SyncCoordinator.kt@@ -0,0 +1,81 @@+package com.streamvault.data.sync++import com.streamvault.domain.model.ProviderSnapshot+import com.streamvault.domain.provider.CapabilityResolution++/**+ * Provider-neutral orchestration boundary for catalog and guide work.+ *+ * Provider-specific policy lives behind [CatalogSyncPlan] implementations. This class owns+ * resolution and keeps callers from reintroducing provider-type switches for full sync, section+ * repair, or guide refresh.+ */+internal class SyncCoordinator(+ private val plans: CatalogSyncPlanRegistry,+ private val continuationScheduler: SyncContinuationScheduler = SyncContinuationScheduler.NONE+) {+ suspend fun syncFull(request: FullProviderSyncRequest): CapabilityResolution<SyncOutcome> =+ resolve(request.snapshot).map {+ handOffContinuations(request.snapshot, SyncActivationPolicy.validate(it.syncFull(request)))+ }++ suspend fun syncSection(+ request: SectionProviderSyncRequest+ ): CapabilityResolution<SyncOutcome> = resolve(request.snapshot)+ .flatMap { it.syncSection(request) }+ .validateOutcome(request.snapshot)++ suspend fun syncGuide(+ request: ProviderGuideSyncRequest+ ): CapabilityResolution<ProviderGuideSyncResult> = resolve(request.snapshot).flatMap { it.syncGuide(request) }++ fun resolve(snapshot: ProviderSnapshot): CapabilityResolution<CatalogSyncPlan> = plans.resolve(snapshot)++ private suspend fun <T, R> CapabilityResolution<T>.flatMap(+ block: suspend (T) -> CapabilityResolution<R>+ ): CapabilityResolution<R> = when (this) {+ is CapabilityResolution.Available -> block(capability)+ is CapabilityResolution.ConfigurationError -> this+ is CapabilityResolution.Restricted -> this+ is CapabilityResolution.Unsupported -> this+ }++ private suspend fun <T, R> CapabilityResolution<T>.map(+ block: suspend (T) -> R+ ): CapabilityResolution<R> = when (this) {+ is CapabilityResolution.Available -> CapabilityResolution.Available(block(capability))+ is CapabilityResolution.ConfigurationError -> this+ is CapabilityResolution.Restricted -> this+ is CapabilityResolution.Unsupported -> this+ }++ private suspend fun CapabilityResolution<SyncOutcome>.validateOutcome(+ snapshot: ProviderSnapshot+ ): CapabilityResolution<SyncOutcome> =+ when (this) {+ is CapabilityResolution.Available -> CapabilityResolution.Available(+ handOffContinuations(snapshot, SyncActivationPolicy.validate(capability))+ )+ is CapabilityResolution.ConfigurationError -> this+ is CapabilityResolution.Restricted -> this+ is CapabilityResolution.Unsupported -> this+ }++ private suspend fun handOffContinuations(+ snapshot: ProviderSnapshot,+ outcome: SyncOutcome+ ): SyncOutcome {+ if (outcome.continuationWork.isNotEmpty()) {+ continuationScheduler.schedule(snapshot, outcome.continuationWork)+ }+ return outcome+ }+}++internal fun interface SyncContinuationScheduler {+ suspend fun schedule(snapshot: ProviderSnapshot, work: List<SyncContinuation>)++ companion object {+ val NONE = SyncContinuationScheduler { _, _ -> }+ }+}diff --git a/data/src/main/java/com/streamvault/data/sync/SyncManager.kt b/data/src/main/java/com/streamvault/data/sync/SyncManager.ktindex 14bff4c6..53fbcee3 100644--- a/data/src/main/java/com/streamvault/data/sync/SyncManager.kt+++ b/data/src/main/java/com/streamvault/data/sync/SyncManager.kt@@ -14,7 +14,6 @@ import com.streamvault.data.local.dao.ProviderDaoimport com.streamvault.data.local.dao.ProviderWorkflowDaoimport com.streamvault.data.local.dao.SeriesCategoryHydrationDaoimport com.streamvault.data.local.dao.SeriesDao-import com.streamvault.data.local.dao.StalkerIndexJobDaoimport com.streamvault.data.local.dao.TmdbIdentityDaoimport com.streamvault.data.local.dao.VodCategoryHydrationDaoimport com.streamvault.data.local.dao.VodCatalogEntryDao@@ -23,14 +22,11 @@ import com.streamvault.data.local.dao.XtreamIndexJobDaoimport com.streamvault.data.local.dao.XtreamLiveOnboardingDaoimport com.streamvault.data.local.entity.CategoryEntityimport com.streamvault.data.local.entity.ChannelEntity-import com.streamvault.data.local.entity.ChannelGuideSyncEntityimport com.streamvault.data.local.entity.MovieEntityimport com.streamvault.data.local.entity.SeriesEntity-import com.streamvault.data.local.entity.StalkerIndexJobEntityimport com.streamvault.data.local.entity.VodCatalogEntryEntityimport com.streamvault.data.local.entity.VodCategoryHydrationEntityimport com.streamvault.data.local.entity.XtreamContentIndexEntity-import com.streamvault.data.local.entity.XtreamIndexJobEntityimport com.streamvault.data.local.entity.XtreamLiveOnboardingStateEntityimport com.streamvault.data.mapper.toDomainimport com.streamvault.data.mapper.toEntity@@ -68,9 +64,9 @@ import com.streamvault.data.remote.xtream.XtreamApiServiceimport com.streamvault.data.remote.xtream.XtreamProviderimport com.streamvault.data.remote.xtream.XtreamUrlFactoryimport com.streamvault.data.security.CredentialCrypto-import com.streamvault.data.provider.toProviderSnapshotimport com.streamvault.data.provider.TypedProviderClientFactoryimport com.streamvault.data.provider.XtreamClientOptions+import com.streamvault.data.provider.StalkerPlaybackCapabilityCacheimport com.streamvault.data.util.AdultContentClassifierimport com.streamvault.data.util.runSuspendCatchingimport com.streamvault.data.util.UrlSecurityPolicy@@ -85,8 +81,6 @@ import com.streamvault.domain.model.ProviderTypeimport com.streamvault.domain.model.Resultimport com.streamvault.domain.model.Seriesimport com.streamvault.domain.model.VodCatalogItem-import com.streamvault.domain.model.StalkerCatalogMode-import com.streamvault.domain.model.StalkerIndexStateimport com.streamvault.domain.model.StalkerRequestPriorityimport com.streamvault.domain.model.StalkerTransportGrantimport com.streamvault.domain.model.StalkerTransportMode@@ -95,7 +89,6 @@ import com.streamvault.domain.model.SyncMetadataimport com.streamvault.domain.model.SyncStateimport com.streamvault.domain.model.VodSyncModeimport com.streamvault.domain.model.XtreamConfig-import com.streamvault.data.provider.toLegacyProviderimport com.streamvault.domain.repository.EpgRepositoryimport com.streamvault.domain.repository.EpgSourceRepositoryimport com.streamvault.domain.repository.SyncMetadataRepository@@ -119,8 +112,6 @@ import kotlinx.coroutines.flow.firstimport kotlinx.coroutines.flow.mapimport kotlinx.coroutines.withContextimport kotlin.coroutines.coroutineContext-import kotlinx.coroutines.sync.Mutex-import kotlinx.coroutines.sync.withLockimport kotlinx.serialization.json.Jsonimport okhttp3.OkHttpClientimport okhttp3.Request@@ -130,9 +121,6 @@ import java.io.IOExceptionimport java.io.InputStreamimport java.net.URIimport java.security.MessageDigest-import java.util.ArrayDeque-import java.util.concurrent.ConcurrentHashMap-import java.util.concurrent.atomic.AtomicLongimport java.util.zip.GZIPInputStreamimport javax.inject.Injectimport javax.inject.Singleton@@ -140,25 +128,6 @@ import javax.inject.Singletonprivate const val TAG = "SyncManager"private const val XTREAM_FALLBACK_STAGE_BATCH_SIZE = 500private const val STALKER_INDEX_CATEGORY_SLICE_SIZE = 32-private const val STALKER_WILDCARD_PAGE_SLICE_SIZE = 192-private const val STALKER_COMPLETE_PAGE_BATCH_SIZE = 200-private const val STALKER_MAX_PARALLEL_CATEGORY_FETCHES = 2-private const val STALKER_MAX_SECTION_RUN_MILLIS = 240_000L-private const val STALKER_CATEGORY_RETRY_BUDGET = 3-private const val STALKER_CATEGORY_RETRY_COOLDOWN_MILLIS = 5 * 60 * 1000L-private const val STALKER_RUNNING_JOB_STALE_MILLIS = 15 * 60 * 1000L-private const val STALKER_MIN_HEALTHY_EPG_PROGRAMS = 3-// Bulk live is an optimization. Large portals stream tens of MB over a single-// response and can spend 8s+ generating it before the first byte. Cancel only-// when the stream stalls (no items for the stall window); an absolute wall-clock-// cap would kill healthy transfers that continue making progress.-private const val STALKER_BULK_LIVE_STALL_TIMEOUT_MILLIS = 30_000L-private const val STALKER_BULK_LIVE_STALL_CHECK_INTERVAL_MILLIS = 1_000L-// A negative bulk-live verdict expires far sooner than the 7-day validated-// portal state: re-probing costs one fast request, while a stale false verdict-// forces the very slow per-category path on every sync. Portals that recorded-// "unsupported" under the old fixed-timeout logic self-heal through this.-private const val STALKER_BULK_LIVE_UNSUPPORTED_TTL_MILLIS = 6 * 60 * 60 * 1000Lprivate const val LIVE_CATEGORY_SEQUENTIAL_MODE_WARNING ="Live category sync downgraded to sequential mode after provider stress signals."private const val XTREAM_RECOVERY_ABORT_WARNING_SUFFIX =@@ -167,31 +136,6 @@ private const val XTREAM_AVOID_FULL_CATALOG_COOLDOWN_MILLIS = 6 * 60 * 60 * 1000private const val XTREAM_MOVIE_REQUEST_TIMEOUT_MILLIS = 60_000Lprivate const val XTREAM_SERIES_REQUEST_TIMEOUT_MILLIS = 60_000Lprivate const val XTREAM_SQLITE_LOOKUP_CHUNK_SIZE = 900-private const val STALKER_GUIDE_PROGRAM_BATCH_SIZE = 500-private const val XTREAM_ONBOARDING_PHASE_STARTING = "STARTING"-private const val XTREAM_ONBOARDING_PHASE_FETCHING = "FETCHING"-private const val XTREAM_ONBOARDING_PHASE_RECOVERING = "RECOVERING"-private const val XTREAM_ONBOARDING_PHASE_STAGED = "STAGED"-private const val XTREAM_ONBOARDING_PHASE_COMMITTING = "COMMITTING"-private const val XTREAM_ONBOARDING_PHASE_COMPLETED = "COMPLETED"-private const val XTREAM_ONBOARDING_PHASE_FAILED = "FAILED"-/**- * Maximum number of programs we will accept from a single per-channel `get_epg_info`- * call before treating the response as a portal that ignores `ch_id` and returns the- * full bulk EPG. Probed real-world portals return at most ~150 programs/channel for a- * 6h period; 5 000 leaves ample headroom while still catching multi-megabyte payloads.- */-private const val STALKER_PER_CHANNEL_RECORD_SANITY_CAP = 5_000-private const val STALKER_PER_CHANNEL_EPG_REQUESTS_PER_RUN = 48-private const val MILLIS_PER_DAY = 24L * 60L * 60L * 1000L--/**- * Sentinel exception raised inside the streamed per-channel EPG callback when we detect- * that the portal is returning the bulk payload regardless of the requested `ch_id`.- * Caught and converted into a warning by [SyncManager.syncStalkerPortalEpg].- */-private class StalkerBrokenPerChannelEpgException(channelName: String) :- RuntimeException("Stalker portal returned bulk-shaped EPG for per-channel request ($channelName)")internal suspend fun <K, V> chunkedLookupById(ids: List<K>,@@ -207,11 +151,6 @@ internal suspend fun <K, V> chunkedLookupById(.associateBy(keySelector)}-private data class XtreamLiveCommitResult(- val acceptedCount: Int,- val warnings: List<String>-)-/** Ensures a pending provider edit is promoted by only the first durable catalog commit. */private class CatalogCommitGate(private val afterCatalogApply: suspend () -> Unit@@ -252,16 +191,16 @@ class SyncManager @Inject constructor(private val tmdbIdentityDao: TmdbIdentityDao,private val xtreamContentIndexDao: XtreamContentIndexDao,private val xtreamIndexJobDao: XtreamIndexJobDao,- private val stalkerIndexJobDao: StalkerIndexJobDao,+ private val stalkerIndexJobStore: StalkerIndexJobStore,private val xtreamLiveOnboardingDao: XtreamLiveOnboardingDao,private val episodeDao: EpisodeDao,- private val jellyfinProvider: JellyfinProvider,+ jellyfinProvider: JellyfinProvider,private val xtreamJson: Json,private val m3uParser: M3uParser,private val epgRepository: EpgRepository,private val epgSourceRepository: EpgSourceRepository,private val okHttpClient: OkHttpClient,- private val credentialCrypto: CredentialCrypto,+ credentialCrypto: CredentialCrypto,private val syncMetadataRepository: SyncMetadataRepository,private val transactionRunner: DatabaseTransactionRunner,private val preferencesRepository: com.streamvault.data.preferences.PreferencesRepository,@@ -272,9 +211,17 @@ class SyncManager @Inject constructor(private val providerWorkflowCommitFence: ProviderWorkflowCommitFence,private val typedProviderClientFactory: TypedProviderClientFactory,private val providerSnapshotRepository: ProviderSnapshotRepository? = null,- private val providerWorkflowDao: ProviderWorkflowDao? = null-) {- private val syncStateTracker = SyncStateTracker()+ providerWorkflowDao: ProviderWorkflowDao? = null,+ private val providerWorkLocks: ProviderWorkLockRegistry,+ private val providerSyncLocks: ProviderSyncLockRegistry,+ private val stalkerPlaybackCapabilityCache: StalkerPlaybackCapabilityCache,+ private val providerSyncWorkScheduler: ProviderSyncWorkScheduler+) : ProviderSyncCommands, CatalogHydrationCommands, ProviderSyncStateSource, ProviderSyncLifecycle {+ private val syncProviderSnapshotAdapter = SyncProviderSnapshotAdapter(providerSnapshotRepository)+ private val syncStatusPublicationCoordinator = SyncStatusPublicationCoordinator(+ syncMetadataRepository = syncMetadataRepository,+ syncProgressBus = syncProgressBus+ )private val syncErrorSanitizer = SyncErrorSanitizer()private val xtreamAdaptiveSyncPolicy = XtreamAdaptiveSyncPolicy()private val syncCatalogStore = SyncCatalogStore(@@ -287,6 +234,168 @@ class SyncManager @Inject constructor(transactionRunner = transactionRunner,workflowCommitFence = providerWorkflowCommitFence)+ private val catalogIndexJobStore = CatalogIndexJobStore(+ providerDao = providerDao,+ xtreamIndexJobDao = xtreamIndexJobDao,+ stalkerIndexJobStore = stalkerIndexJobStore+ )+ private val stalkerIndexCheckpointStore = StalkerIndexCheckpointStore(+ movieHydrationDao = movieCategoryHydrationDao,+ seriesHydrationDao = seriesCategoryHydrationDao+ )+ private val stalkerIndexContinuationCoordinator by lazy {+ StalkerIndexContinuationCoordinator(+ stalkerIndexJobStore = stalkerIndexJobStore,+ loadCategories = { providerId, contentType ->+ categoryDao.getByProviderAndTypeSync(providerId, contentType.name)+ },+ loadHydration = stalkerIndexCheckpointStore::getHydrationSnapshot,+ visibleCategories = { providerId, contentType, categories, api ->+ visibleStalkerIndexCategories(+ contentType,+ allVisibleStalkerIndexCategories(providerId, contentType, categories),+ api+ )+ },+ loadProvider = ::loadCompatibilityProvider,+ loadStalkerProviders = {+ providerDao.getAllSync()+ .filter { provider -> provider.type == ProviderType.STALKER_PORTAL }+ .map { provider -> provider.id }+ },+ deleteLegacyJobs = { providerId -> xtreamIndexJobDao.deleteByProvider(providerId) },+ cancelIndex = ::cancelStalkerIndexSync,+ scheduleIndex = { providerId, initialDelaySeconds, appendSuccessor ->+ providerSyncWorkScheduler.scheduleStalkerIndex(+ providerId = providerId,+ force = false,+ initialDelaySeconds = initialDelaySeconds,+ appendSuccessor = appendSuccessor+ )+ },+ scheduleBackgroundEpg = providerSyncWorkScheduler::scheduleBackgroundEpg,+ log = { message -> Log.i(TAG, message) }+ )+ }+ private val stalkerIncrementalIndexExecutor by lazy {+ StalkerIncrementalIndexExecutor(+ operations = CallbackStalkerIncrementalIndexOperations(+ StalkerIncrementalIndexCallbacks(+ runtimeProfile = { CatalogSyncRuntimeProfile.from(applicationContext) },+ allVisibleCategories = { providerId, contentType ->+ allVisibleStalkerIndexCategories(+ providerId = providerId,+ contentType = contentType,+ categories = categoryDao.getByProviderAndTypeSync(providerId, contentType.name)+ )+ },+ visibleCategories = { contentType, categories, api ->+ visibleStalkerIndexCategories(contentType, categories, api)+ },+ getJob = { providerId, contentType -> stalkerIndexJobStore.get(providerId, contentType) },+ getHydration = stalkerIndexCheckpointStore::getHydrationSnapshot,+ currentIndexedRowCount = ::currentStalkerIndexedRowCount,+ pruneStaleRows = { providerId, contentType ->+ xtreamContentIndexDao.pruneStaleLocalContentRows(providerId, contentType.name)+ },+ updateSummaryMetadata = ::updateStalkerSummaryMetadata,+ fetchSummaryPage = { provider, api, contentType, categoryId, page ->+ withStalkerFetchPermit(provider, contentType, categoryId, page) {+ fetchStalkerSummaryPageWithRecovery(+ api = api,+ contentType = contentType,+ categoryId = categoryId,+ page = page,+ splitVod = provider.catalogLayout == CatalogLayout.SPLIT+ )+ }+ },+ fetchWildcardPage = { provider, api, contentType, categoryId, page ->+ withStalkerFetchPermit(provider, contentType, categoryId, page) {+ fetchStalkerWildcardSummaryPageWithRecovery(api, contentType, categoryId, page)+ }+ },+ markAttemptStarted = stalkerIndexCheckpointStore::markAttemptStarted,+ markAttemptSucceeded = stalkerIndexCheckpointStore::markAttemptSucceeded,+ markAttemptFailed = stalkerIndexCheckpointStore::markAttemptFailed,+ upsertMovieSummaryBatch = { providerId, movies, indexedAt ->+ upsertXtreamMovieSummaryBatch(providerId, movies, indexedAt, restoreWatchProgress = false)+ },+ upsertSeriesSummaryBatch = { providerId, series, indexedAt ->+ upsertXtreamSeriesSummaryBatch(providerId, series, indexedAt)+ },+ upsertVodDerivedSeriesSummaryBatch = { providerId, series, indexedAt ->+ [email protected](providerId, series, indexedAt)+ },+ recordRequestFailure = { providerId, error ->+ stalkerRequestCoordinator.recordFailure(providerId, error)+ },+ failureState = { error ->+ StalkerIndexRecoveryPolicy.failureState(error, ::sanitizeThrowableMessage)+ },+ progress = ::progress,+ restoreMovieWatchProgress = { providerId -> movieDao.restoreWatchProgress(providerId) },+ upsertJob = catalogIndexJobStore::upsert,+ log = { message -> Log.i(TAG, message) }+ )+ )+ )+ }+ private val xtreamIncrementalIndexExecutor by lazy {+ XtreamIncrementalIndexExecutor(+ operations = CallbackXtreamIncrementalIndexOperations(+ XtreamIncrementalIndexCallbacks(+ getCategories = { providerId, contentType ->+ categoryDao.getByProviderAndTypeSync(providerId, contentType.name)+ },+ ensureCategoryShell = { provider, api, contentType, now, onProgress ->+ xtreamCatalogSectionExecutor.syncCategoryShell(+ provider = provider,+ api = api,+ contentType = contentType,+ label = xtreamIndexSectionLabel(contentType),+ now = now,+ onProgress = onProgress+ ).getOrThrow()+ },+ getJob = { providerId, contentType ->+ xtreamIndexJobDao.get(providerId, contentType.name)+ },+ shouldRunSummary = catalogIndexJobStore::shouldRunSummary,+ fetchMovieCategory = { provider, api, category ->+ fetchMovieCategoryOutcome(provider, api, category.toXtreamCategory())+ },+ fetchSeriesCategory = { provider, api, category ->+ fetchSeriesCategoryOutcome(provider, api, category.toXtreamCategory())+ },+ upsertMovieSummaryBatch = { providerId, movies, indexedAt ->+ upsertXtreamMovieSummaryBatch(+ providerId = providerId,+ movies = movies,+ indexedAt = indexedAt,+ restoreWatchProgress = false+ )+ },+ upsertSeriesSummaryBatch = ::upsertXtreamSeriesSummaryBatch,+ streamMovies = { _, api, adultCategoryIds, onBatch ->+ api.streamVodSummaries(adultCategoryIds = adultCategoryIds, onBatch = onBatch)+ },+ streamSeries = { _, api, adultCategoryIds, onBatch ->+ api.streamSeriesSummaries(adultCategoryIds = adultCategoryIds, onBatch = onBatch)+ },+ upsertJob = catalogIndexJobStore::upsert,+ updateSummaryMetadata = ::updateXtreamSummaryMetadata,+ scheduleIndex = { providerId, contentType ->+ scheduleXtreamIndexSync(providerId, contentType, force = false)+ },+ progress = ::progress,+ restoreMovieWatchProgress = { providerId -> movieDao.restoreWatchProgress(providerId) },+ sanitize = ::sanitizeThrowableMessage,+ log = { message -> Log.i(TAG, message) }+ )+ )+ )+ }private val m3uImporter = SyncManagerM3uImporter(m3uParser = m3uParser,okHttpClient = okHttpClient,@@ -295,6 +404,46 @@ class SyncManager @Inject constructor(progress = ::progress,emitProgress = ::emitProviderProgress)+ private val m3uCatalogExecutor by lazy {+ M3uCatalogSyncExecutor(+ importer = m3uImporter,+ syncMetadataRepository = syncMetadataRepository,+ epgSourceRepository = epgSourceRepository,+ countPrograms = { providerId -> programDao.countByProvider(providerId) },+ shouldSyncEpgUpfront = ::shouldSyncEpgUpfront,+ updateEpgJobState = ::updateXtreamEpgJobState,+ refreshGuide = providerEpgExecutor::syncM3uProviderEpg,+ markBackgroundEpgQueued = { providerId, now ->+ upsertXtreamIndexJob(+ providerId = providerId,+ section = "EPG",+ state = "QUEUED",+ now = now,+ totalCategories = 1,+ completedCategories = 0,+ nextCategoryIndex = 0,+ failedCategories = 0,+ lastAttemptAt = now,+ lastError = null+ )+ },+ progress = ::progress,+ sanitizeThrowableMessage = ::sanitizeThrowableMessage+ )+ }+ private val jellyfinCatalogExecutor by lazy {+ JellyfinCatalogSyncExecutor(+ jellyfinProvider = jellyfinProvider,+ credentialCrypto = credentialCrypto,+ syncCatalogStore = syncCatalogStore,+ catalogSyncDao = catalogSyncDao,+ providerWorkflowDao = providerWorkflowDao,+ syncMetadataRepository = syncMetadataRepository,+ movieDao = movieDao,+ seriesDao = seriesDao,+ progress = ::progress+ )+ }private val xtreamSupport = SyncManagerXtreamSupport(adaptiveSyncPolicy = xtreamAdaptiveSyncPolicy,shouldRememberSequentialPreference = ::shouldRememberSequentialPreference,@@ -304,607 +453,242 @@ class SyncManager @Inject constructor(seriesRequestTimeoutMillis = XTREAM_SERIES_REQUEST_TIMEOUT_MILLIS,recoveryAbortWarningSuffix = XTREAM_RECOVERY_ABORT_WARNING_SUFFIX)- private val providerSyncRegistry: ProviderSyncAdapterRegistry by lazy {- ProviderSyncAdapterRegistry(- listOf(- LambdaProviderSyncAdapter(- providerType = ProviderType.XTREAM_CODES,- full = { request ->- val provider = request.snapshot.toSyncCompatibilityProvider()- syncXtreamIndexFirst(- provider = provider,- force = request.force,- onProgress = request.onProgress,- trackInitialLiveOnboarding = request.trackInitialLiveOnboarding,- syncReason = if (request.trackInitialLiveOnboarding) {- XtreamLiveSyncReason.INITIAL_ONBOARDING- } else {- XtreamLiveSyncReason.FOREGROUND- },- afterCatalogApply = request.afterCatalogApply- )- },- section = { request ->- val provider = request.snapshot.toSyncCompatibilityProvider()- CapabilityResolution.Available(when (request.section) {- SyncRepairSection.LIVE -> syncXtreamLiveOnly(provider, request.syncReason, request.onProgress)- SyncRepairSection.EPG -> {- syncXtreamEpgOnly(provider, request.onProgress)- SyncOutcome()- }- SyncRepairSection.MOVIES -> syncXtreamMoviesOnly(provider, request.onProgress)- SyncRepairSection.SERIES -> syncXtreamSeriesOnly(provider, request.onProgress)- })- },- guide = { request ->- val provider = request.snapshot.toSyncCompatibilityProvider()- CapabilityResolution.Available(- syncXtreamProviderEpg(- provider,- syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id),- request.now,- request.force,- request.onProgress- )- )- }- ),- LambdaProviderSyncAdapter(- providerType = ProviderType.M3U,- full = { request ->- syncM3u(request.snapshot.toSyncCompatibilityProvider(), request.force, request.onProgress, request.afterCatalogApply)- },- section = { request ->- val provider = request.snapshot.toSyncCompatibilityProvider()- when (request.section) {- SyncRepairSection.LIVE -> CapabilityResolution.Available(- syncM3uLiveOnly(provider, request.onProgress)- )- SyncRepairSection.MOVIES -> CapabilityResolution.Available(- syncM3uMoviesOnly(provider, request.onProgress)- )- SyncRepairSection.EPG -> {- syncM3uEpgOnly(provider, request.onProgress)- CapabilityResolution.Available(SyncOutcome())- }- SyncRepairSection.SERIES -> CapabilityResolution.Unsupported(- "Series retry is unavailable for M3U providers"- )- }},- guide = { request ->- val provider = request.snapshot.toSyncCompatibilityProvider()- CapabilityResolution.Available(- syncM3uProviderEpg(- provider,- syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id),- request.now,- request.force,- request.onProgress- )- )- }- ),- LambdaProviderSyncAdapter(- providerType = ProviderType.STALKER_PORTAL,- full = { request ->- val provider = request.snapshot.toSyncCompatibilityProvider()- syncStalker(- provider = provider,- force = request.force,- onProgress = request.onProgress,- afterCatalogApply = request.afterCatalogApply,- deferProviderStateUntilCatalogCommit = request.deferProviderStateUntilCatalogCommit- )- },- section = { request ->- val provider = request.snapshot.toSyncCompatibilityProvider()- CapabilityResolution.Available(when (request.section) {- SyncRepairSection.LIVE -> syncStalkerLiveOnly(provider, request.onProgress)- SyncRepairSection.EPG -> {- syncStalkerEpgOnly(provider, request.onProgress)- SyncOutcome()- }- SyncRepairSection.MOVIES -> syncStalkerMoviesOnly(provider, request.onProgress)- SyncRepairSection.SERIES -> syncStalkerSeriesOnly(provider, request.onProgress)- }) },- guide = { request ->- val provider = request.snapshot.toSyncCompatibilityProvider()- CapabilityResolution.Available(- syncStalkerProviderEpg(- provider,- syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id),- request.now,- request.force,- request.onProgress- )- )- }- ),- LambdaProviderSyncAdapter(- providerType = ProviderType.JELLYFIN,- full = { request ->- syncJellyfin(request.snapshot.toSyncCompatibilityProvider(), request.force, request.onProgress, request.afterCatalogApply)- },- section = { request ->- val provider = request.snapshot.toSyncCompatibilityProvider()- when (request.section) {- SyncRepairSection.MOVIES -> {- syncJellyfinMoviesOnly(provider, request.onProgress)- CapabilityResolution.Available(SyncOutcome())- }- SyncRepairSection.SERIES -> {- syncJellyfinSeriesOnly(provider, request.onProgress)- CapabilityResolution.Available(SyncOutcome())- }- SyncRepairSection.LIVE -> CapabilityResolution.Unsupported(- "Live TV retry is unavailable for Jellyfin providers"- )- SyncRepairSection.EPG -> CapabilityResolution.Unsupported(- "Native guide retry is unavailable for Jellyfin providers"- )- }},- guide = { request ->- val provider = request.snapshot.toSyncCompatibilityProvider()- CapabilityResolution.Available(- syncJellyfinProviderEpg(- provider,- syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id),- request.now,- request.force,- request.onProgress- )- )- }+ private val providerEpgExecutor by lazy {+ ProviderEpgSyncExecutor(+ preferencesRepository = preferencesRepository,+ epgRepository = epgRepository,+ epgSourceRepository = epgSourceRepository,+ channelDao = channelDao,+ programDao = programDao,+ transactionRunner = transactionRunner,+ syncMetadataRepository = syncMetadataRepository,+ stalkerPortalStateStore = stalkerPortalStateStore,+ stalkerRequestCoordinator = stalkerRequestCoordinator,+ createStalkerProvider = ::createStalkerSyncProvider,+ xtreamSupport = xtreamSupport,+ progress = ::progress,+ sanitizeThrowableMessage = ::sanitizeThrowableMessage+ )+ }+ private val xtreamCatalogSectionExecutor by lazy {+ XtreamCatalogSectionExecutor(+ preferencesRepository = preferencesRepository,+ syncMetadataRepository = syncMetadataRepository,+ syncCatalogStore = syncCatalogStore,+ createProvider = ::createXtreamSyncProvider,+ markIndexRunning = { providerId, contentType, now ->+ upsertXtreamIndexJob(+ providerId = providerId,+ section = contentType.name,+ state = "RUNNING",+ now = now,+ lastAttemptAt = now)- )+ },+ markIndexQueued = { providerId, contentType, now, totalCategories ->+ upsertXtreamIndexJob(+ providerId = providerId,+ section = contentType.name,+ state = "QUEUED",+ now = now,+ totalCategories = totalCategories,+ completedCategories = 0,+ nextCategoryIndex = 0,+ failedCategories = 0,+ indexedRows = 0,+ skippedMalformedRows = 0,+ lastAttemptAt = now,+ lastError = null+ )+ },+ markIndexFailure = { providerId, contentType, now, error ->+ upsertXtreamIndexJob(+ providerId = providerId,+ section = contentType.name,+ state = XtreamIndexRecoveryPolicy.failureState(error),+ now = now,+ lastAttemptAt = now,+ lastError = sanitizeThrowableMessage(error)+ )+ },+ progress = ::progress,+ sanitizeThrowableMessage = ::sanitizeThrowableMessage,+ userMessage = { error, fallback -> syncErrorSanitizer.userMessage(error, fallback) }+ )+ }+ private val stalkerCatalogSectionExecutor by lazy {+ StalkerCatalogSectionExecutor(+ movieCategoryHydrationDao = movieCategoryHydrationDao,+ seriesCategoryHydrationDao = seriesCategoryHydrationDao,+ xtreamContentIndexDao = xtreamContentIndexDao,+ syncCatalogStore = syncCatalogStore,+ movieDao = movieDao,+ seriesDao = seriesDao,+ syncMetadataRepository = syncMetadataRepository,+ createProvider = ::createStalkerSyncProvider,+ updateIndexJob = { providerId, contentType, totalCategories, now ->+ upsertXtreamIndexJob(+ providerId = providerId,+ section = contentType.name,+ state = "QUEUED",+ now = now,+ totalCategories = totalCategories,+ completedCategories = 0,+ nextCategoryIndex = 0,+ failedCategories = 0,+ indexedRows = 0,+ skippedMalformedRows = 0,+ deletedPrunedRows = 0,+ clearPriority = true,+ lastAttemptAt = now,+ lastError = null+ )+ },+ emitSectionProgress = { providerId, section, total, itemsIndexed ->+ emitCatalogSyncProgress(+ providerId,+ section = section,+ total = total,+ itemsIndexed = itemsIndexed+ )+ },+ progress = ::progress+ )+ }+ private val xtreamCatalogExecutor by lazy {+ XtreamCatalogSyncExecutor(+ applicationContext = applicationContext,+ preferencesRepository = preferencesRepository,+ syncMetadataRepository = syncMetadataRepository,+ channelDao = channelDao,+ categoryDao = categoryDao,+ xtreamLiveOnboardingDao = xtreamLiveOnboardingDao,+ syncCatalogStore = syncCatalogStore,+ sectionExecutor = xtreamCatalogSectionExecutor,+ liveStrategy = xtreamLiveStrategy,+ catalogStrategySupport = catalogStrategySupport,+ createProvider = ::createXtreamSyncProvider,+ updateIndexJob = { update ->+ upsertXtreamIndexJob(+ providerId = update.providerId,+ section = update.section,+ state = update.state,+ now = update.now,+ totalCategories = update.totalCategories,+ completedCategories = update.completedCategories,+ indexedRows = update.indexedRows,+ lastAttemptAt = update.lastAttemptAt,+ lastError = update.lastError+ )+ },+ indexFailureState = XtreamIndexRecoveryPolicy::failureState,+ shouldRememberSequentialPreference = ::shouldRememberSequentialPreference,+ progress = ::progress,+ emitProgress = ::emitProviderProgress,+ sanitizeThrowableMessage = ::sanitizeThrowableMessage,+ userMessage = { error, fallback -> syncErrorSanitizer.userMessage(error, fallback) }+ )+ }+ private val stalkerSyncExecutor by lazy {+ StalkerCatalogSyncExecutor(+ applicationContext = applicationContext,+ preferencesRepository = preferencesRepository,+ syncMetadataRepository = syncMetadataRepository,+ providerSnapshotRepository = providerSnapshotRepository,+ transactionRunner = transactionRunner,+ categoryDao = categoryDao,+ channelDao = channelDao,+ movieCategoryHydrationDao = movieCategoryHydrationDao,+ seriesCategoryHydrationDao = seriesCategoryHydrationDao,+ vodCategoryHydrationDao = vodCategoryHydrationDao,+ vodCatalogEntryDao = vodCatalogEntryDao,+ movieDao = movieDao,+ seriesDao = seriesDao,+ syncCatalogStore = syncCatalogStore,+ catalogStager = catalogStager,+ catalogStrategySupport = catalogStrategySupport,+ categoryRecoverySupport = xtreamSupport,+ sectionExecutor = stalkerCatalogSectionExecutor,+ readinessTracker = stalkerReadinessTracker,+ createProvider = ::createStalkerSyncProvider,+ syncProviderEpg = providerEpgExecutor::syncStalkerProviderEpg,+ progress = ::progress,+ emitCatalogProgress = { providerId, section, total, itemsIndexed ->+ emitCatalogSyncProgress(providerId, section, total ?: 0, itemsIndexed ?: 0)+ },+ categoryFailureWarning = ::categoryFailureWarning,+ sanitizeThrowableMessage = ::sanitizeThrowableMessage+ )+ }+ private val syncCoordinator: SyncCoordinator by lazy {+ SyncCoordinator(+ CatalogSyncPlanAssembler(+ delegate = SyncManagerPlanDelegate(+ snapshotAdapter = syncProviderSnapshotAdapter,+ syncMetadataRepository = syncMetadataRepository,+ xtreamCatalogExecutor = xtreamCatalogExecutor,+ xtreamCatalogSectionExecutor = xtreamCatalogSectionExecutor,+ providerEpgExecutor = providerEpgExecutor,+ m3uCatalogExecutor = m3uCatalogExecutor,+ stalkerSyncExecutor = stalkerSyncExecutor,+ stalkerCatalogSectionExecutor = stalkerCatalogSectionExecutor,+ jellyfinCatalogExecutor = jellyfinCatalogExecutor+ )+ ).create(),+ continuationScheduler = ProviderContinuationScheduler(providerSyncWorkScheduler))}private suspend fun loadCompatibilityProvider(providerId: Long): Provider? =- providerSnapshotRepository?.getSnapshot(providerId)?.toLegacyProvider()- val syncState: StateFlow<SyncState> = syncStateTracker.aggregateState- val syncStatesByProvider: StateFlow<Map<Long, SyncState>> = syncStateTracker.statesByProvider- private val providerSyncMutexes = ConcurrentHashMap<Long, Mutex>()- private val providerStalkerSummaryMutexes = ConcurrentHashMap<Long, Mutex>()- private val providerStalkerIndexSectionMutexes = ConcurrentHashMap<String, Mutex>()- private val providerVodCategoryMutexes = ConcurrentHashMap<String, Mutex>()- private val providerEpgMutexes = ConcurrentHashMap<Long, Mutex>()- private val syncAdmissionMutex = Mutex()-- suspend fun hydrateUnifiedVodCategory(+ syncProviderSnapshotAdapter.getLegacyProvider(providerId)+ val syncState: StateFlow<SyncState> = syncStatusPublicationCoordinator.syncState+ val syncStatesByProvider: StateFlow<Map<Long, SyncState>> =+ syncStatusPublicationCoordinator.syncStatesByProvider++ private val vodCategoryHydrationCoordinator by lazy {+ VodCategoryHydrationCoordinator(+ providerSyncLocks = providerSyncLocks,+ categoryDao = categoryDao,+ movieCategoryHydrationDao = movieCategoryHydrationDao,+ seriesCategoryHydrationDao = seriesCategoryHydrationDao,+ vodCategoryHydrationDao = vodCategoryHydrationDao,+ movieDao = movieDao,+ seriesDao = seriesDao,+ vodCatalogEntryDao = vodCatalogEntryDao,+ transactionRunner = transactionRunner,+ loadProvider = ::loadCompatibilityProvider,+ createProvider = ::createStalkerSyncProvider+ )+ }++ override suspend fun hydrateUnifiedVodCategory(providerId: Long,categoryId: Long,request: com.streamvault.domain.model.VodCategoryHydrationRequest- ): Result<Unit> {- val requestedPage = if (request == com.streamvault.domain.model.VodCategoryHydrationRequest.NEXT_PAGE) {- ((vodCategoryHydrationDao.get(providerId, categoryId)?.lastSuccessfulPage ?: 0) + 1).coerceAtLeast(1)- } else {- null- }- val lock = providerVodCategoryMutexes.computeIfAbsent("$providerId:$categoryId") { Mutex() }- return lock.withLock {- val providerEntity = loadCompatibilityProvider(providerId)- ?: return@withLock Result.error("Provider not found")- if (providerEntity.type != ProviderType.STALKER_PORTAL) {- return@withLock Result.success(Unit)- }- val current = vodCategoryHydrationDao.get(providerId, categoryId)- if (current?.isComplete == true ||- (requestedPage != null && current != null && current.lastSuccessfulPage >= requestedPage) ||- (request == com.streamvault.domain.model.VodCategoryHydrationRequest.OPEN &&- (current?.lastSuccessfulPage ?: 0) > 0)- ) {- return@withLock Result.success(Unit)- }-- val api = createStalkerSyncProvider(providerEntity)- var hydration = current- var nextPage = ((current?.lastSuccessfulPage ?: 0) + 1).coerceAtLeast(1)- var remotePagesRequested = 0- val seenPageFingerprints = mutableSetOf<String>()- while (true) {- val attemptAt = System.currentTimeMillis()- if (request == com.streamvault.domain.model.VodCategoryHydrationRequest.COMPLETE &&- remotePagesRequested >= STALKER_COMPLETE_PAGE_BATCH_SIZE- ) {- break- }- remotePagesRequested += 1- vodCategoryHydrationDao.upsert(- (hydration ?: VodCategoryHydrationEntity(providerId, categoryId)).copy(- lastAttemptedPage = nextPage,- lastStatus = "RUNNING",- lastError = null- )- )- when (val pageResult = api.getUnifiedVodPage(categoryId, nextPage)) {- is Result.Success -> {- val page = pageResult.data- if (- hydration?.advertisedTotalPages != null &&- page.advertisedTotalPages != null &&- hydration?.advertisedTotalPages != page.advertisedTotalPages- ) {- val prior = hydration ?: VodCategoryHydrationEntity(providerId, categoryId)- hydration = prior.copy(- lastAttemptedPage = page.page,- lastStatus = "ANOMALY",- lastError = "Portal changed its advertised catalog page count while loading.",- retryAfterMs = 0L- )- vodCategoryHydrationDao.upsert(hydration!!)- return@withLock Result.error(hydration!!.lastError ?: "Portal changed its advertised page count")- }- val pageFingerprint = page.items.joinToString("|") { it.rawItemId }- .takeIf(String::isNotEmpty)- if (pageFingerprint != null && !seenPageFingerprints.add(pageFingerprint)) {- val prior = hydration ?: VodCategoryHydrationEntity(providerId, categoryId)- hydration = prior.copy(- lastAttemptedPage = page.page,- lastStatus = "ANOMALY",- lastError = "Portal repeated a catalog page while loading page ${page.page}.",- retryAfterMs = 0L- )- vodCategoryHydrationDao.upsert(hydration!!)- return@withLock Result.error(hydration!!.lastError ?: "Portal repeated a catalog page")- }- val category = categoryDao.getByProviderAndTypeSync(providerId, ContentType.VOD.name)- .firstOrNull { it.categoryId == categoryId }- val protected = category?.isUserProtected == true- val movies = page.items.mapNotNull { entry ->- (entry.item as? VodCatalogItem.MovieItem)?.movie- ?.copy(isUserProtected = protected)- ?.toEntity()- }- val series = page.items.mapNotNull { entry ->- (entry.item as? VodCatalogItem.SeriesItem)?.series- ?.copy(isUserProtected = protected)- ?.toEntity()- }- val entries = page.items.mapIndexed { rawIndex, entry ->- when (val item = entry.item) {- is VodCatalogItem.MovieItem -> VodCatalogEntryEntity(- providerId = providerId,- categoryId = categoryId,- rawItemId = entry.rawItemId,- itemType = ContentType.MOVIE,- targetId = item.movie.streamId,- rawPage = page.page,- rawIndex = rawIndex- )- is VodCatalogItem.SeriesItem -> VodCatalogEntryEntity(- providerId = providerId,- categoryId = categoryId,- rawItemId = entry.rawItemId,- itemType = ContentType.SERIES,- targetId = item.series.seriesId,- rawPage = page.page,- rawIndex = rawIndex- )- }- }- val pageLimitReached = request == com.streamvault.domain.model.VodCategoryHydrationRequest.COMPLETE &&- remotePagesRequested >= STALKER_COMPLETE_PAGE_BATCH_SIZE &&- !page.isComplete- val truncated = page.isTruncated || pageLimitReached- val pageComplete = page.isComplete && !truncated- val terminationReason = page.terminationReason- ?: "page_limit".takeIf { pageLimitReached }- transactionRunner.inTransaction {- movieDao.upsertCategoryPage(providerId, movies)- seriesDao.upsertCategoryPage(providerId, series)- vodCatalogEntryDao.replacePage(providerId, categoryId, page.page, entries)- val persistedCount = vodCatalogEntryDao.countByCategory(providerId, categoryId)- hydration = VodCategoryHydrationEntity(- providerId = providerId,- categoryId = categoryId,- lastLoadedPage = page.page,- lastAttemptedPage = page.page,- lastSuccessfulPage = page.page,- totalPages = page.totalPages,- advertisedTotalItems = page.advertisedTotalItems,- advertisedTotalPages = page.advertisedTotalPages,- pageSize = page.pageSize,- itemCount = persistedCount,- isComplete = pageComplete,- hasMovies = (hydration?.hasMovies == true) || movies.isNotEmpty(),- hasSeries = (hydration?.hasSeries == true) || series.isNotEmpty(),- lastHydratedAt = attemptAt,- lastStatus = if (truncated) "TRUNCATED" else "SUCCESS",- lastError = terminationReason,- retryAfterMs = 0L,- failureCount = 0,- retryBudgetRemaining = STALKER_CATEGORY_RETRY_BUDGET,- lastPageFingerprint = pageFingerprint- )- vodCategoryHydrationDao.upsert(hydration!!)- }- if (truncated) return@withLock Result.error(terminationReason ?: "VOD response was truncated")- if (pageComplete) return@withLock Result.success(Unit)- if (request != com.streamvault.domain.model.VodCategoryHydrationRequest.COMPLETE) {- return@withLock Result.success(Unit)- }- nextPage = page.page + 1- }- is Result.Error -> {- val prior = hydration ?: VodCategoryHydrationEntity(providerId, categoryId)- hydration = prior.copy(- lastAttemptedPage = nextPage,- lastStatus = "FAILED_RETRYABLE",- lastError = pageResult.message,- failureCount = prior.failureCount + 1,- retryBudgetRemaining = (prior.retryBudgetRemaining - 1).coerceAtLeast(0)- )- vodCategoryHydrationDao.upsert(hydration!!)- return@withLock Result.error(pageResult.message, pageResult.exception)- }- Result.Loading -> return@withLock Result.error("VOD hydration did not complete")- }- }- @Suppress("UNREACHABLE_CODE")- Result.success(Unit)- }- }+ ): Result<Unit> = vodCategoryHydrationCoordinator.hydrateUnifiedVodCategory(providerId, categoryId, request)- suspend fun hydrateSplitVodCategory(+ override suspend fun hydrateSplitVodCategory(providerId: Long,movieCategoryId: Long,request: com.streamvault.domain.model.VodCategoryHydrationRequest,- requestedProjection: ContentType = ContentType.MOVIE- ): Result<Unit> {- val requestedPage = if (request == com.streamvault.domain.model.VodCategoryHydrationRequest.NEXT_PAGE) {- ((movieCategoryHydrationDao.get(providerId, movieCategoryId)?.lastSuccessfulPage ?: 0) + 1)- .coerceAtLeast(1)- } else {- null- }- val lock = providerVodCategoryMutexes.computeIfAbsent("split:$providerId:$movieCategoryId") { Mutex() }- return lock.withLock {- val providerEntity = loadCompatibilityProvider(providerId)- ?: return@withLock Result.error("Provider not found")- if (providerEntity.type != ProviderType.STALKER_PORTAL || providerEntity.catalogLayout != CatalogLayout.SPLIT) {- return@withLock Result.success(Unit)- }- var hydration = movieCategoryHydrationDao.get(providerId, movieCategoryId)- var movieCount = movieDao.getCountByCategory(providerId, movieCategoryId).first()- if (hydration?.isComplete == true ||- (requestedPage != null && hydration != null && hydration.lastSuccessfulPage >= requestedPage) ||- (request == com.streamvault.domain.model.VodCategoryHydrationRequest.OPEN &&- (hydration?.lastSuccessfulPage ?: 0) > 0)- ) {- return@withLock Result.success(Unit)- }- val api = createStalkerSyncProvider(providerEntity)- val movieCategory = categoryDao.getByProviderAndTypeSync(providerId, ContentType.MOVIE.name)- .firstOrNull { it.categoryId == movieCategoryId }- ?: return@withLock Result.error("Movie category not found")- // Populate the provider's category identity cache before translating it to Series.- api.getVodCategories()- val seriesCategoryId = api.projectVodCategoryToSeries(movieCategoryId)- ?: return@withLock Result.error("Unable to resolve VOD-derived Series category")- val initialProjectionCount = when (requestedProjection) {- ContentType.SERIES -> seriesDao.getCountByCategory(providerId, seriesCategoryId).first()- else -> movieCount- }- var nextPage = ((hydration?.lastSuccessfulPage ?: 0) + 1).coerceAtLeast(1)- var remotePagesRequested = 0- val seenPageFingerprints = mutableSetOf<String>()- while (true) {- val attemptAt = System.currentTimeMillis()- if (request == com.streamvault.domain.model.VodCategoryHydrationRequest.COMPLETE &&- remotePagesRequested >= STALKER_COMPLETE_PAGE_BATCH_SIZE- ) {- break- }- remotePagesRequested += 1- movieCategoryHydrationDao.upsert(- (hydration ?: com.streamvault.data.local.entity.MovieCategoryHydrationEntity(- providerId,- movieCategoryId- )).copy(- lastAttemptedPage = nextPage,- lastStatus = "RUNNING",- lastError = null- )- )- seriesCategoryHydrationDao.get(providerId, seriesCategoryId)?.let { seriesHydration ->- seriesCategoryHydrationDao.upsert(- seriesHydration.copy(- lastAttemptedPage = nextPage,- lastStatus = "RUNNING",- lastError = null- )- )- }- when (val pageResult = api.getSplitVodPage(movieCategoryId, seriesCategoryId, nextPage)) {- is Result.Success -> {- val page = pageResult.data- if (- hydration?.advertisedTotalPages != null &&- page.advertisedTotalPages != null &&- hydration?.advertisedTotalPages != page.advertisedTotalPages- ) {- val prior = hydration ?: com.streamvault.data.local.entity.MovieCategoryHydrationEntity(- providerId,- movieCategoryId- )- hydration = prior.copy(- lastAttemptedPage = page.page,- lastStatus = "ANOMALY",- lastError = "Portal changed its advertised catalog page count while loading.",- retryAfterMs = 0L- )- movieCategoryHydrationDao.upsert(hydration!!)- return@withLock Result.error(hydration!!.lastError ?: "Portal changed its advertised page count")- }- val pageFingerprint = page.items.joinToString("|") { it.rawItemId }- .takeIf(String::isNotEmpty)- if (pageFingerprint != null && !seenPageFingerprints.add(pageFingerprint)) {- val prior = hydration ?: com.streamvault.data.local.entity.MovieCategoryHydrationEntity(- providerId,- movieCategoryId- )- hydration = prior.copy(- lastAttemptedPage = page.page,- lastStatus = "ANOMALY",- lastError = "Portal repeated a catalog page while loading page ${page.page}.",- retryAfterMs = 0L- )- movieCategoryHydrationDao.upsert(hydration!!)- return@withLock Result.error(hydration!!.lastError ?: "Portal repeated a catalog page")- }- val movies = page.items.mapNotNull { (it.item as? VodCatalogItem.MovieItem)?.movie?.toEntity() }- val incomingSeries = page.items.mapNotNull {- (it.item as? VodCatalogItem.SeriesItem)?.series- ?.copy(isUserProtected = movieCategory.isUserProtected)- ?.toEntity()- }- val now = attemptAt- val pageLimitReached = request == com.streamvault.domain.model.VodCategoryHydrationRequest.COMPLETE &&- remotePagesRequested >= STALKER_COMPLETE_PAGE_BATCH_SIZE &&- !page.isComplete- val truncated = page.isTruncated || pageLimitReached- val pageComplete = page.isComplete && !truncated- val terminationReason = page.terminationReason- ?: "page_limit".takeIf { pageLimitReached }- val existingSeriesHydration = seriesCategoryHydrationDao.get(providerId, seriesCategoryId)- transactionRunner.inTransaction {- movieDao.upsertCategoryPage(providerId, movies)- if (incomingSeries.isNotEmpty()) {- categoryDao.insertAll(- listOf(- CategoryEntity(- providerId = providerId,- categoryId = seriesCategoryId,- name = movieCategory.name,- parentId = movieCategory.parentId,- type = ContentType.SERIES,- providerOrder = movieCategory.providerOrder,- isAdult = movieCategory.isAdult,- isUserProtected = movieCategory.isUserProtected- )- )- )- }- // Check inside the same transaction as the write so a concurrent- // native-Series refresh can never be replaced by derived VOD data.- val existingSeries = seriesDao.getBySeriesIds(- providerId,- incomingSeries.map { it.seriesId }- ).associateBy { it.seriesId }- val derivedSeries = incomingSeries.filter { incoming ->- existingSeries[incoming.seriesId]?.catalogOrigin !=- com.streamvault.domain.model.SeriesCatalogOrigin.NATIVE- }- seriesDao.upsertCategoryPage(providerId, derivedSeries)- movieCount = movieDao.getCountByCategory(providerId, movieCategoryId).first()- val seriesCount = seriesDao.getCountByCategory(providerId, seriesCategoryId).first()- hydration = com.streamvault.data.local.entity.MovieCategoryHydrationEntity(- providerId = providerId,- categoryId = movieCategoryId,- lastHydratedAt = now,- itemCount = movieCount,- lastStatus = if (truncated) "TRUNCATED" else "SUCCESS",- lastError = terminationReason,- lastLoadedPage = page.page,- lastAttemptedPage = page.page,- lastSuccessfulPage = page.page,- totalPages = page.totalPages,- advertisedTotalItems = page.advertisedTotalItems,- advertisedTotalPages = page.advertisedTotalPages,- isComplete = pageComplete,- pageSize = page.pageSize,- retryBudgetRemaining = STALKER_CATEGORY_RETRY_BUDGET,- lastPageFingerprint = pageFingerprint- )- movieCategoryHydrationDao.upsert(hydration!!)- if (incomingSeries.isNotEmpty() || existingSeriesHydration != null) {- seriesCategoryHydrationDao.upsert(- com.streamvault.data.local.entity.SeriesCategoryHydrationEntity(- providerId = providerId,- categoryId = seriesCategoryId,- lastHydratedAt = now,- itemCount = seriesCount,- lastStatus = if (truncated) "TRUNCATED" else "SUCCESS",- lastError = terminationReason,- lastLoadedPage = page.page,- lastAttemptedPage = page.page,- lastSuccessfulPage = page.page,- totalPages = page.totalPages,- advertisedTotalItems = page.advertisedTotalItems,- advertisedTotalPages = page.advertisedTotalPages,- isComplete = pageComplete,- pageSize = page.pageSize,- retryBudgetRemaining = STALKER_CATEGORY_RETRY_BUDGET,- lastPageFingerprint = pageFingerprint- )- )- }- }- if (truncated) return@withLock Result.error(terminationReason ?: "VOD response was truncated")- val projectionCount = when (requestedProjection) {- ContentType.SERIES -> seriesDao.getCountByCategory(providerId, seriesCategoryId).first()- else -> movieCount- }- if (pageComplete ||- (request != com.streamvault.domain.model.VodCategoryHydrationRequest.COMPLETE &&- projectionCount > initialProjectionCount)- ) {- return@withLock Result.success(Unit)- }- nextPage = page.page + 1- }- is Result.Error -> {- val prior = hydration ?: com.streamvault.data.local.entity.MovieCategoryHydrationEntity(- providerId,- movieCategoryId- )- movieCategoryHydrationDao.upsert(- prior.copy(- lastAttemptedPage = nextPage,- lastStatus = "FAILED_RETRYABLE",- lastError = pageResult.message,- failureCount = prior.failureCount + 1,- retryBudgetRemaining = (prior.retryBudgetRemaining - 1).coerceAtLeast(0)- )- )- seriesCategoryHydrationDao.get(providerId, seriesCategoryId)?.let { seriesHydration ->- seriesCategoryHydrationDao.upsert(- seriesHydration.copy(- lastAttemptedPage = nextPage,- lastStatus = "FAILED_RETRYABLE",- lastError = pageResult.message,- failureCount = seriesHydration.failureCount + 1,- retryBudgetRemaining = (seriesHydration.retryBudgetRemaining - 1).coerceAtLeast(0)- )- )- }- return@withLock Result.error(pageResult.message, pageResult.exception)- }- Result.Loading -> return@withLock Result.error("Split VOD hydration did not complete")- }- }- @Suppress("UNREACHABLE_CODE")- Result.success(Unit)- }- }+ requestedProjection: ContentType+ ): Result<Unit> = vodCategoryHydrationCoordinator.hydrateSplitVodCategory(+ providerId,+ movieCategoryId,+ request,+ requestedProjection+ )- suspend fun hydrateSplitVodSeriesCategory(+ override suspend fun hydrateSplitVodSeriesCategory(providerId: Long,seriesCategoryId: Long,request: com.streamvault.domain.model.VodCategoryHydrationRequest- ): Result<Unit> {- val providerEntity = loadCompatibilityProvider(providerId) ?: return Result.error("Provider not found")- if (providerEntity.type != ProviderType.STALKER_PORTAL || providerEntity.catalogLayout != CatalogLayout.SPLIT) {- return Result.success(Unit)- }- val api = createStalkerSyncProvider(providerEntity)- api.getSeriesCategories()- val movieCategoryId = api.projectSeriesCategoryToVod(seriesCategoryId)- ?: return Result.error("Unable to resolve VOD category for derived Series")- return hydrateSplitVodCategory(providerId, movieCategoryId, request, ContentType.SERIES)- }- private val providerWorkLocks = ProviderWorkLockRegistry()+ ): Result<Unit> = vodCategoryHydrationCoordinator.hydrateSplitVodSeriesCategory(+ providerId,+ seriesCategoryId,+ request+ )+private val xtreamCatalogHttpService: OkHttpXtreamApiService by lazy {OkHttpXtreamApiService(client = okHttpClient,@@ -952,45 +736,17 @@ class SyncManager @Inject constructor()}- fun syncStateForProvider(providerId: Long): Flow<SyncState> =+ override fun syncStateForProvider(providerId: Long): Flow<SyncState> =syncStatesByProvider.map { states -> states[providerId] ?: SyncState.Idle }- fun currentSyncState(providerId: Long): SyncState =- syncStateTracker.current(providerId)+ override fun currentSyncState(providerId: Long): SyncState =+ syncStatusPublicationCoordinator.currentSyncState(providerId)/** Returns true if any provider sync mutex is currently held (used by DatabaseMaintenanceManager). */fun isAnySyncActive(): Boolean = providerWorkLocks.isAnyWorkActiveOrWaiting()- private fun isAnySyncMutexLocked(): Boolean =- providerSyncMutexes.values.any { it.isLocked } ||- providerEpgMutexes.values.any { it.isLocked }-private suspend fun <T> withProviderLock(providerId: Long, block: suspend () -> T): T {- return providerWorkLocks.withProviderLock(providerId) {- val mutex = syncAdmissionMutex.withLock {- providerSyncMutexes.computeIfAbsent(providerId) { Mutex() }.also { providerMutex ->- providerMutex.lock()- }- }- try {- block()- } finally {- mutex.unlock()- }- }- }-- private suspend fun <T> withProviderEpgLock(providerId: Long, block: suspend () -> T): T {- val mutex = syncAdmissionMutex.withLock {- providerEpgMutexes.computeIfAbsent(providerId) { Mutex() }.also { providerMutex ->- providerMutex.lock()- }- }- try {- return block()- } finally {- mutex.unlock()- }+ return providerWorkLocks.withProviderLock(providerId, block)}private suspend fun <T> withStalkerIndexSectionLock(@@ -998,40 +754,23 @@ class SyncManager @Inject constructor(section: ContentType,block: suspend () -> T): T {- val lockKey = "$providerId:${section.name}"- val mutex = syncAdmissionMutex.withLock {- providerStalkerIndexSectionMutexes.computeIfAbsent(lockKey) { Mutex() }.also { sectionMutex ->- sectionMutex.lock()- }- }- try {- return block()- } finally {- mutex.unlock()- }+ return providerSyncLocks.withStalkerIndexSectionLock(providerId, section, block)}private suspend fun <T> withStalkerSummaryProviderLock(providerId: Long, block: suspend () -> T): T {- val mutex = syncAdmissionMutex.withLock {- providerStalkerSummaryMutexes.computeIfAbsent(providerId) { Mutex() }.also { providerMutex ->- providerMutex.lock()- }- }- try {- return block()- } finally {- mutex.unlock()- }+ return providerSyncLocks.withStalkerSummaryLock(providerId, block)}private suspend fun <T> withStalkerSummaryLock(providerId: Long,section: ContentType?,block: suspend () -> T- ): T = when (section) {- ContentType.MOVIE,- ContentType.SERIES -> withStalkerSummaryProviderLock(providerId, block)- else -> withProviderLock(providerId, block)+ ): T = withProviderLock(providerId) {+ when (section) {+ ContentType.MOVIE,+ ContentType.SERIES -> withStalkerSummaryProviderLock(providerId, block)+ else -> block()+ }}private suspend fun <T> withStalkerFetchPermit(@@ -1054,84 +793,69 @@ class SyncManager @Inject constructor(suspend fun runWhenNoSyncActive(block: suspend () -> Boolean): Boolean =providerWorkLocks.runWhenNoWorkActive(block)- suspend fun onProviderDeleted(providerId: Long) {- runCatching { BackgroundEpgSyncWorker.cancel(applicationContext, providerId) }+ override suspend fun onProviderDeleted(providerId: Long) {+ runCatching { providerSyncWorkScheduler.cancelBackgroundEpg(providerId) }.onFailure { error -> Log.w(TAG, "Failed to cancel background EPG work: ${sanitizeThrowableMessage(error)}") }- runCatching { StalkerIndexWorker.cancel(applicationContext, providerId) }+ runCatching { providerSyncWorkScheduler.cancelStalkerIndex(providerId) }.onFailure { error -> Log.w(TAG, "Failed to cancel Stalker index work: ${sanitizeThrowableMessage(error)}") }withProviderLock(providerId) {- withProviderEpgLock(providerId) {- syncStateTracker.reset(providerId)- stalkerReadinessTracker.clear(providerId)- xtreamAdaptiveSyncPolicy.forgetProvider(providerId)- syncCatalogStore.clearProviderStaging(providerId)- epgRepository.onProviderDeleted(providerId)- providerSyncMutexes.remove(providerId)- providerStalkerSummaryMutexes.remove(providerId)- providerEpgMutexes.remove(providerId)- }+ resetState(providerId)+ stalkerReadinessTracker.clear(providerId)+ xtreamAdaptiveSyncPolicy.forgetProvider(providerId)+ syncCatalogStore.clearProviderStaging(providerId)+ epgRepository.onProviderDeleted(providerId)}+ providerSyncLocks.forgetProvider(providerId)+ providerWorkLocks.forgetProvider(providerId)+ stalkerPlaybackCapabilityCache.invalidate(providerId)+ stalkerRequestCoordinator.forgetProvider(providerId)+ StalkerTrafficCoordinator.forgetProvider(providerId)+ StalkerProvider.clearCachesForProvider(providerId)}- fun scheduleBackgroundEpgSync(providerId: Long) {+ override fun scheduleBackgroundEpgSync(providerId: Long) {runCatching {- BackgroundEpgSyncWorker.enqueue(applicationContext, providerId)+ providerSyncWorkScheduler.scheduleBackgroundEpg(providerId)}.onFailure { error ->Log.w(TAG, "Failed to schedule background EPG sync for provider $providerId: ${sanitizeThrowableMessage(error)}")}}- fun scheduleProviderSyncResume(+ override fun scheduleProviderSyncResume(providerId: Long,- configurationGeneration: Long? = null+ configurationGeneration: Long?) {runCatching {- if (configurationGeneration != null) {- ProviderSyncWorker.enqueueProviderConfigRevision(- applicationContext,- providerId,- configurationGeneration- )- } else {- ProviderSyncWorker.enqueueProvider(applicationContext, providerId)- }+ providerSyncWorkScheduler.scheduleProviderResume(providerId, configurationGeneration)}.onFailure { error ->Log.w(TAG, "Failed to schedule provider resume work for provider $providerId: ${sanitizeThrowableMessage(error)}")}}- fun scheduleXtreamIndexSync(providerId: Long, section: ContentType? = null, force: Boolean = false) {+ override fun scheduleXtreamIndexSync(providerId: Long, section: ContentType?, force: Boolean) {runCatching {- XtreamIndexWorker.enqueue(- context = applicationContext,- providerId = providerId,- section = section?.name,- force = force- )+ providerSyncWorkScheduler.scheduleXtreamIndex(providerId, section, force)}.onFailure { error ->Log.w(TAG, "Failed to schedule Xtream index work for provider $providerId (${section?.name ?: "all"}): ${sanitizeThrowableMessage(error)}")}}- fun scheduleStalkerIndexSync(+ override fun scheduleStalkerIndexSync(providerId: Long,- section: ContentType? = null,- force: Boolean = false,- initialDelaySeconds: Long = 0L,- appendSuccessor: Boolean = false+ section: ContentType?,+ force: Boolean,+ initialDelaySeconds: Long,+ appendSuccessor: Boolean) {- val effectiveSection: ContentType? = nullrunCatching {- StalkerIndexWorker.enqueue(- context = applicationContext,+ providerSyncWorkScheduler.scheduleStalkerIndex(providerId = providerId,- section = effectiveSection?.name,force = force,initialDelaySeconds = initialDelaySeconds,appendSuccessor = appendSuccessor)}.onFailure { error ->- Log.w(TAG, "Failed to schedule Stalker index work for provider $providerId (${effectiveSection?.name ?: "all"}): ${sanitizeThrowableMessage(error)}")+ Log.w(TAG, "Failed to schedule Stalker index work for provider $providerId (${section?.name ?: "all"}): ${sanitizeThrowableMessage(error)}")}}@@ -1144,7 +868,7 @@ class SyncManager @Inject constructor(scheduleStalkerIndexSync(providerId = providerId)}- suspend fun prioritizeXtreamIndexCategory(+ override suspend fun prioritizeXtreamIndexCategory(providerId: Long,section: ContentType,categoryId: Long@@ -1170,7 +894,7 @@ class SyncManager @Inject constructor(scheduleXtreamIndexSync(providerId, section, force = false)}- suspend fun prioritizeStalkerIndexCategory(+ override suspend fun prioritizeStalkerIndexCategory(providerId: Long,section: ContentType,categoryId: Long@@ -1181,10 +905,10 @@ class SyncManager @Inject constructor(if (section != ContentType.MOVIE && section != ContentType.SERIES) return}- suspend fun syncEpg(+ override suspend fun syncEpg(providerId: Long,- force: Boolean = true,- onProgress: ((String) -> Unit)? = null+ force: Boolean,+ onProgress: ((String) -> Unit)?): com.streamvault.domain.model.Result<Unit> {val providerEntity = providerDao.getById(providerId)?: return com.streamvault.domain.model.Result.error("Provider $providerId not found")@@ -1213,17 +937,13 @@ class SyncManager @Inject constructor(lastAttemptAt = startedAt,lastError = null)+ val stateSession = beginSyncStateSession(providerId)publishSyncState(providerId, SyncState.Syncing("Downloading EPG..."))return try {- val snapshot = providerSnapshotRepository?.getSnapshot(providerId) ?: provider.toProviderSnapshot()- val syncAdapter = when (val resolution = providerSyncRegistry.resolve(snapshot)) {- is CapabilityResolution.Available -> resolution.capability- is CapabilityResolution.ConfigurationError -> return Result.error(resolution.reason)- is CapabilityResolution.Restricted -> return Result.error(resolution.reason)- is CapabilityResolution.Unsupported -> return Result.error(resolution.reason)- }- val epgResult = when (val result = syncAdapter.syncGuide(+ val snapshot = syncProviderSnapshotAdapter.getSnapshot(providerId)+ ?: syncProviderSnapshotAdapter.toSnapshot(provider)+ val epgResult = when (val result = syncCoordinator.syncGuide(ProviderGuideSyncRequest(snapshot = snapshot,force = force,@@ -1232,9 +952,9 @@ class SyncManager @Inject constructor())) {is CapabilityResolution.Available -> result.capability- is CapabilityResolution.ConfigurationError -> return Result.error(result.reason)- is CapabilityResolution.Restricted -> return Result.error(result.reason)- is CapabilityResolution.Unsupported -> return Result.error(result.reason)+ is CapabilityResolution.ConfigurationError -> return failGuideResolution(provider, result.reason)+ is CapabilityResolution.Restricted -> return failGuideResolution(provider, result.reason)+ is CapabilityResolution.Unsupported -> return failGuideResolution(provider, result.reason)}val finishedAt = System.currentTimeMillis()val epgCount = programDao.countByProvider(providerId)@@ -1284,9 +1004,37 @@ class SyncManager @Inject constructor(updateSyncStatusMetadata(providerId = providerId, status = syncFailureStatus(provider, e))publishSyncState(providerId, SyncState.Error(safeMessage, e))com.streamvault.domain.model.Result.error(safeMessage, e)+ } finally {+ finishSyncStateSession(stateSession)}}+ private suspend fun failGuideResolution(+ provider: Provider,+ reason: String+ ): com.streamvault.domain.model.Result<Unit> {+ val failedAt = System.currentTimeMillis()+ updateXtreamEpgJobState(+ provider = provider,+ state = "FAILED_PERMANENT",+ now = failedAt,+ indexedRows = programDao.countByProvider(provider.id),+ lastError = reason+ )+ updateSyncStatusMetadata(providerId = provider.id, status = "FAILED_PERMANENT")+ publishSyncState(provider.id, SyncState.Error(reason))+ return Result.error(reason)+ }++ private suspend fun failSectionResolution(+ providerId: Long,+ reason: String+ ): com.streamvault.domain.model.Result<Unit> {+ updateSyncStatusMetadata(providerId = providerId, status = "FAILED_PERMANENT")+ publishSyncState(providerId, SyncState.Error(reason))+ return Result.error(reason)+ }+private fun shouldSyncEpgUpfront(provider: Provider): Boolean =provider.epgSyncMode == ProviderEpgSyncMode.UPFRONT@@ -1317,13 +1065,13 @@ class SyncManager @Inject constructor()}- suspend fun sync(+ override suspend fun sync(providerId: Long,- force: Boolean = false,- movieFastSyncOverride: Boolean? = null,- epgSyncModeOverride: ProviderEpgSyncMode? = null,- onProgress: ((String) -> Unit)? = null,- trackInitialLiveOnboarding: Boolean = false+ force: Boolean,+ movieFastSyncOverride: Boolean?,+ epgSyncModeOverride: ProviderEpgSyncMode?,+ onProgress: ((String) -> Unit)?,+ trackInitialLiveOnboarding: Boolean): com.streamvault.domain.model.Result<Unit> = syncWithProviderOverride(providerId = providerId,force = force,@@ -1337,15 +1085,15 @@ class SyncManager @Inject constructor(* Runs a not-yet-committed configuration. The callback is invoked within the first catalog* transaction that publishes data, so callers can atomically promote the configuration.*/- suspend fun syncWithProviderOverride(+ override suspend fun syncWithProviderOverride(providerId: Long,- force: Boolean = false,- movieFastSyncOverride: Boolean? = null,- epgSyncModeOverride: ProviderEpgSyncMode? = null,- onProgress: ((String) -> Unit)? = null,- trackInitialLiveOnboarding: Boolean = false,- providerOverride: Provider? = null,- afterCatalogApply: (suspend () -> Unit)? = null+ force: Boolean,+ movieFastSyncOverride: Boolean?,+ epgSyncModeOverride: ProviderEpgSyncMode?,+ onProgress: ((String) -> Unit)?,+ trackInitialLiveOnboarding: Boolean,+ providerOverride: Provider?,+ afterCatalogApply: (suspend () -> Unit)?): com.streamvault.domain.model.Result<Unit> = withProviderLock(providerId) lock@{var progressSession: SyncProgressSession? = nulltry {@@ -1368,23 +1116,14 @@ class SyncManager @Inject constructor(publishSyncState(providerId, SyncState.Syncing("Starting..."))val snapshot = if (providerOverride != null) {- provider.toProviderSnapshot()+ syncProviderSnapshotAdapter.toSnapshot(provider)} else {- providerSnapshotRepository?.getSnapshot(providerId) ?: provider.toProviderSnapshot()- }- val syncAdapter = when (val resolution = providerSyncRegistry.resolve(snapshot)) {- is CapabilityResolution.Available -> resolution.capability- is CapabilityResolution.ConfigurationError ->- return@lock Result.error(resolution.reason)- is CapabilityResolution.Restricted ->- return@lock Result.error(resolution.reason)- is CapabilityResolution.Unsupported ->- return@lock Result.error(resolution.reason)+ syncProviderSnapshotAdapter.getSnapshot(providerId)+ ?: syncProviderSnapshotAdapter.toSnapshot(provider)}-try {val outcome = withContext(Dispatchers.IO) {- syncAdapter.syncFull(+ when (val resolution = syncCoordinator.syncFull(FullProviderSyncRequest(snapshot = snapshot,force = force,@@ -1393,21 +1132,29 @@ class SyncManager @Inject constructor(deferProviderStateUntilCatalogCommit = providerOverride != null,afterCatalogApply = catalogCommitGate::apply)- )+ )) {+ is CapabilityResolution.Available -> resolution.capability+ is CapabilityResolution.ConfigurationError -> throw IllegalStateException(resolution.reason)+ is CapabilityResolution.Restricted -> throw IllegalStateException(resolution.reason)+ is CapabilityResolution.Unsupported -> throw IllegalStateException(resolution.reason)+ }}transactionRunner.inTransaction {providerWorkflowCommitFence.assertCanCommit(providerId)// A candidate configuration which produced no catalog is not committed. Do// not make the previous provider look freshly synced in that case.- if (providerOverride == null || catalogCommitGate.hasApplied) {+ if (+ !outcome.requiresPartialActivation &&+ (providerOverride == null || catalogCommitGate.hasApplied)+ ) {providerDao.updateSyncTime(providerId, System.currentTimeMillis())}updateSyncStatusMetadata(providerId = providerId,- status = if (outcome.partial) "PARTIAL" else "SUCCESS"+ status = if (outcome.requiresPartialActivation) "PARTIAL" else "SUCCESS")}- publishSyncState(providerId, if (outcome.partial) {+ publishSyncState(providerId, if (outcome.requiresPartialActivation) {SyncState.Partial("Sync completed with warnings", outcome.warnings)} else {SyncState.Success()@@ -1420,11 +1167,7 @@ class SyncManager @Inject constructor(val safeMessage = syncErrorSanitizer.userMessage(e, "Sync failed")Log.e(TAG, "Sync failed for provider $providerId: ${syncErrorSanitizer.throwableMessage(e)}")if (provider.type == ProviderType.XTREAM_CODES && trackInitialLiveOnboarding) {- recordXtreamLiveOnboardingState(- provider = provider,- phase = XTREAM_ONBOARDING_PHASE_FAILED,- lastError = sanitizeThrowableMessage(e)- )+ xtreamCatalogExecutor.markInitialOnboardingFailure(provider, e)}updateSyncStatusMetadata(providerId = providerId, status = syncFailureStatus(provider, e))publishSyncState(providerId, SyncState.Error(safeMessage, e))@@ -1436,12 +1179,12 @@ class SyncManager @Inject constructor(}fun resetState(providerId: Long? = null) {- syncStateTracker.reset(providerId)+ syncStatusPublicationCoordinator.reset(providerId)}- suspend fun rebuildXtreamIndex(+ override suspend fun rebuildXtreamIndex(providerId: Long,- onProgress: ((String) -> Unit)? = null+ onProgress: ((String) -> Unit)?): com.streamvault.domain.model.Result<Unit> = withProviderLock(providerId) lock@{val providerEntity = providerDao.getById(providerId)?: return@lock com.streamvault.domain.model.Result.error("Provider $providerId not found")@@ -1452,11 +1195,11 @@ class SyncManager @Inject constructor(val provider = loadCompatibilityProvider(providerId)?: return@lock Result.error("Provider $providerId has no typed configuration")+ val progressSession = beginProgressSession(providerId)publishSyncState(providerId, SyncState.Syncing("Preparing index rebuild..."))val now = System.currentTimeMillis()val warnings = mutableListOf<String>()- val progressSession = beginProgressSession(providerId)try {withContext(Dispatchers.IO) {progress(providerId, onProgress, "Marking existing index rows stale...")@@ -1467,7 +1210,7 @@ class SyncManager @Inject constructor(val enableBase64TextCompatibility = preferencesRepository.xtreamBase64TextCompatibility.first()val api = createXtreamSyncProvider(provider, useTextClassification, enableBase64TextCompatibility)- syncXtreamCategoryShell(+ xtreamCatalogSectionExecutor.syncCategoryShell(provider = provider,api = api,contentType = ContentType.MOVIE,@@ -1479,7 +1222,7 @@ class SyncManager @Inject constructor(upsertXtreamIndexJob(providerId = providerId,section = ContentType.MOVIE.name,- state = xtreamIndexFailureState(error),+ state = XtreamIndexRecoveryPolicy.failureState(error),now = now,lastAttemptAt = now,lastError = sanitizeThrowableMessage(error)@@ -1488,7 +1231,7 @@ class SyncManager @Inject constructor(}scheduleXtreamIndexSync(providerId, ContentType.MOVIE, force = true)- syncXtreamCategoryShell(+ xtreamCatalogSectionExecutor.syncCategoryShell(provider = provider,api = api,contentType = ContentType.SERIES,@@ -1500,7 +1243,7 @@ class SyncManager @Inject constructor(upsertXtreamIndexJob(providerId = providerId,section = ContentType.SERIES.name,- state = xtreamIndexFailureState(error),+ state = XtreamIndexRecoveryPolicy.failureState(error),now = now,lastAttemptAt = now,lastError = sanitizeThrowableMessage(error)@@ -1509,14 +1252,7 @@ class SyncManager @Inject constructor(}scheduleXtreamIndexSync(providerId, ContentType.SERIES, force = true)- val metadata = syncMetadataRepository.getMetadata(providerId) ?: SyncMetadata(providerId)- syncMetadataRepository.updateMetadata(- metadata.copy(- lastMovieAttempt = now,- movieCatalogStale = true,- movieSyncMode = VodSyncMode.UNKNOWN- )- )+ syncStatusPublicationCoordinator.markMovieIndexRebuildAttempt(providerId, now)}updateSyncStatusMetadata(providerId = providerId,@@ -1545,12 +1281,12 @@ class SyncManager @Inject constructor(}}- suspend fun retrySection(+ override suspend fun retrySection(providerId: Long,section: SyncRepairSection,- movieFastSyncOverride: Boolean? = null,- syncReason: XtreamLiveSyncReason = XtreamLiveSyncReason.MANUAL_SETTINGS,- onProgress: ((String) -> Unit)? = null+ movieFastSyncOverride: Boolean?,+ syncReason: XtreamLiveSyncReason,+ onProgress: ((String) -> Unit)?): com.streamvault.domain.model.Result<Unit> = withProviderLock(providerId) lock@{val providerEntity = providerDao.getById(providerId)?: return@lock com.streamvault.domain.model.Result.error("Provider $providerId not found")@@ -1562,8 +1298,10 @@ class SyncManager @Inject constructor(} ?: resolvedProviderval progressSession = beginProgressSession(providerId)+ publishSyncState(providerId, SyncState.Syncing("Retrying ${section.name}..."))try {- val persistedSnapshot = providerSnapshotRepository?.getSnapshot(providerId) ?: provider.toProviderSnapshot()+ val persistedSnapshot = syncProviderSnapshotAdapter.getSnapshot(providerId)+ ?: syncProviderSnapshotAdapter.toSnapshot(provider)val persistedConfiguration = persistedSnapshot.configurationval snapshot = if (movieFastSyncOverride != null && persistedConfiguration is XtreamConfig) {persistedSnapshot.copy(@@ -1574,14 +1312,8 @@ class SyncManager @Inject constructor(} else {persistedSnapshot}- val syncAdapter = when (val resolution = providerSyncRegistry.resolve(snapshot)) {- is CapabilityResolution.Available -> resolution.capability- is CapabilityResolution.ConfigurationError -> return@lock Result.error(resolution.reason)- is CapabilityResolution.Restricted -> return@lock Result.error(resolution.reason)- is CapabilityResolution.Unsupported -> return@lock Result.error(resolution.reason)- }val sectionResult = withContext(Dispatchers.IO) {- syncAdapter.syncSection(+ syncCoordinator.syncSection(SectionProviderSyncRequest(snapshot = snapshot,section = section,@@ -1592,17 +1324,17 @@ class SyncManager @Inject constructor(}val outcome = when (sectionResult) {is CapabilityResolution.Available -> sectionResult.capability- is CapabilityResolution.Unsupported -> return@lock Result.error(sectionResult.reason)- is CapabilityResolution.Restricted -> return@lock Result.error(sectionResult.reason)- is CapabilityResolution.ConfigurationError -> return@lock Result.error(sectionResult.reason)+ is CapabilityResolution.Unsupported -> return@lock failSectionResolution(providerId, sectionResult.reason)+ is CapabilityResolution.Restricted -> return@lock failSectionResolution(providerId, sectionResult.reason)+ is CapabilityResolution.ConfigurationError -> return@lock failSectionResolution(providerId, sectionResult.reason)}updateSyncStatusMetadata(providerId = providerId,- status = if (outcome.partial) "PARTIAL" else "SUCCESS"+ status = if (outcome.requiresPartialActivation) "PARTIAL" else "SUCCESS")publishSyncState(providerId,- if (outcome.partial) {+ if (outcome.requiresPartialActivation) {SyncState.Partial("Section retry completed with warnings", outcome.warnings)} else {SyncState.Success()@@ -1623,575 +1355,12 @@ class SyncManager @Inject constructor(}}- private suspend fun syncXtreamIndexFirst(- provider: Provider,+ override suspend fun processQueuedXtreamIndexJobs(+ providerId: Long,+ section: ContentType?,force: Boolean,- onProgress: ((String) -> Unit)?,- trackInitialLiveOnboarding: Boolean = false,- syncReason: XtreamLiveSyncReason = XtreamLiveSyncReason.FOREGROUND,- afterCatalogApply: suspend () -> Unit = {}- ): SyncOutcome {- val warnings = mutableListOf<String>()- UrlSecurityPolicy.validateXtreamServerUrl(provider.serverUrl)?.let { message ->- throw IllegalStateException(message)- }-- progress(provider.id, onProgress, "Connecting to server...")- val useTextClassification = preferencesRepository.useXtreamTextClassification.first()- val enableBase64TextCompatibility = preferencesRepository.xtreamBase64TextCompatibility.first()- val hiddenLiveCategoryIds = preferencesRepository.getHiddenCategoryIds(provider.id, ContentType.LIVE).first()- val api = createXtreamSyncProvider(provider, useTextClassification, enableBase64TextCompatibility)- val runtimeProfile = CatalogSyncRuntimeProfile.from(applicationContext)- val now = System.currentTimeMillis()- var metadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)-- if (trackInitialLiveOnboarding) {- recordXtreamLiveOnboardingState(- provider = provider,- phase = XTREAM_ONBOARDING_PHASE_STARTING,- now = now,- clearError = true,- runtimeProfile = runtimeProfile- )- }-- upsertXtreamIndexJob(- providerId = provider.id,- section = ContentType.LIVE.name,- state = "RUNNING",- now = now,- lastAttemptAt = now- )- val liveOutcome = runSuspendCatching {- val recoveredLiveCommit = if (trackInitialLiveOnboarding) {- recoverXtreamLiveOnboardingSession(- provider = provider,- hiddenLiveCategoryIds = hiddenLiveCategoryIds,- afterCatalogApply = afterCatalogApply- )- } else {- null- }- if (recoveredLiveCommit != null) {- warnings += recoveredLiveCommit.warnings- val acceptedCount = recoveredLiveCommit.acceptedCount- 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- )- metadata = metadata.copy(- lastLiveSync = now,- lastLiveSuccess = now,- liveCount = acceptedCount- )- syncMetadataRepository.updateMetadata(metadata)- return@runSuspendCatching acceptedCount- }-- if (trackInitialLiveOnboarding) {- recordXtreamLiveOnboardingState(- provider = provider,- phase = XTREAM_ONBOARDING_PHASE_FETCHING,- now = System.currentTimeMillis(),- clearError = true,- runtimeProfile = runtimeProfile- )- }- progress(provider.id, onProgress, "Downloading Live TV...")- val liveSyncResult = syncXtreamLiveCatalog(- provider = provider,- api = api,- existingMetadata = metadata,- hiddenLiveCategoryIds = hiddenLiveCategoryIds,- onProgress = onProgress,- runtimeProfile = runtimeProfile,- trackInitialLiveOnboarding = trackInitialLiveOnboarding,- syncReason = syncReason- )- if (trackInitialLiveOnboarding) {- val stagedAcceptedCount = liveSyncResult.stagedAcceptedCount- recordXtreamLiveOnboardingState(- provider = provider,- phase = if (liveSyncResult.stagedSessionId != null) {- XTREAM_ONBOARDING_PHASE_STAGED- } else {- XTREAM_ONBOARDING_PHASE_COMMITTING- },- now = System.currentTimeMillis(),- stagedSessionId = liveSyncResult.stagedSessionId,- importStrategy = liveSyncResult.catalogResult.strategyNameOrNull(),- acceptedRowCount = stagedAcceptedCount,- stagedFlushCount = stagedFlushCountFor(stagedAcceptedCount),- clearError = true,- runtimeProfile = runtimeProfile,- syncProfileStrategy = liveSyncResult.profileStrategyName(runtimeProfile, trackInitialLiveOnboarding)- )- }- val liveSequentialStress = liveSyncResult.strategyFeedback.segmentedStressDetected- val liveProviderAdaptation = updateSequentialProviderAdaptation(- previousRemembered = metadata.liveSequentialFailuresRemembered,- previousHealthyStreak = metadata.liveHealthySyncStreak,- sawSequentialStress = liveSequentialStress- )- val liveAvoidFullUntil = updateAvoidFullUntil(- previousAvoidFullUntil = metadata.liveAvoidFullUntil,- now = now,- feedback = liveSyncResult.strategyFeedback- )-- val acceptedCount = when (val liveResult = liveSyncResult.catalogResult) {- is CatalogStrategyResult.Success -> {- if (trackInitialLiveOnboarding) {- recordXtreamLiveOnboardingState(- provider = provider,- phase = XTREAM_ONBOARDING_PHASE_COMMITTING,- now = System.currentTimeMillis(),- stagedSessionId = liveSyncResult.stagedSessionId,- importStrategy = liveResult.strategyName,- acceptedRowCount = liveSyncResult.stagedAcceptedCount,- stagedFlushCount = stagedFlushCountFor(liveSyncResult.stagedAcceptedCount),- clearError = true,- runtimeProfile = runtimeProfile,- syncProfileStrategy = liveSyncResult.profileStrategyName(runtimeProfile, trackInitialLiveOnboarding)- )- }- finalizeXtreamLiveCatalog(- providerId = provider.id,- liveSyncResult = liveSyncResult,- hiddenLiveCategoryIds = hiddenLiveCategoryIds,- onProgress = onProgress,- afterCatalogApply = afterCatalogApply- ).also { commitResult ->- warnings += commitResult.warnings- }.acceptedCount- }- is CatalogStrategyResult.Partial -> {- if (trackInitialLiveOnboarding) {- recordXtreamLiveOnboardingState(- provider = provider,- phase = XTREAM_ONBOARDING_PHASE_COMMITTING,- now = System.currentTimeMillis(),- stagedSessionId = liveSyncResult.stagedSessionId,- importStrategy = liveResult.strategyName,- acceptedRowCount = liveSyncResult.stagedAcceptedCount,- stagedFlushCount = stagedFlushCountFor(liveSyncResult.stagedAcceptedCount),- clearError = true,- runtimeProfile = runtimeProfile,- syncProfileStrategy = liveSyncResult.profileStrategyName(runtimeProfile, trackInitialLiveOnboarding)- )- }- finalizeXtreamLiveCatalog(- providerId = provider.id,- liveSyncResult = liveSyncResult,- hiddenLiveCategoryIds = hiddenLiveCategoryIds,- onProgress = onProgress,- partialCompletionWarning = "Live TV sync completed partially.",- afterCatalogApply = afterCatalogApply- ).also { commitResult ->- warnings += commitResult.warnings- }.acceptedCount- }- is CatalogStrategyResult.EmptyValid -> {- val existingChannelCount = channelDao.getCount(provider.id).first()- if (existingChannelCount == 0) {- 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- }- }- is CatalogStrategyResult.Failure -> {- val existingChannelCount = channelDao.getCount(provider.id).first()- if (existingChannelCount == 0) {- 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- }- }- }-- metadata = metadata.copy(- lastLiveSync = now,- lastLiveSuccess = now,- liveCount = acceptedCount,- liveAvoidFullUntil = liveAvoidFullUntil,- liveSequentialFailuresRemembered = liveProviderAdaptation.rememberSequential,- liveHealthySyncStreak = liveProviderAdaptation.healthyStreak- )- syncMetadataRepository.updateMetadata(metadata)- acceptedCount- }- val liveCount = liveOutcome.getOrElse { error ->- if (trackInitialLiveOnboarding) {- recordXtreamLiveOnboardingState(- provider = provider,- phase = XTREAM_ONBOARDING_PHASE_FAILED,- lastError = sanitizeThrowableMessage(error),- runtimeProfile = runtimeProfile- )- }- upsertXtreamIndexJob(- providerId = provider.id,- section = ContentType.LIVE.name,- state = xtreamIndexFailureState(error),- now = now,- lastAttemptAt = now,- lastError = sanitizeThrowableMessage(error)- )- throw error- }- upsertXtreamIndexJob(- providerId = provider.id,- section = ContentType.LIVE.name,- state = "QUEUED",- now = now,- totalCategories = 1,- completedCategories = 0,- indexedRows = liveCount,- lastAttemptAt = now,- lastError = null- )- scheduleXtreamIndexSync(provider.id, ContentType.LIVE)-- // Transition VOD : signale a l'UI qu'on passe a la section Movies. Le total- // reel des categories VOD n'est connu qu'a l'interieur de `syncXtreamCategoryShell`,- // donc on emet en indetermine (total = 0). `itemsIndexed` cumule le LIVE deja importe.- emitProviderProgress(provider.id,- com.streamvault.domain.sync.SyncProgress(- section = com.streamvault.domain.sync.Section.VOD,- current = 0,- total = 0,- currentLabel = "",- itemsIndexed = liveCount- )- )- val movieCategoryCount = syncXtreamCategoryShell(- provider = provider,- api = api,- contentType = ContentType.MOVIE,- label = "Movies",- now = now,- onProgress = onProgress- ).getOrElse { error ->- warnings += "Movies categories could not be loaded; movie indexing will retry later."- upsertXtreamIndexJob(- providerId = provider.id,- section = ContentType.MOVIE.name,- state = xtreamIndexFailureState(error),- now = now,- lastAttemptAt = now,- lastError = sanitizeThrowableMessage(error)- )- 0- }- if (movieCategoryCount > 0) {- scheduleXtreamIndexSync(provider.id, ContentType.MOVIE)- }- // Transition SERIES : meme principe que VOD ci-dessus. `itemsIndexed` reste a- // `liveCount` car VOD ne stage pas d'items dans la base au moment du shell- // (le contenu detaille est rempli ulterieurement par XtreamIndexWorker).- emitProviderProgress(provider.id,- com.streamvault.domain.sync.SyncProgress(- section = com.streamvault.domain.sync.Section.SERIES,- current = 0,- total = 0,- currentLabel = "",- itemsIndexed = liveCount- )- )- val seriesCategoryCount = syncXtreamCategoryShell(- provider = provider,- api = api,- contentType = ContentType.SERIES,- label = "Series",- now = now,- onProgress = onProgress- ).getOrElse { error ->- warnings += "Series categories could not be loaded; series indexing will retry later."- upsertXtreamIndexJob(- providerId = provider.id,- section = ContentType.SERIES.name,- state = xtreamIndexFailureState(error),- now = now,- lastAttemptAt = now,- lastError = sanitizeThrowableMessage(error)- )- 0- }- if (seriesCategoryCount > 0) {- 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,- movieSyncMode = VodSyncMode.UNKNOWN- )- syncMetadataRepository.updateMetadata(metadata)-- val epgState = if (provider.epgSyncMode == ProviderEpgSyncMode.SKIP) "IDLE" else "QUEUED"- upsertXtreamIndexJob(- providerId = provider.id,- section = "EPG",- state = epgState,- now = now,- lastAttemptAt = if (epgState == "QUEUED") now else 0L- )- if (provider.epgSyncMode != ProviderEpgSyncMode.SKIP) {- runCatching { scheduleBackgroundEpgSync(provider.id) }- .onFailure { error ->- Log.w(TAG, "Failed to schedule Xtream background EPG sync for provider ${provider.id}: ${sanitizeThrowableMessage(error)}")- warnings += "EPG background sync could not be scheduled; it will retry on the next launch or manual sync."- }- }-- if (force) {- Log.i(TAG, "Xtream index-first sync completed for provider ${provider.id}; VOD and series index jobs are queued.")- }- return if (warnings.isEmpty()) SyncOutcome() else SyncOutcome(partial = true, warnings = warnings.distinct())- }-- private suspend fun recordXtreamLiveOnboardingState(- provider: Provider,- phase: String,- now: Long = System.currentTimeMillis(),- stagedSessionId: Long? = null,- importStrategy: String? = null,- nextCategoryIndex: Int? = null,- acceptedRowCount: Int? = null,- stagedFlushCount: Int? = null,- lastError: String? = null,- clearError: Boolean = false,- completedAt: Long? = null,- clearStagedSession: Boolean = false,- runtimeProfile: CatalogSyncRuntimeProfile? = null,- syncProfileStrategy: String? = null- ) {- val existing = xtreamLiveOnboardingDao.getByProvider(provider.id)- xtreamLiveOnboardingDao.upsert(- XtreamLiveOnboardingStateEntity(- providerId = provider.id,- providerType = provider.type.name,- contentType = ContentType.LIVE.name,- phase = phase,- stagedSessionId = if (clearStagedSession) null else stagedSessionId ?: existing?.stagedSessionId,- importStrategy = importStrategy ?: existing?.importStrategy,- nextCategoryIndex = nextCategoryIndex ?: existing?.nextCategoryIndex ?: 0,- acceptedRowCount = acceptedRowCount ?: existing?.acceptedRowCount ?: 0,- stagedFlushCount = stagedFlushCount ?: existing?.stagedFlushCount ?: 0,- syncProfileTier = runtimeProfile?.tier?.name ?: existing?.syncProfileTier,- syncProfileBatchSize = runtimeProfile?.stageBatchSize ?: existing?.syncProfileBatchSize ?: 0,- syncProfileStrategy = syncProfileStrategy ?: existing?.syncProfileStrategy,- syncProfileLowMemory = runtimeProfile?.snapshot?.isCurrentlyLowOnMemory ?: existing?.syncProfileLowMemory ?: false,- syncProfileMemoryClassMb = runtimeProfile?.snapshot?.memoryClassMb ?: existing?.syncProfileMemoryClassMb ?: 0,- syncProfileAvailableMemMb = runtimeProfile?.snapshot?.availableMemMb ?: existing?.syncProfileAvailableMemMb ?: 0L,- lastError = when {- clearError -> null- lastError != null -> lastError- else -> existing?.lastError- },- createdAt = existing?.createdAt?.takeIf { it > 0L } ?: now,- updatedAt = now,- completedAt = completedAt- )- )- }-- private fun CatalogStrategyResult<*>.strategyNameOrNull(): String? = when (this) {- is CatalogStrategyResult.Success -> strategyName- is CatalogStrategyResult.Partial -> strategyName- is CatalogStrategyResult.EmptyValid -> strategyName- is CatalogStrategyResult.Failure -> strategyName- }-- private fun stagedFlushCountFor(acceptedCount: Int): Int =- if (acceptedCount <= 0) 0 else (acceptedCount + XTREAM_FALLBACK_STAGE_BATCH_SIZE - 1) / XTREAM_FALLBACK_STAGE_BATCH_SIZE-- private fun CatalogSyncPayload<Channel>.profileStrategyName(- runtimeProfile: CatalogSyncRuntimeProfile,- trackInitialLiveOnboarding: Boolean- ): String {- val baseStrategy = catalogResult.strategyNameOrNull() ?: "unknown"- val fullPolicy = if (strategyFeedback.preferredSegmentedFirst) {- "segmented_first"- } else if (runtimeProfile.shouldAttemptFullLiveCatalog(trackInitialLiveOnboarding)) {- "full_allowed"- } else {- "full_blocked"- }- return "$baseStrategy;$fullPolicy"- }-- private suspend fun recoverXtreamLiveOnboardingSession(- provider: Provider,- hiddenLiveCategoryIds: Set<Long>,- afterCatalogApply: suspend () -> Unit = {}- ): XtreamLiveCommitResult? {- val state = xtreamLiveOnboardingDao.getIncompleteByProvider(provider.id) ?: return null- val sessionId = state.stagedSessionId ?: return null- if (state.providerType != ProviderType.XTREAM_CODES.name || state.contentType != ContentType.LIVE.name) {- discardXtreamLiveOnboardingSession(provider, sessionId, "Saved Live TV import did not match this provider.")- return null- }- if (state.importStrategy != null && state.importStrategy != "full") {- discardXtreamLiveOnboardingSession(provider, sessionId, "Saved Live TV import strategy could not be resumed.")- return null- }-- val stagedState = syncCatalogStore.stagedLiveImportState(provider.id, sessionId)- val discardReason = when {- stagedState.channelCount <= 0 -> "Saved Live TV import was missing staged channels."- stagedState.movieCount > 0 || stagedState.seriesCount > 0 -> "Saved Live TV import contained rows for another catalog type."- else -> null- }- if (discardReason != null) {- discardXtreamLiveOnboardingSession(provider, sessionId, discardReason)- return null- }-- recordXtreamLiveOnboardingState(- provider = provider,- phase = XTREAM_ONBOARDING_PHASE_RECOVERING,- stagedSessionId = sessionId,- importStrategy = state.importStrategy ?: "full",- acceptedRowCount = stagedState.channelCount,- stagedFlushCount = stagedFlushCountFor(stagedState.channelCount),- clearError = true- )- if (hiddenLiveCategoryIds.isNotEmpty()) {- mergeHiddenChannelsIntoStaging(provider.id, sessionId, hiddenLiveCategoryIds)- }- val commitState = if (hiddenLiveCategoryIds.isNotEmpty()) {- syncCatalogStore.stagedLiveImportState(provider.id, sessionId)- } else {- stagedState- }- recordXtreamLiveOnboardingState(- provider = provider,- phase = XTREAM_ONBOARDING_PHASE_COMMITTING,- stagedSessionId = sessionId,- importStrategy = state.importStrategy ?: "full",- acceptedRowCount = stagedState.channelCount,- stagedFlushCount = stagedFlushCountFor(stagedState.channelCount),- clearError = true- )- syncCatalogStore.applyStagedLiveCatalog(- providerId = provider.id,- sessionId = sessionId,- categories = commitState.categories.takeIf { it.isNotEmpty() },- afterCatalogApply = afterCatalogApply- )- return XtreamLiveCommitResult(- acceptedCount = stagedState.channelCount,- warnings = listOf("Live TV import resumed from saved staged session.")- )- }-- private suspend fun discardXtreamLiveOnboardingSession(- provider: Provider,- sessionId: Long,- reason: String- ) {- Log.w(TAG, "Discarding saved Xtream Live onboarding session for provider ${provider.id}: $reason")- syncCatalogStore.discardStagedImport(provider.id, sessionId)- recordXtreamLiveOnboardingState(- provider = provider,- phase = XTREAM_ONBOARDING_PHASE_STARTING,- lastError = reason,- clearStagedSession = true- )- }-- private suspend fun syncXtreamCategoryShell(- provider: Provider,- api: XtreamProvider,- contentType: ContentType,- label: String,- now: Long,+ maxCategoriesPerSection: Int?,onProgress: ((String) -> Unit)?- ): kotlin.Result<Int> = runSuspendCatching {- progress(provider.id, onProgress, "Loading $label categories...")- upsertXtreamIndexJob(- providerId = provider.id,- section = contentType.name,- state = "RUNNING",- now = now,- lastAttemptAt = now- )- val categories = when (contentType) {- ContentType.MOVIE -> requireResult(api.getVodCategories(), "Failed to load VOD categories")- ContentType.SERIES -> requireResult(api.getSeriesCategories(), "Failed to load series categories")- else -> throw IllegalArgumentException("Unsupported Xtream category shell: $contentType")- }- syncCatalogStore.upsertCategories(- providerId = provider.id,- type = contentType.name,- categories = categories.map { category -> category.toEntity(provider.id) }- )- upsertXtreamIndexJob(- providerId = provider.id,- section = contentType.name,- state = "QUEUED",- now = now,- totalCategories = categories.size,- completedCategories = 0,- nextCategoryIndex = 0,- failedCategories = 0,- indexedRows = 0,- skippedMalformedRows = 0,- lastAttemptAt = now,- lastError = null- )- categories.size- }-- suspend fun processQueuedXtreamIndexJobs(- providerId: Long,- section: ContentType? = null,- force: Boolean = false,- maxCategoriesPerSection: Int? = null,- onProgress: ((String) -> Unit)? = null): com.streamvault.domain.model.Result<Unit> = withProviderLock(providerId) lock@{val providerEntity = providerDao.getById(providerId)?: return@lock com.streamvault.domain.model.Result.error("Provider $providerId not found")@@ -2218,20 +1387,26 @@ class SyncManager @Inject constructor(val failures = mutableListOf<Throwable>()sections.forEach { contentType ->val job = xtreamIndexJobDao.get(providerId, contentType.name)- if (!force && !shouldRunXtreamSummaryIndex(job)) {+ if (!force && !catalogIndexJobStore.shouldRunSummary(job)) {return@forEach}val failure = runSuspendCatching {when (contentType) {ContentType.LIVE -> processXtreamLiveIndexBackfillSection(providerId, onProgress)ContentType.MOVIE,- ContentType.SERIES -> processXtreamSummaryIndexSection(provider, api, contentType, maxCategoriesPerSection, onProgress)+ ContentType.SERIES -> xtreamIncrementalIndexExecutor.processSummary(+ provider,+ api,+ contentType,+ maxCategoriesPerSection,+ onProgress+ )ContentType.VOD,ContentType.SERIES_EPISODE -> Unit}}.exceptionOrNull()if (failure != null) {- val state = xtreamIndexFailureState(failure)+ val state = XtreamIndexRecoveryPolicy.failureState(failure)val currentJob = xtreamIndexJobDao.get(providerId, contentType.name)if (currentJob?.state != "PARTIAL") {val failureAt = System.currentTimeMillis()@@ -2260,67 +1435,20 @@ class SyncManager @Inject constructor(}}- private fun shouldRunXtreamSummaryIndex(job: XtreamIndexJobEntity?): Boolean {- if (job == null) return true- if (job.state in setOf("QUEUED", "RUNNING", "PARTIAL", "STALE", "FAILED_RETRYABLE")) return true- return ContentCachePolicy.shouldRefresh(job.lastSuccessAt, ContentCachePolicy.CATALOG_TTL_MILLIS)+ override fun cancelStalkerIndexSync(providerId: Long) {+ providerSyncWorkScheduler.cancelStalkerIndex(providerId)}- fun cancelStalkerIndexSync(providerId: Long) {- StalkerIndexWorker.cancel(applicationContext, providerId)+ override suspend fun reconcileStalkerIndexWorkAtStartup() {+ stalkerIndexContinuationCoordinator.reconcileAtStartup()}- suspend fun reconcileStalkerIndexWorkAtStartup() {- providerDao.getAllSync()- .filter { it.type == ProviderType.STALKER_PORTAL }- .forEach { identity ->- val provider = loadCompatibilityProvider(identity.id) ?: return@forEach- // v62 and older reused Xtream rows. They are never valid Stalker owners now.- xtreamIndexJobDao.deleteByProvider(provider.id)- val hasPendingOneTime = listOf(ContentType.MOVIE, ContentType.SERIES).any { section ->- stalkerIndexJobDao.get(provider.id, section.name)?.state in setOf(- StalkerIndexState.QUEUED,- StalkerIndexState.RUNNING,- StalkerIndexState.RETRY_WAIT,- StalkerIndexState.PARTIAL- )- }- if (provider.stalkerCatalogMode == StalkerCatalogMode.ON_DEMAND && !hasPendingOneTime) {- cancelStalkerIndexSync(provider.id)- } else if (provider.stalkerCatalogMode == StalkerCatalogMode.BACKGROUND_INDEX || hasPendingOneTime) {- scheduleStalkerIndexSync(provider.id)- }- }- }-- private fun shouldRunStalkerSummaryIndex(job: StalkerIndexJobEntity?): Boolean {- if (job == null) return true- if (job.state in setOf(- StalkerIndexState.QUEUED,- StalkerIndexState.RUNNING,- StalkerIndexState.PARTIAL,- StalkerIndexState.RETRY_WAIT- )) return true- return ContentCachePolicy.shouldRefresh(job.lastSuccessAt, ContentCachePolicy.CATALOG_TTL_MILLIS)- }-- private fun StalkerIndexState.toLegacyJobState(): String = when (this) {- StalkerIndexState.DISABLED -> "DISABLED"- StalkerIndexState.QUEUED -> "QUEUED"- StalkerIndexState.RUNNING -> "RUNNING"- StalkerIndexState.RETRY_WAIT -> "FAILED_RETRYABLE"- StalkerIndexState.PARTIAL -> "PARTIAL"- StalkerIndexState.COMPLETE -> "SUCCESS"- StalkerIndexState.TRUNCATED -> "TRUNCATED"- StalkerIndexState.FAILED -> "FAILED_PERMANENT"- }-- suspend fun processQueuedStalkerIndexJobs(+ override suspend fun processQueuedStalkerIndexJobs(providerId: Long,- section: ContentType? = null,- force: Boolean = false,- maxCategoriesPerSection: Int? = null,- onProgress: ((String) -> Unit)? = null+ section: ContentType?,+ force: Boolean,+ maxCategoriesPerSection: Int?,+ onProgress: ((String) -> Unit)?): com.streamvault.domain.model.Result<Unit> {return withStalkerSummaryLock(providerId, section) lock@{val playbackDelayMillis = if (StalkerTrafficCoordinator.isPlaybackActive(providerId)) 2_000L else 0L@@ -2344,7 +1472,7 @@ class SyncManager @Inject constructor(val provider = loadCompatibilityProvider(providerId)?: return@lock Result.error("Provider $providerId has no typed configuration")val api = createStalkerSyncProvider(provider)- val decision = chooseNextStalkerCatalogSection(+ val decision = stalkerIndexContinuationCoordinator.chooseNextSection(provider = provider,api = api,requestedSection = section,@@ -2363,7 +1491,7 @@ class SyncManager @Inject constructor(appendSuccessor = true)} else {- scheduleStalkerEpgIfCatalogIdle(provider)+ stalkerIndexContinuationCoordinator.scheduleEpgIfCatalogIdle(provider)}return@lock com.streamvault.domain.model.Result.success(Unit)}@@ -2374,7 +1502,7 @@ class SyncManager @Inject constructor(var sawRetryableFailure = falseval categoryLimit = maxCategoriesPerSection?.coerceAtLeast(1) ?: STALKER_INDEX_CATEGORY_SLICE_SIZEval failure = runSuspendCatching {- processStalkerSummaryIndexSection(+ stalkerIncrementalIndexExecutor.processSummary(provider = provider,api = api,contentType = contentType,@@ -2384,7 +1512,7 @@ class SyncManager @Inject constructor(}.exceptionOrNull()if (failure != null) {val failedAt = System.currentTimeMillis()- val state = stalkerIndexFailureState(failure)+ val state = StalkerIndexRecoveryPolicy.failureState(failure, ::sanitizeThrowableMessage)upsertXtreamIndexJob(providerId = providerId,section = contentType.name,@@ -2404,4051 +1532,601 @@ class SyncManager @Inject constructor(val exception = if (sawRetryableFailure) IOException(message, cause) else IllegalStateException(message, cause)com.streamvault.domain.model.Result.error(warnings.first(), exception)} else {- scheduleNextStalkerCatalogStep(provider, api)- scheduleStalkerEpgIfCatalogIdle(provider)+ stalkerIndexContinuationCoordinator.scheduleNextSection(provider, api)+ stalkerIndexContinuationCoordinator.scheduleEpgIfCatalogIdle(provider)com.streamvault.domain.model.Result.success(Unit)}}}- private data class StalkerCatalogDecision(- val contentType: ContentType?,- val retryDelaySeconds: Long = 0L,- val reason: String- )-- private data class StalkerCatalogSectionState(- val contentType: ContentType,- val runnable: Boolean,- val retryDelaySeconds: Long,- val pending: Boolean,- val jobState: String?,- val updatedAt: Long- )-- private suspend fun chooseNextStalkerCatalogSection(- provider: Provider,+ private suspend fun fetchStalkerSummaryPageWithRecovery(api: StalkerProvider,- requestedSection: ContentType?,- force: Boolean,- now: Long- ): StalkerCatalogDecision {- val movie = stalkerCatalogSectionState(provider, api, ContentType.MOVIE, force, now)- val series = stalkerCatalogSectionState(provider, api, ContentType.SERIES, force, now)- if (requestedSection == ContentType.MOVIE && movie.runnable) {- return StalkerCatalogDecision(- ContentType.MOVIE,- reason = "explicit movie section is runnable (${movie.jobState ?: "no job"})"- )+ contentType: ContentType,+ categoryId: Long,+ page: Int,+ splitVod: Boolean = false+ ): Result<com.streamvault.data.remote.stalker.StalkerPagedResult<out Any>> {+ suspend fun fetch(): Result<com.streamvault.data.remote.stalker.StalkerPagedResult<out Any>> {+ if (splitVod && contentType == ContentType.MOVIE) {+ val seriesCategoryId = api.projectVodCategoryToSeries(categoryId)+ ?: return Result.error("Unable to resolve VOD-derived Series category")+ return api.getSplitVodPage(categoryId, seriesCategoryId, page)+ }+ return fetchStalkerSummaryPage(api, contentType, categoryId, page)}- if (requestedSection == ContentType.SERIES && series.runnable) {- return StalkerCatalogDecision(- ContentType.SERIES,- reason = "explicit series section is runnable (${series.jobState ?: "no job"})"+ val initial = fetch()+ val recovered = if (initial is Result.Error && StalkerIndexRecoveryPolicy.isLikelyAuthFailure(initial.message, initial.exception)) {+ Log.w(+ TAG,+ "Retrying Stalker ${contentType.name} page $page after auth refresh for category $categoryId")+ api.invalidateAuthentication()+ fetch()+ } else {+ initial}- if (movie.runnable && series.runnable) {- // In split mode, finish/prune the native Series projection before VOD-derived- // supplementation. That lets a disappeared native row fall back to VOD safely.- val selected = if (provider.catalogLayout == CatalogLayout.SPLIT) {- series- } else {- listOf(movie, series).minWith(- compareBy<StalkerCatalogSectionState>({ it.updatedAt }, { it.contentType.ordinal })+ if (page != 1 || recovered !is Result.Success || recovered.data.items.isNotEmpty()) {+ return recovered+ }+ val fallback = fetchStalkerSummaryFirstPageFallback(api, contentType, categoryId)+ return if (fallback is Result.Success && fallback.data.items.isNotEmpty()) {+ Log.i(+ TAG,+ "Recovered empty paged Stalker ${contentType.name} first page with non-paged fallback for category $categoryId"+ )+ fallback+ } else if (fallback is Result.Error && fallback.exception is StalkerApiError.CatalogTruncated) {+ val truncation = fallback.exception as StalkerApiError.CatalogTruncated+ Result.success(+ com.streamvault.data.remote.stalker.StalkerPagedResult(+ items = emptyList(),+ page = 1,+ totalPages = truncation.pageLimit,+ pageSize = 0,+ hasAdvertisedTotal = true,+ advertisedTotalPages = truncation.advertisedTotalPages,+ isTruncated = true,+ terminationReason = "page_limit")- }- return StalkerCatalogDecision(- selected.contentType,- reason = "oldest pending section is ${selected.contentType.name.lowercase()} (${selected.jobState ?: "no job"})")+ } else {+ recovered}- if (movie.runnable) {- return StalkerCatalogDecision(ContentType.MOVIE, reason = "movies are runnable (${movie.jobState ?: "no job"})")- }- if (series.runnable) {- val reason = if (movie.pending && movie.retryDelaySeconds > 0L) {- "movies are waiting ${movie.retryDelaySeconds}s for retry; series is runnable"- } else {- "movies are complete or terminal; series is runnable (${series.jobState ?: "no job"})"- }- return StalkerCatalogDecision(ContentType.SERIES, reason = reason)- }-- val retryDelaySeconds = listOf(movie.retryDelaySeconds, series.retryDelaySeconds)- .filter { it > 0L }- .minOrNull()- ?: 0L- return StalkerCatalogDecision(- contentType = null,- retryDelaySeconds = retryDelaySeconds,- reason = when {- retryDelaySeconds > 0L -> "catalog is waiting ${retryDelaySeconds}s for retry"- movie.pending || series.pending -> "catalog has no attemptable work"- requestedSection == ContentType.MOVIE -> "requested movie section is not pending"- requestedSection == ContentType.SERIES -> "requested series section is not pending"- else -> "catalog is idle"- }- )}- private suspend fun stalkerCatalogSectionState(- provider: Provider,+ private suspend fun fetchStalkerSummaryFirstPageFallback(api: StalkerProvider,contentType: ContentType,- force: Boolean,- now: Long- ): StalkerCatalogSectionState {- val job = stalkerIndexJobDao.get(provider.id, contentType.name)- if (!force && !shouldRunStalkerSummaryIndex(job)) {- return StalkerCatalogSectionState(- contentType = contentType,- runnable = false,- retryDelaySeconds = 0L,- pending = false,- jobState = job?.state?.toLegacyJobState(),- updatedAt = job?.updatedAt ?: 0L+ categoryId: Long+ ): Result<com.streamvault.data.remote.stalker.StalkerPagedResult<out Any>> = when (contentType) {+ ContentType.MOVIE -> when (val result = api.getVodStreams(categoryId)) {+ is Result.Success -> Result.success(+ com.streamvault.data.remote.stalker.StalkerPagedResult(+ items = result.data,+ page = 1,+ totalPages = 1,+ pageSize = result.data.size+ ))+ is Result.Error -> Result.error(result.message, result.exception)+ is Result.Loading -> Result.error("Unexpected loading state from Stalker movie first-page fallback")}-- val categories = categoryDao.getByProviderAndTypeSync(provider.id, contentType.name)- val visibleCategories = visibleStalkerIndexCategories(- contentType,- allVisibleStalkerIndexCategories(provider.id, contentType, categories),- api- )- if (visibleCategories.isEmpty()) {- return StalkerCatalogSectionState(- contentType = contentType,- runnable = true,- retryDelaySeconds = 0L,- pending = true,- jobState = job?.state?.toLegacyJobState(),- updatedAt = job?.updatedAt ?: 0L+ ContentType.SERIES -> when (val result = api.getSeriesList(categoryId)) {+ is Result.Success -> Result.success(+ com.streamvault.data.remote.stalker.StalkerPagedResult(+ items = result.data,+ page = 1,+ totalPages = 1,+ pageSize = result.data.size+ ))+ is Result.Error -> Result.error(result.message, result.exception)+ is Result.Loading -> Result.error("Unexpected loading state from Stalker series first-page fallback")}-- val hydrations = visibleCategories.map { category ->- getStalkerHydrationSnapshot(provider.id, contentType, category.categoryId)- }- val hasAttemptableWork = hydrations.any { hydration -> canAttemptStalkerCategory(hydration, now) }- val retryDelaySeconds = nextRetryDelaySeconds(hydrations, now)- val hasUnresolvedWork = hydrations.any { hydration ->- hydration == null ||- (!hydration.isComplete && !hydration.isTerminalFailure && hydration.retryBudgetRemaining > 0)- }- val needsStateReconciliation = job?.state in setOf(- StalkerIndexState.QUEUED,- StalkerIndexState.RUNNING,- StalkerIndexState.RETRY_WAIT- ) &&- !hasUnresolvedWork- return StalkerCatalogSectionState(- contentType = contentType,- runnable = hasAttemptableWork || needsStateReconciliation,- retryDelaySeconds = retryDelaySeconds,- pending = hasUnresolvedWork || needsStateReconciliation,- jobState = job?.state?.toLegacyJobState(),- updatedAt = job?.updatedAt ?: 0L- )+ else -> Result.error("Unsupported Stalker summary first-page fallback section: $contentType")}- private suspend fun scheduleNextStalkerCatalogStep(provider: Provider, api: StalkerProvider) {- val decision = chooseNextStalkerCatalogSection(- provider = provider,- api = api,- requestedSection = null,- force = false,- now = System.currentTimeMillis()- )- when {- decision.contentType != null -> {- Log.i(TAG, "Scheduling next Stalker catalog step for provider ${provider.id}: ${decision.contentType.name}")- scheduleStalkerIndexSync(- providerId = provider.id,- section = null,- force = false,- appendSuccessor = true- )- }- decision.retryDelaySeconds > 0L -> {- Log.i(TAG, "Scheduling Stalker catalog retry for provider ${provider.id} in ${decision.retryDelaySeconds}s")- scheduleStalkerIndexSync(- providerId = provider.id,- section = null,- force = false,- initialDelaySeconds = decision.retryDelaySeconds,- appendSuccessor = true- )- }+ private suspend fun fetchStalkerWildcardSummaryPageWithRecovery(+ api: StalkerProvider,+ contentType: ContentType,+ categoryId: Long,+ page: Int+ ): Result<com.streamvault.data.remote.stalker.StalkerPagedResult<out Any>> {+ val initial = fetchStalkerWildcardSummaryPage(api, contentType, categoryId, page)+ if (initial is Result.Error && StalkerIndexRecoveryPolicy.isLikelyAuthFailure(initial.message, initial.exception)) {+ Log.w(+ TAG,+ "Retrying Stalker wildcard ${contentType.name} page $page after auth refresh for category $categoryId"+ )+ api.invalidateAuthentication()+ return fetchStalkerWildcardSummaryPage(api, contentType, categoryId, page)}+ return initial}- private suspend fun scheduleStalkerEpgIfCatalogIdle(provider: Provider) {- if (provider.type != ProviderType.STALKER_PORTAL ||- provider.epgSyncMode != ProviderEpgSyncMode.BACKGROUND- ) return- Log.i(TAG, "Scheduling Stalker EPG independently of catalog indexing for provider ${provider.id}.")- scheduleBackgroundEpgSync(provider.id)- }+ private fun detectStalkerPageAnomaly(+ hydration: StalkerHydrationSnapshot?,+ requestedPage: Int,+ pagedResult: com.streamvault.data.remote.stalker.StalkerPagedResult<out Any>,+ pageFingerprint: String?+ ): String? = StalkerIndexPolicy.detectPageAnomaly(+ hydration,+ requestedPage,+ pagedResult,+ pageFingerprint+ )- private fun scheduleStalkerIndexContinuation(- provider: Provider,- section: ContentType,- force: Boolean = false,- initialDelaySeconds: Long = 0L- ) {- scheduleStalkerIndexSync(- providerId = provider.id,- section = null,- force = force,- initialDelaySeconds = initialDelaySeconds- )- }+ private fun stalkerPageFingerprint(+ items: List<out Any>,+ contentType: ContentType+ ): String? = StalkerIndexPolicy.pageFingerprint(items, contentType)- private fun nextRetryDelaySeconds(- hydrations: Iterable<StalkerHydrationSnapshot?>,- now: Long- ): Long {- val retryAt = hydrations- .filterNotNull()- .filter { hydration ->- !hydration.isComplete &&- !hydration.isTerminalFailure &&- hydration.retryBudgetRemaining > 0 &&- hydration.retryAfterMs > now- }- .minOfOrNull { it.retryAfterMs }- ?: return 0L- return ((retryAt - now + 999L) / 1000L).coerceAtLeast(1L)+ private fun dedupeStalkerPageItems(+ items: List<out Any>,+ contentType: ContentType+ ): List<out Any> = StalkerIndexPolicy.dedupePageItems(items, contentType)++ private fun filterStalkerItemsToCategories(+ items: List<out Any>,+ contentType: ContentType,+ visibleCategoryIds: Set<Long>?+ ): List<out Any> = StalkerIndexPolicy.filterToVisibleCategories(items, contentType, visibleCategoryIds)++ private suspend fun fetchStalkerSummaryPage(+ api: StalkerProvider,+ contentType: ContentType,+ categoryId: Long,+ page: Int+ ): Result<com.streamvault.data.remote.stalker.StalkerPagedResult<out Any>> = when (contentType) {+ ContentType.MOVIE -> api.getVodStreamsPage(categoryId, page)+ ContentType.SERIES -> api.getSeriesListPage(categoryId, page)+ else -> Result.error("Unsupported Stalker summary page section: $contentType")}- private suspend fun processStalkerSummaryIndexSection(- provider: Provider,+ private suspend fun fetchStalkerWildcardSummaryPage(api: StalkerProvider,contentType: ContentType,- maxCategories: Int,- onProgress: ((String) -> Unit)?- ) {- require(contentType == ContentType.MOVIE || contentType == ContentType.SERIES) {- "Unsupported Stalker summary index section: $contentType"- }- val now = System.currentTimeMillis()- val categories = categoryDao.getByProviderAndTypeSync(provider.id, contentType.name)- val allVisibleCategories = allVisibleStalkerIndexCategories(provider.id, contentType, categories)- val visibleCategories = visibleStalkerIndexCategories(contentType, allVisibleCategories, api)- val wildcardCategory = allVisibleCategories.firstOrNull { category ->- api.isWildcardCategory(contentType, category.categoryId)- }- if (visibleCategories.isEmpty()) {- val deletedRows = xtreamContentIndexDao.pruneStaleLocalContentRows(provider.id, contentType.name)- val indexedRows = currentStalkerIndexedRowCount(provider.id, contentType)- upsertXtreamIndexJob(- providerId = provider.id,- section = contentType.name,- state = "SUCCESS",- now = now,- totalCategories = 0,- completedCategories = 0,- nextCategoryIndex = 0,- failedCategories = 0,- indexedRows = indexedRows,- deletedPrunedRows = deletedRows,- clearPriority = true,- lastAttemptAt = now,- lastSuccessAt = now,- lastError = null- )- updateStalkerSummaryMetadata(provider.id, contentType, indexedRows, "SUCCESS", now)- return- }+ categoryId: Long,+ page: Int+ ): Result<com.streamvault.data.remote.stalker.StalkerPagedResult<out Any>> = when (contentType) {+ ContentType.MOVIE -> api.getVodStreamsPageUsingItemCategories(categoryId, page)+ ContentType.SERIES -> api.getSeriesListPage(categoryId, page)+ else -> Result.error("Unsupported Stalker wildcard summary page section: $contentType")+ }- val initialJob = stalkerIndexJobDao.get(provider.id, contentType.name)+ private suspend fun allVisibleStalkerIndexCategories(+ providerId: Long,+ contentType: ContentType,+ categories: List<CategoryEntity>+ ): List<CategoryEntity> {+ val hiddenCategoryIds = preferencesRepository.getHiddenCategoryIds(providerId, contentType).first()+ return categories.filterNot { category -> category.categoryId in hiddenCategoryIds }+ }- val learnedWildcardSupport = api.validatedPortalState()?.let { state ->- when (contentType) {- ContentType.MOVIE -> state.movieWildcardSupported- ContentType.SERIES -> state.seriesWildcardSupported- else -> null- }- }- if (- wildcardCategory != null &&- learnedWildcardSupport != false &&- visibleCategories.size == 1 &&- visibleCategories.first().categoryId == wildcardCategory.categoryId- ) {- StalkerTelemetry.strategySelected(- provider.id,- "${contentType.name}_WILDCARD",- if (learnedWildcardSupport == true) "VALIDATED_CACHE" else "CAPABILITY_PROBE"- )- if (processStalkerWildcardIndexSection(- provider = provider,- api = api,- contentType = contentType,- wildcardCategory = wildcardCategory,- visibleCategories = allVisibleCategories,- maxPages = STALKER_WILDCARD_PAGE_SLICE_SIZE,- initialJob = initialJob,- onProgress = onProgress- )) {- api.recordWildcardCapability(contentType, supported = true)- return- }- } else if (wildcardCategory != null && learnedWildcardSupport == false) {- StalkerTelemetry.strategySelected(provider.id, "${contentType.name}_CATEGORY", "WILDCARD_KNOWN_UNSUPPORTED")- }+ private suspend fun visibleStalkerIndexCategories(+ contentType: ContentType,+ categories: List<CategoryEntity>,+ api: StalkerProvider+ ): List<CategoryEntity> {+ val visible = categories+ if (visible.isEmpty()) return emptyList()+ val normalCategories = visible.filterNot { category -> api.isWildcardCategory(contentType, category.categoryId) }+ return if (normalCategories.isNotEmpty()) normalCategories else visible+ }- val hydrationByCategory = visibleCategories.associate { category ->- category.categoryId to getStalkerHydrationSnapshot(provider.id, contentType, category.categoryId)+ private suspend fun currentStalkerIndexedRowCount(providerId: Long, contentType: ContentType): Int =+ when (contentType) {+ ContentType.MOVIE -> movieDao.getCount(providerId).first()+ ContentType.SERIES -> seriesDao.getCount(providerId).first()+ else -> 0}- val completedBefore = hydrationByCategory.values.count { it?.isComplete == true }- val failedBefore = hydrationByCategory.values.count { it?.isTerminalFailure == true }- val indexedBefore = currentStalkerIndexedRowCount(provider.id, contentType)- upsertXtreamIndexJob(- providerId = provider.id,- section = contentType.name,- state = "RUNNING",- now = now,- totalCategories = visibleCategories.size,- completedCategories = completedBefore,- failedCategories = failedBefore,- indexedRows = indexedBefore,- lastAttemptAt = now,- lastError = null- )- var restoreMovieWatchProgressPending = false-- try {- val pending = buildList {- visibleCategories.forEach { category ->- if (size >= maxCategories) return@forEach- val hydration = hydrationByCategory[category.categoryId]- if (!canAttemptStalkerCategory(hydration, now)) return@forEach- add(category)- }+ private suspend fun currentStalkerCategoryCount(providerId: Long, contentType: ContentType, categoryId: Long): Int =+ when (contentType) {+ ContentType.MOVIE -> movieDao.getCountByCategory(providerId, categoryId).first()+ ContentType.SERIES -> seriesDao.getCountByCategory(providerId, categoryId).first()+ else -> 0}- data class StalkerCategoryFetchAttempt(- val category: CategoryEntity,- val hydration: StalkerHydrationSnapshot?,- val nextPage: Int- )-- data class StalkerCategoryFetchResult(- val attempt: StalkerCategoryFetchAttempt,- val result: Result<com.streamvault.data.remote.stalker.StalkerPagedResult<out Any>>- )-- data class StalkerSuccessfulPage(- val category: CategoryEntity,- val hydration: StalkerHydrationSnapshot?,- val requestedPage: Int,- val items: List<Any>,- val totalPages: Int,- val pageSize: Int,- val advertisedTotalItems: Int?,- val advertisedTotalPages: Int?,- val isComplete: Boolean,- val isTruncated: Boolean,- val terminationReason: String?,- val pageFingerprint: String?+ private suspend fun updateStalkerSummaryMetadata(+ providerId: Long,+ contentType: ContentType,+ indexedRows: Int,+ finalState: String,+ now: Long+ ) {+ syncStatusPublicationCoordinator.updateSummaryMetadata(+ providerId = providerId,+ contentType = contentType,+ indexedRows = indexedRows,+ finalState = finalState,+ now = now,+ movieSyncMode = VodSyncMode.PAGED)+ }- var clearPriority = false- var skippedMalformedRows = initialJob?.skippedMalformedRows ?: 0- var pagesCommitted = 0- var rowsCommitted = 0- val sectionStartedAt = System.currentTimeMillis()- val runtimeProfile = CatalogSyncRuntimeProfile.from(applicationContext)- val parallelFetchLimit = stalkerCategoryFetchConcurrencyLimit(- provider = provider,- runtimeProfile = runtimeProfile,- maxCategories = maxCategories- )- val runDeadlineAt = System.currentTimeMillis() + STALKER_MAX_SECTION_RUN_MILLIS- val pendingQueue = ArrayDeque(pending)- var forceSequential = parallelFetchLimit <= 1- val retriedImmediately = mutableSetOf<Long>()- while (pendingQueue.isNotEmpty() && System.currentTimeMillis() < runDeadlineAt) {- if (pagesCommitted > 0) {- delay(StalkerTrafficCoordinator.backgroundInterPageDelayMillis(provider.id))- }- val windowSize = minOf(- if (forceSequential) 1 else parallelFetchLimit,- pendingQueue.size- )- val window = buildList {- repeat(windowSize) {- add(pendingQueue.removeFirst())- }- }- val attempts = window.mapNotNull { category ->- val hydration = getStalkerHydrationSnapshot(provider.id, contentType, category.categoryId)- if (!canAttemptStalkerCategory(hydration, System.currentTimeMillis())) {- return@mapNotNull null- }- val nextPage = nextStalkerAttemptPage(hydration)- progress(- provider.id,- onProgress,- "Indexing ${xtreamIndexSectionLabel(contentType)}: ${category.name} page $nextPage"- )- markStalkerAttemptStarted(- providerId = provider.id,- contentType = contentType,- categoryId = category.categoryId,- hydration = hydration,- attemptedPage = nextPage,- now = System.currentTimeMillis()- )- StalkerCategoryFetchAttempt(- category = category,- hydration = hydration,- nextPage = nextPage- )- }- if (attempts.isEmpty()) {- continue- }- val fetchedResults = coroutineScope {- attempts.map { attempt ->- async {- StalkerCategoryFetchResult(- attempt = attempt,- result = withStalkerFetchPermit(- provider = provider,- contentType = contentType,- categoryId = attempt.category.categoryId,- page = attempt.nextPage- ) {- fetchStalkerSummaryPageWithRecovery(- api = api,- contentType = contentType,- categoryId = attempt.category.categoryId,- page = attempt.nextPage,- splitVod = provider.catalogLayout == CatalogLayout.SPLIT- )- }- )- }- }.awaitAll()- }-- var windowRetryableFailures = 0- val successfulPages = mutableListOf<StalkerSuccessfulPage>()- for (fetched in fetchedResults) {- val category = fetched.attempt.category- val hydration = fetched.attempt.hydration- val nextPage = fetched.attempt.nextPage- if (fetched.result is Result.Error) {- stalkerRequestCoordinator.recordFailure(provider.id, fetched.result.exception)- }- when (val result = fetched.result) {- is Result.Success -> {- val pageFingerprint = stalkerPageFingerprint(result.data.items, contentType)- val anomaly = detectStalkerPageAnomaly(- hydration = hydration,- requestedPage = nextPage,- pagedResult = result.data,- pageFingerprint = pageFingerprint- )- if (anomaly != null) {- val indexedAt = System.currentTimeMillis()- skippedMalformedRows += result.data.items.size- val shouldRetryImmediately = category.categoryId !in retriedImmediately &&- ((hydration?.failureCount ?: 0) == 0)- markStalkerAttemptFailed(- providerId = provider.id,- contentType = contentType,- categoryId = category.categoryId,- hydration = hydration,- attemptedPage = nextPage,- now = indexedAt,- message = anomaly,- retryable = true,- pageFingerprint = pageFingerprint- )- if (shouldRetryImmediately) {- retriedImmediately += category.categoryId- pendingQueue.addLast(category)- }- upsertXtreamIndexJob(- providerId = provider.id,- section = contentType.name,- state = "RUNNING",- now = indexedAt,- skippedMalformedRows = skippedMalformedRows,- lastAttemptAt = indexedAt,- lastError = anomaly- )- continue- }- val dedupedItems = dedupeStalkerPageItems(result.data.items, contentType)- skippedMalformedRows += (result.data.items.size - dedupedItems.size).coerceAtLeast(0)- successfulPages += StalkerSuccessfulPage(- category = category,- hydration = hydration,- requestedPage = nextPage,- items = dedupedItems,- totalPages = result.data.totalPages,- pageSize = result.data.pageSize,- advertisedTotalItems = result.data.advertisedTotalItems,- advertisedTotalPages = result.data.advertisedTotalPages,- isComplete = result.data.isComplete,- isTruncated = result.data.isTruncated,- terminationReason = result.data.terminationReason,- pageFingerprint = pageFingerprint- )- }- is Result.Error -> {- val failedAt = System.currentTimeMillis()- val retryable = stalkerIndexFailureState(result.exception ?: IllegalStateException(result.message)) != "FAILED_PERMANENT"- if (retryable) {- windowRetryableFailures += 1- }- val shouldRetryImmediately = retryable &&- category.categoryId !in retriedImmediately &&- ((hydration?.failureCount ?: 0) == 0)- markStalkerAttemptFailed(- providerId = provider.id,- contentType = contentType,- categoryId = category.categoryId,- hydration = hydration,- attemptedPage = nextPage,- now = failedAt,- message = result.message,- retryable = retryable,- pageFingerprint = hydration?.lastPageFingerprint- )- if (shouldRetryImmediately) {- retriedImmediately += category.categoryId- pendingQueue.addLast(category)- }- if (!retryable) {- throw IllegalStateException(result.message, result.exception)- }- upsertXtreamIndexJob(- providerId = provider.id,- section = contentType.name,- state = "RUNNING",- now = failedAt,- skippedMalformedRows = skippedMalformedRows,- lastAttemptAt = now,- lastError = result.message- )- }- is Result.Loading -> Unit- }- }- if (successfulPages.isNotEmpty()) {- val indexedAt = System.currentTimeMillis()- when (contentType) {- ContentType.MOVIE -> {- val rawItems = successfulPages.flatMap { page -> page.items }- val classified = rawItems.filterIsInstance<StalkerVodCatalogItem>()- val movies = if (classified.isEmpty()) {- rawItems.filterIsInstance<Movie>()- } else {- classified.mapNotNull { (it.item as? VodCatalogItem.MovieItem)?.movie }- }- upsertXtreamMovieSummaryBatch(provider.id, movies, indexedAt, restoreWatchProgress = false)- if (classified.isNotEmpty()) {- upsertVodDerivedSeriesSummaryBatch(- provider.id,- classified.mapNotNull { (it.item as? VodCatalogItem.SeriesItem)?.series },- indexedAt- )- }- }- ContentType.SERIES -> upsertXtreamSeriesSummaryBatch(- provider.id,- successfulPages.flatMap { page -> page.items.filterIsInstance<Series>() },- indexedAt- )- else -> Unit- }- if (contentType == ContentType.MOVIE) {- restoreMovieWatchProgressPending = true- }- for (page in successfulPages) {- pagesCommitted += 1- rowsCommitted += page.items.size- val pageComplete = !page.isTruncated && (- page.isComplete ||- (page.items.isEmpty() && page.totalPages in 1..page.requestedPage)- )- val categoryCount = (page.hydration?.itemCount ?: 0) + page.items.size- markStalkerAttemptSucceeded(- providerId = provider.id,- contentType = contentType,- categoryId = page.category.categoryId,- hydration = page.hydration,- attemptedPage = page.requestedPage,- now = indexedAt,- itemCount = categoryCount,- totalPages = page.totalPages,- pageSize = page.pageSize,- advertisedTotalItems = page.advertisedTotalItems,- advertisedTotalPages = page.advertisedTotalPages,- pageComplete = pageComplete,- truncated = page.isTruncated,- terminationReason = page.terminationReason,- pageFingerprint = page.pageFingerprint- )- if (!pageComplete && !page.isTruncated && System.currentTimeMillis() < runDeadlineAt) {- pendingQueue.addLast(page.category)- }- }- }- if (!forceSequential && windowRetryableFailures >= minOf(2, attempts.size)) {- forceSequential = true- Log.w(- TAG,- "Stalker ${contentType.name} category fetch downgraded to sequential mode for provider ${provider.id} after retryable parallel failures."- )- }- }-- val refreshedHydration = visibleCategories.associate { category ->- category.categoryId to getStalkerHydrationSnapshot(provider.id, contentType, category.categoryId)- }- val finishedAt = System.currentTimeMillis()- val completedCategories = refreshedHydration.values.count { it?.isComplete == true }- val failedCategories = refreshedHydration.values.count { it?.isTerminalFailure == true }- val truncatedCategories = refreshedHydration.values.count { it?.isTruncated == true }- val hasMoreCategories = refreshedHydration.values.any { hydration ->- canAttemptStalkerCategory(hydration, finishedAt)- }- val retryDelaySeconds = nextRetryDelaySeconds(refreshedHydration.values, finishedAt)- val indexedRows = currentStalkerIndexedRowCount(provider.id, contentType)- val pruneSuppressed = refreshedHydration.values.any { hydration ->- hydration?.hasPruneSuppressionRisk == true- }- val deletedRows = if (!hasMoreCategories && failedCategories == 0 && !pruneSuppressed) {- xtreamContentIndexDao.pruneStaleLocalContentRows(provider.id, contentType.name)- } else {- 0- }- val finalState = when {- hasMoreCategories -> "QUEUED"- truncatedCategories > 0 -> "TRUNCATED"- failedCategories > 0 -> "PARTIAL"- pruneSuppressed -> "PARTIAL"- else -> "SUCCESS"- }- upsertXtreamIndexJob(- providerId = provider.id,- section = contentType.name,- state = finalState,- now = finishedAt,- totalCategories = visibleCategories.size,- completedCategories = completedCategories,- nextCategoryIndex = completedCategories,- failedCategories = failedCategories,- indexedRows = indexedRows,- skippedMalformedRows = skippedMalformedRows,- deletedPrunedRows = deletedRows,- clearPriority = clearPriority || finalState in setOf("SUCCESS", "TRUNCATED"),- lastAttemptAt = now,- lastSuccessAt = finishedAt.takeIf { finalState == "SUCCESS" },- lastError = refreshedHydration.values.firstOrNull {- it?.lastStatus in setOf("ERROR", "TRUNCATED")- }?.lastError- )- updateStalkerSummaryMetadata(provider.id, contentType, indexedRows, finalState, finishedAt)- Log.i(- TAG,- "Stalker ${contentType.name} indexing finished for provider ${provider.id}: state=$finalState completed=$completedCategories failed=$failedCategories rows=$indexedRows committedPages=$pagesCommitted committedRows=$rowsCommitted throughput=${stalkerThroughputSummary(sectionStartedAt, pagesCommitted, rowsCommitted)} retryDelay=${retryDelaySeconds}s"- )- } finally {- if (contentType == ContentType.MOVIE && restoreMovieWatchProgressPending) {- movieDao.restoreWatchProgress(provider.id)- }- }- }-- private fun stalkerCategoryFetchConcurrencyLimit(- provider: Provider,- runtimeProfile: CatalogSyncRuntimeProfile,- maxCategories: Int+ private suspend fun upsertXtreamMovieSummaryBatch(+ providerId: Long,+ movies: List<Movie>,+ indexedAt: Long,+ restoreWatchProgress: Boolean = true): Int {- val runtimeLimit = runtimeProfile.maxCategoryConcurrency.coerceAtLeast(1)- val effectiveLimit = runtimeLimit- return minOf(- maxCategories.coerceAtLeast(1),- effectiveLimit,- STALKER_MAX_PARALLEL_CATEGORY_FETCHES- ).coerceAtLeast(1)- }-- private fun stalkerThroughputSummary(- startedAt: Long,- pages: Int,- rows: Int- ): String {- val elapsedSeconds = ((System.currentTimeMillis() - startedAt).coerceAtLeast(1L)) / 1000.0- val pagesPerSecond = pages / elapsedSeconds- val rowsPerSecond = rows / elapsedSeconds- return "%.2f pages/s, %.2f rows/s".format(java.util.Locale.US, pagesPerSecond, rowsPerSecond)- }-- private suspend fun processStalkerWildcardIndexSection(- provider: Provider,- api: StalkerProvider,- contentType: ContentType,- wildcardCategory: CategoryEntity,- visibleCategories: List<CategoryEntity>,- maxPages: Int,- initialJob: StalkerIndexJobEntity?,- onProgress: ((String) -> Unit)?- ): Boolean {- val now = System.currentTimeMillis()- val normalVisibleCategoryIds = mutableSetOf<Long>()- visibleCategories.forEach { category ->- if (!api.isWildcardCategory(contentType, category.categoryId)) {- normalVisibleCategoryIds += category.categoryId- }+ if (movies.isEmpty()) return 0+ val incoming = movies.map { movie -> movie.toEntity().copy(cacheState = "SUMMARY_ONLY", detailHydratedAt = 0L, remoteStaleAt = 0L) }+ val existingByStreamId = loadMoviesByStreamIds(providerId, incoming.map { it.streamId })+ val merged = incoming.map { summary ->+ val existing = existingByStreamId[summary.streamId]+ mergeMovieSummary(existing, summary)}- val visibleCategoryIds = normalVisibleCategoryIds.takeIf { it.isNotEmpty() }- val hydration = getStalkerHydrationSnapshot(provider.id, contentType, wildcardCategory.categoryId)- if (!canAttemptStalkerCategory(hydration, now)) return false-- upsertXtreamIndexJob(- providerId = provider.id,- section = contentType.name,- state = "RUNNING",- now = now,- totalCategories = visibleCategories.size,- completedCategories = 0,- failedCategories = 0,- indexedRows = currentStalkerIndexedRowCount(provider.id, contentType),- lastAttemptAt = now,- lastError = null- )-- var skippedMalformedRows = initialJob?.skippedMalformedRows ?: 0- val seenPageFingerprints = mutableSetOf<String>()- var pagesProcessed = 0- var rowsCommitted = 0- var lastError: String? = null- var restoreMovieWatchProgressPending = false- var indexedRowsEstimate = currentStalkerIndexedRowCount(provider.id, contentType)- val sectionStartedAt = System.currentTimeMillis()-- try {- while (pagesProcessed < maxPages) {- if (pagesProcessed > 0) {- delay(StalkerTrafficCoordinator.backgroundInterPageDelayMillis(provider.id))- }- val currentHydration = getStalkerHydrationSnapshot(provider.id, contentType, wildcardCategory.categoryId)- if (!canAttemptStalkerCategory(currentHydration, System.currentTimeMillis())) break- val nextPage = nextStalkerAttemptPage(currentHydration)- progress(provider.id, onProgress, "Indexing ${xtreamIndexSectionLabel(contentType)}: All page $nextPage")- markStalkerAttemptStarted(- providerId = provider.id,- contentType = contentType,- categoryId = wildcardCategory.categoryId,- hydration = currentHydration,- attemptedPage = nextPage,- now = System.currentTimeMillis()- )- val coordinatedResult = withStalkerFetchPermit(- provider = provider,- contentType = contentType,- categoryId = wildcardCategory.categoryId,- page = nextPage- ) {- fetchStalkerWildcardSummaryPageWithRecovery(api, contentType, wildcardCategory.categoryId, nextPage)- }- if (coordinatedResult is Result.Error) {- stalkerRequestCoordinator.recordFailure(provider.id, coordinatedResult.exception)- }- when (val result = coordinatedResult) {- is Result.Success -> {- val indexedAt = System.currentTimeMillis()- val dedupedItems = dedupeStalkerPageItems(result.data.items, contentType)- val visibleItems = filterStalkerItemsToCategories(dedupedItems, contentType, visibleCategoryIds)- skippedMalformedRows += (result.data.items.size - visibleItems.size).coerceAtLeast(0)- if (nextPage == 1 && visibleItems.isEmpty()) {- val message = "Stalker wildcard catalog did not return usable visible ${xtreamIndexSectionLabel(contentType)} rows."- markStalkerAttemptFailed(- providerId = provider.id,- contentType = contentType,- categoryId = wildcardCategory.categoryId,- hydration = currentHydration,- attemptedPage = nextPage,- now = indexedAt,- message = message,- retryable = false,- pageFingerprint = null- )- Log.i(TAG, "$message Falling back to per-category indexing for provider ${provider.id}.")- api.recordWildcardCapability(contentType, supported = false)- return false- }-- val pageFingerprint = stalkerPageFingerprint(visibleItems, contentType)- val anomaly = detectStalkerPageAnomaly(- hydration = currentHydration,- requestedPage = nextPage,- pagedResult = com.streamvault.data.remote.stalker.StalkerPagedResult(- items = visibleItems,- page = result.data.page,- totalPages = result.data.totalPages,- pageSize = result.data.pageSize,- advertisedTotalItems = result.data.advertisedTotalItems,- advertisedTotalPages = result.data.advertisedTotalPages,- hasAdvertisedTotal = result.data.hasAdvertisedTotal,- isTruncated = result.data.isTruncated,- terminationReason = result.data.terminationReason- ),- pageFingerprint = pageFingerprint- ) ?: pageFingerprint- ?.takeIf { !seenPageFingerprints.add(it) }- ?.let { "Portal repeated a wildcard page payload." }-- if (anomaly != null) {- markStalkerAttemptFailed(- providerId = provider.id,- contentType = contentType,- categoryId = wildcardCategory.categoryId,- hydration = currentHydration,- attemptedPage = nextPage,- now = indexedAt,- message = anomaly,- retryable = false,- pageFingerprint = pageFingerprint- )- Log.i(TAG, "Stalker wildcard ${contentType.name} indexing disabled for provider ${provider.id}: $anomaly")- api.recordWildcardCapability(contentType, supported = false)- return false- }-- when (contentType) {- ContentType.MOVIE -> upsertXtreamMovieSummaryBatch(- provider.id,- visibleItems.filterIsInstance<Movie>(),- indexedAt,- restoreWatchProgress = false- )- ContentType.SERIES -> upsertXtreamSeriesSummaryBatch(provider.id, visibleItems.filterIsInstance<Series>(), indexedAt)- else -> Unit- }- if (contentType == ContentType.MOVIE && visibleItems.isNotEmpty()) {- restoreMovieWatchProgressPending = true- }- indexedRowsEstimate += visibleItems.size- rowsCommitted += visibleItems.size-- val pageComplete = !result.data.isTruncated && (- result.data.isComplete ||- (result.data.items.isEmpty() && result.data.totalPages in 1..nextPage)- )- markStalkerAttemptSucceeded(- providerId = provider.id,- contentType = contentType,- categoryId = wildcardCategory.categoryId,- hydration = currentHydration,- attemptedPage = nextPage,- now = indexedAt,- itemCount = indexedRowsEstimate,- totalPages = result.data.totalPages,- pageSize = result.data.pageSize,- advertisedTotalItems = result.data.advertisedTotalItems,- advertisedTotalPages = result.data.advertisedTotalPages,- pageComplete = pageComplete,- truncated = result.data.isTruncated,- terminationReason = result.data.terminationReason,- pageFingerprint = pageFingerprint- )- pagesProcessed += 1- if (pageComplete || result.data.isTruncated) break- }- is Result.Error -> {- val failedAt = System.currentTimeMillis()- lastError = result.message- val retryable = stalkerIndexFailureState(result.exception ?: IllegalStateException(result.message)) != "FAILED_PERMANENT"- markStalkerAttemptFailed(- providerId = provider.id,- contentType = contentType,- categoryId = wildcardCategory.categoryId,- hydration = currentHydration,- attemptedPage = nextPage,- now = failedAt,- message = result.message,- retryable = retryable,- pageFingerprint = currentHydration?.lastPageFingerprint- )- api.recordWildcardCapability(contentType, supported = false)- return false+ transactionRunner.inTransaction {+ movieDao.insertAll(merged)+ val persistedByStreamId = loadMoviesByStreamIds(providerId, merged.map { it.streamId })+ xtreamContentIndexDao.upsertAll(+ merged.map { movie ->+ val persisted = persistedByStreamId[movie.streamId] ?: movie+ movie.toXtreamIndexRow(providerId, persisted.id, indexedAt)}- is Result.Loading -> Unit- }- }-- val finishedAt = System.currentTimeMillis()- val refreshedHydration = getStalkerHydrationSnapshot(provider.id, contentType, wildcardCategory.categoryId)- val hasMorePages = canAttemptStalkerCategory(refreshedHydration, finishedAt)- val indexedRows = currentStalkerIndexedRowCount(provider.id, contentType)- val finalState = when {- hasMorePages -> "QUEUED"- refreshedHydration?.isTruncated == true -> "TRUNCATED"- refreshedHydration?.isTerminalFailure == true -> "PARTIAL"- refreshedHydration?.hasPruneSuppressionRisk == true -> "PARTIAL"- else -> "SUCCESS"- }- val deletedRows = if (finalState == "SUCCESS") {- xtreamContentIndexDao.pruneStaleLocalContentRows(provider.id, contentType.name)- } else {- 0+ )}- upsertXtreamIndexJob(- providerId = provider.id,- section = contentType.name,- state = finalState,- now = finishedAt,- totalCategories = visibleCategories.size,- completedCategories = if (finalState == "SUCCESS") visibleCategories.size else 0,- nextCategoryIndex = if (finalState in setOf("SUCCESS", "TRUNCATED")) visibleCategories.size else 0,- failedCategories = if (finalState == "PARTIAL") 1 else 0,- indexedRows = indexedRows,- skippedMalformedRows = skippedMalformedRows,- deletedPrunedRows = deletedRows,- clearPriority = finalState in setOf("SUCCESS", "TRUNCATED"),- lastAttemptAt = now,- lastSuccessAt = finishedAt.takeIf { finalState == "SUCCESS" },- lastError = lastError ?: refreshedHydration?.lastError- )- updateStalkerSummaryMetadata(provider.id, contentType, indexedRows, finalState, finishedAt)- Log.i(- TAG,- "Stalker wildcard ${contentType.name} indexing finished for provider ${provider.id}: state=$finalState pages=$pagesProcessed rows=$rowsCommitted totalRows=$indexedRows throughput=${stalkerThroughputSummary(sectionStartedAt, pagesProcessed, rowsCommitted)}"- )- return true- } finally {- if (contentType == ContentType.MOVIE && restoreMovieWatchProgressPending) {- movieDao.restoreWatchProgress(provider.id)- }+ if (restoreWatchProgress) {+ movieDao.restoreWatchProgress(providerId)}+ return merged.size}- private data class StalkerHydrationSnapshot(- val lastHydratedAt: Long,- val itemCount: Int,- val lastStatus: String,- val lastError: String?,- val lastLoadedPage: Int,- val lastAttemptedPage: Int,- val lastSuccessfulPage: Int,- val totalPages: Int,- val advertisedTotalItems: Int?,- val advertisedTotalPages: Int?,- val isComplete: Boolean,- val pageSize: Int,- val retryAfterMs: Long,- val failureCount: Int,- val retryBudgetRemaining: Int,- val lastPageFingerprint: String?- )-- private val StalkerHydrationSnapshot.isTerminalFailure: Boolean- get() = lastStatus in setOf("FAILED_PERMANENT", "FAILED_BUDGET_EXHAUSTED")-- private val StalkerHydrationSnapshot.isTruncated: Boolean- get() = lastStatus == "TRUNCATED"-- private val StalkerHydrationSnapshot.hasPruneSuppressionRisk: Boolean- get() = lastStatus in setOf("ANOMALY", "FAILED_RETRYABLE", "COOLDOWN", "TRUNCATED")-- private suspend fun getStalkerHydrationSnapshot(+ private suspend fun upsertXtreamSeriesSummaryBatch(providerId: Long,- contentType: ContentType,- categoryId: Long- ): StalkerHydrationSnapshot? = when (contentType) {- ContentType.MOVIE -> movieCategoryHydrationDao.get(providerId, categoryId)?.let { hydration ->- StalkerHydrationSnapshot(- lastHydratedAt = hydration.lastHydratedAt,- itemCount = hydration.itemCount,- lastStatus = hydration.lastStatus,- lastError = hydration.lastError,- lastLoadedPage = hydration.lastLoadedPage,- lastAttemptedPage = hydration.lastAttemptedPage,- lastSuccessfulPage = hydration.lastSuccessfulPage,- totalPages = hydration.totalPages,- advertisedTotalItems = hydration.advertisedTotalItems,- advertisedTotalPages = hydration.advertisedTotalPages,- isComplete = hydration.isComplete,- pageSize = hydration.pageSize,- retryAfterMs = hydration.retryAfterMs,- failureCount = hydration.failureCount,- retryBudgetRemaining = hydration.retryBudgetRemaining,- lastPageFingerprint = hydration.lastPageFingerprint- )+ series: List<Series>,+ indexedAt: Long+ ): Int {+ if (series.isEmpty()) return 0+ val incoming = series.map { item -> item.toEntity().copy(cacheState = "SUMMARY_ONLY", detailHydratedAt = 0L, remoteStaleAt = 0L) }+ val existingBySeriesId = loadSeriesByIds(providerId, incoming.map { it.seriesId })+ val merged = incoming.map { summary ->+ val existing = existingBySeriesId[summary.seriesId]+ mergeSeriesSummary(existing, summary)}- ContentType.SERIES -> seriesCategoryHydrationDao.get(providerId, categoryId)?.let { hydration ->- StalkerHydrationSnapshot(- lastHydratedAt = hydration.lastHydratedAt,- itemCount = hydration.itemCount,- lastStatus = hydration.lastStatus,- lastError = hydration.lastError,- lastLoadedPage = hydration.lastLoadedPage,- lastAttemptedPage = hydration.lastAttemptedPage,- lastSuccessfulPage = hydration.lastSuccessfulPage,- totalPages = hydration.totalPages,- advertisedTotalItems = hydration.advertisedTotalItems,- advertisedTotalPages = hydration.advertisedTotalPages,- isComplete = hydration.isComplete,- pageSize = hydration.pageSize,- retryAfterMs = hydration.retryAfterMs,- failureCount = hydration.failureCount,- retryBudgetRemaining = hydration.retryBudgetRemaining,- lastPageFingerprint = hydration.lastPageFingerprint+ transactionRunner.inTransaction {+ seriesDao.insertAll(merged)+ val persistedBySeriesId = loadSeriesByIds(providerId, merged.map { it.seriesId })+ xtreamContentIndexDao.upsertAll(+ merged.map { item ->+ val persisted = persistedBySeriesId[item.seriesId] ?: item+ item.toXtreamIndexRow(providerId, persisted.id, indexedAt)+ })}- else -> null- }-- private fun canAttemptStalkerCategory(- hydration: StalkerHydrationSnapshot?,- finishedAt: Long- ): Boolean {- if (hydration == null) return true- if (hydration.isComplete) return false- if (hydration.isTruncated) return false- if (hydration.isTerminalFailure) return false- if (hydration.retryBudgetRemaining <= 0) return false- if (hydration.retryAfterMs > finishedAt) return false- return true- }-- private fun nextStalkerAttemptPage(hydration: StalkerHydrationSnapshot?): Int {- if (hydration == null) return 1- if (hydration.lastStatus in setOf("FAILED_RETRYABLE", "COOLDOWN", "ANOMALY")) {- return hydration.lastAttemptedPage.coerceAtLeast(1)- }- return (hydration.lastSuccessfulPage + 1).coerceAtLeast(1)+ return merged.size}- private suspend fun markStalkerAttemptStarted(+ private suspend fun upsertVodDerivedSeriesSummaryBatch(providerId: Long,- contentType: ContentType,- categoryId: Long,- hydration: StalkerHydrationSnapshot?,- attemptedPage: Int,- now: Long- ) {- when (contentType) {- ContentType.MOVIE -> movieCategoryHydrationDao.upsert(- com.streamvault.data.local.entity.MovieCategoryHydrationEntity(- providerId = providerId,- categoryId = categoryId,- lastHydratedAt = hydration?.lastHydratedAt ?: 0L,- itemCount = hydration?.itemCount ?: 0,- lastStatus = "RUNNING",- lastError = null,- lastLoadedPage = hydration?.lastLoadedPage ?: 0,- lastAttemptedPage = attemptedPage,- lastSuccessfulPage = hydration?.lastSuccessfulPage ?: 0,- totalPages = hydration?.totalPages ?: 0,- advertisedTotalItems = hydration?.advertisedTotalItems,- advertisedTotalPages = hydration?.advertisedTotalPages,- isComplete = hydration?.isComplete ?: false,- pageSize = hydration?.pageSize ?: 0,- retryAfterMs = 0L,- failureCount = hydration?.failureCount ?: 0,- retryBudgetRemaining = hydration?.retryBudgetRemaining ?: STALKER_CATEGORY_RETRY_BUDGET,- lastPageFingerprint = hydration?.lastPageFingerprint- )+ series: List<Series>,+ indexedAt: Long+ ): Int {+ if (series.isEmpty()) return 0+ val incoming = series.map { item ->+ item.toEntity().copy(+ catalogOrigin = com.streamvault.domain.model.SeriesCatalogOrigin.VOD_DERIVED,+ cacheState = "SUMMARY_ONLY",+ detailHydratedAt = 0L,+ remoteStaleAt = 0L)- ContentType.SERIES -> seriesCategoryHydrationDao.upsert(- com.streamvault.data.local.entity.SeriesCategoryHydrationEntity(+ }+ var accepted = emptyList<SeriesEntity>()+ transactionRunner.inTransaction {+ val existing = seriesDao.getBySeriesIds(providerId, incoming.map { it.seriesId })+ .associateBy { it.seriesId }+ accepted = incoming.mapNotNull { summary ->+ val current = existing[summary.seriesId]+ if (current?.catalogOrigin == com.streamvault.domain.model.SeriesCatalogOrigin.NATIVE) {+ null+ } else {+ mergeSeriesSummary(current, summary)+ }+ }+ val projectedCategories = accepted.mapNotNull { item ->+ val categoryId = item.categoryId ?: return@mapNotNull null+ CategoryEntity(providerId = providerId,categoryId = categoryId,- lastHydratedAt = hydration?.lastHydratedAt ?: 0L,- itemCount = hydration?.itemCount ?: 0,- lastStatus = "RUNNING",- lastError = null,- lastLoadedPage = hydration?.lastLoadedPage ?: 0,- lastAttemptedPage = attemptedPage,- lastSuccessfulPage = hydration?.lastSuccessfulPage ?: 0,- totalPages = hydration?.totalPages ?: 0,- advertisedTotalItems = hydration?.advertisedTotalItems,- advertisedTotalPages = hydration?.advertisedTotalPages,- isComplete = hydration?.isComplete ?: false,- pageSize = hydration?.pageSize ?: 0,- retryAfterMs = 0L,- failureCount = hydration?.failureCount ?: 0,- retryBudgetRemaining = hydration?.retryBudgetRemaining ?: STALKER_CATEGORY_RETRY_BUDGET,- lastPageFingerprint = hydration?.lastPageFingerprint+ name = item.categoryName ?: "Category $categoryId",+ type = ContentType.SERIES,+ isAdult = item.isAdult,+ isUserProtected = item.isUserProtected)- )- else -> Unit+ }.distinctBy { it.categoryId }+ if (projectedCategories.isNotEmpty()) categoryDao.insertAll(projectedCategories)+ if (accepted.isNotEmpty()) {+ seriesDao.insertAll(accepted)+ val persisted = seriesDao.getBySeriesIds(providerId, accepted.map { it.seriesId })+ .associateBy { it.seriesId }+ xtreamContentIndexDao.upsertAll(+ accepted.map { item ->+ item.toXtreamIndexRow(providerId, persisted[item.seriesId]?.id ?: item.id, indexedAt)+ }+ )+ }}+ return accepted.size}- private suspend fun markStalkerAttemptSucceeded(+ private suspend fun loadMoviesByStreamIds(providerId: Long,- contentType: ContentType,- categoryId: Long,- hydration: StalkerHydrationSnapshot?,- attemptedPage: Int,- now: Long,- itemCount: Int,- totalPages: Int,- pageSize: Int,- advertisedTotalItems: Int? = null,- advertisedTotalPages: Int? = null,- pageComplete: Boolean,- truncated: Boolean = false,- terminationReason: String? = null,- pageFingerprint: String?- ) {- val status = if (truncated) "TRUNCATED" else "SUCCESS"- when (contentType) {- ContentType.MOVIE -> movieCategoryHydrationDao.upsert(- com.streamvault.data.local.entity.MovieCategoryHydrationEntity(- providerId = providerId,- categoryId = categoryId,- lastHydratedAt = now,- itemCount = itemCount,- lastStatus = status,- lastError = terminationReason,- lastLoadedPage = attemptedPage,- lastAttemptedPage = attemptedPage,- lastSuccessfulPage = attemptedPage,- totalPages = totalPages,- advertisedTotalItems = advertisedTotalItems,- advertisedTotalPages = advertisedTotalPages,- isComplete = pageComplete && !truncated,- pageSize = pageSize,- retryAfterMs = 0L,- failureCount = 0,- retryBudgetRemaining = STALKER_CATEGORY_RETRY_BUDGET,- lastPageFingerprint = pageFingerprint- )- )- ContentType.SERIES -> seriesCategoryHydrationDao.upsert(- com.streamvault.data.local.entity.SeriesCategoryHydrationEntity(- providerId = providerId,- categoryId = categoryId,- lastHydratedAt = now,- itemCount = itemCount,- lastStatus = status,- lastError = terminationReason,- lastLoadedPage = attemptedPage,- lastAttemptedPage = attemptedPage,- lastSuccessfulPage = attemptedPage,- totalPages = totalPages,- advertisedTotalItems = advertisedTotalItems,- advertisedTotalPages = advertisedTotalPages,- isComplete = pageComplete && !truncated,- pageSize = pageSize,- retryAfterMs = 0L,- failureCount = 0,- retryBudgetRemaining = STALKER_CATEGORY_RETRY_BUDGET,- lastPageFingerprint = pageFingerprint- )- )- else -> Unit- }+ streamIds: List<Long>+ ): Map<Long, MovieEntity> {+ return chunkedLookupById(+ ids = streamIds,+ chunkSize = XTREAM_SQLITE_LOOKUP_CHUNK_SIZE,+ fetch = { chunk -> movieDao.getByStreamIds(providerId, chunk) },+ keySelector = MovieEntity::streamId+ )}- private suspend fun markStalkerAttemptFailed(+ private suspend fun loadSeriesByIds(providerId: Long,- contentType: ContentType,- categoryId: Long,- hydration: StalkerHydrationSnapshot?,- attemptedPage: Int,- now: Long,- message: String,- retryable: Boolean,- pageFingerprint: String?- ) {- val priorFailures = hydration?.failureCount ?: 0- val remainingBudget = if (retryable) {- ((hydration?.retryBudgetRemaining ?: STALKER_CATEGORY_RETRY_BUDGET) - 1).coerceAtLeast(0)- } else {- 0- }- val nextStatus = when {- !retryable -> "FAILED_PERMANENT"- remainingBudget <= 0 -> "FAILED_BUDGET_EXHAUSTED"- else -> "FAILED_RETRYABLE"- }- val retryAfterMs = if (nextStatus == "FAILED_RETRYABLE" && priorFailures > 0) {- now + STALKER_CATEGORY_RETRY_COOLDOWN_MILLIS * (priorFailures + 1).coerceAtLeast(1)- } else {- 0L- }- when (contentType) {- ContentType.MOVIE -> movieCategoryHydrationDao.upsert(- com.streamvault.data.local.entity.MovieCategoryHydrationEntity(- providerId = providerId,- categoryId = categoryId,- lastHydratedAt = hydration?.lastHydratedAt ?: 0L,- itemCount = hydration?.itemCount ?: 0,- lastStatus = nextStatus,- lastError = message,- lastLoadedPage = hydration?.lastLoadedPage ?: 0,- lastAttemptedPage = attemptedPage,- lastSuccessfulPage = hydration?.lastSuccessfulPage ?: 0,- totalPages = hydration?.totalPages ?: 0,- advertisedTotalItems = hydration?.advertisedTotalItems,- advertisedTotalPages = hydration?.advertisedTotalPages,- isComplete = hydration?.isComplete ?: false,- pageSize = hydration?.pageSize ?: 0,- retryAfterMs = retryAfterMs,- failureCount = priorFailures + 1,- retryBudgetRemaining = remainingBudget,- lastPageFingerprint = pageFingerprint- )- )- ContentType.SERIES -> seriesCategoryHydrationDao.upsert(- com.streamvault.data.local.entity.SeriesCategoryHydrationEntity(- providerId = providerId,- categoryId = categoryId,- lastHydratedAt = hydration?.lastHydratedAt ?: 0L,- itemCount = hydration?.itemCount ?: 0,- lastStatus = nextStatus,- lastError = message,- lastLoadedPage = hydration?.lastLoadedPage ?: 0,- lastAttemptedPage = attemptedPage,- lastSuccessfulPage = hydration?.lastSuccessfulPage ?: 0,- totalPages = hydration?.totalPages ?: 0,- advertisedTotalItems = hydration?.advertisedTotalItems,- advertisedTotalPages = hydration?.advertisedTotalPages,- isComplete = hydration?.isComplete ?: false,- pageSize = hydration?.pageSize ?: 0,- retryAfterMs = retryAfterMs,- failureCount = priorFailures + 1,- retryBudgetRemaining = remainingBudget,- lastPageFingerprint = pageFingerprint- )- )- else -> Unit- }- }-- private suspend fun fetchStalkerSummaryPageWithRecovery(- api: StalkerProvider,- contentType: ContentType,- categoryId: Long,- page: Int,- splitVod: Boolean = false- ): Result<com.streamvault.data.remote.stalker.StalkerPagedResult<out Any>> {- suspend fun fetch(): Result<com.streamvault.data.remote.stalker.StalkerPagedResult<out Any>> {- if (splitVod && contentType == ContentType.MOVIE) {- val seriesCategoryId = api.projectVodCategoryToSeries(categoryId)- ?: return Result.error("Unable to resolve VOD-derived Series category")- return api.getSplitVodPage(categoryId, seriesCategoryId, page)- }- return fetchStalkerSummaryPage(api, contentType, categoryId, page)- }- val initial = fetch()- val recovered = if (initial is Result.Error && isLikelyStalkerAuthFailure(initial.message, initial.exception)) {- Log.w(- TAG,- "Retrying Stalker ${contentType.name} page $page after auth refresh for category $categoryId"- )- api.invalidateAuthentication()- fetch()- } else {- initial- }- if (page != 1 || recovered !is Result.Success || recovered.data.items.isNotEmpty()) {- return recovered- }- val fallback = fetchStalkerSummaryFirstPageFallback(api, contentType, categoryId)- return if (fallback is Result.Success && fallback.data.items.isNotEmpty()) {- Log.i(- TAG,- "Recovered empty paged Stalker ${contentType.name} first page with non-paged fallback for category $categoryId"- )- fallback- } else if (fallback is Result.Error && fallback.exception is StalkerApiError.CatalogTruncated) {- val truncation = fallback.exception as StalkerApiError.CatalogTruncated- Result.success(- com.streamvault.data.remote.stalker.StalkerPagedResult(- items = emptyList(),- page = 1,- totalPages = truncation.pageLimit,- pageSize = 0,- hasAdvertisedTotal = true,- advertisedTotalPages = truncation.advertisedTotalPages,- isTruncated = true,- terminationReason = "page_limit"- )- )- } else {- recovered- }- }-- private suspend fun fetchStalkerSummaryFirstPageFallback(- api: StalkerProvider,- contentType: ContentType,- categoryId: Long- ): Result<com.streamvault.data.remote.stalker.StalkerPagedResult<out Any>> = when (contentType) {- ContentType.MOVIE -> when (val result = api.getVodStreams(categoryId)) {- is Result.Success -> Result.success(- com.streamvault.data.remote.stalker.StalkerPagedResult(- items = result.data,- page = 1,- totalPages = 1,- pageSize = result.data.size- )- )- is Result.Error -> Result.error(result.message, result.exception)- is Result.Loading -> Result.error("Unexpected loading state from Stalker movie first-page fallback")- }- ContentType.SERIES -> when (val result = api.getSeriesList(categoryId)) {- is Result.Success -> Result.success(- com.streamvault.data.remote.stalker.StalkerPagedResult(- items = result.data,- page = 1,- totalPages = 1,- pageSize = result.data.size- )- )- is Result.Error -> Result.error(result.message, result.exception)- is Result.Loading -> Result.error("Unexpected loading state from Stalker series first-page fallback")- }- else -> Result.error("Unsupported Stalker summary first-page fallback section: $contentType")- }-- private suspend fun fetchStalkerWildcardSummaryPageWithRecovery(- api: StalkerProvider,- contentType: ContentType,- categoryId: Long,- page: Int- ): Result<com.streamvault.data.remote.stalker.StalkerPagedResult<out Any>> {- val initial = fetchStalkerWildcardSummaryPage(api, contentType, categoryId, page)- if (initial is Result.Error && isLikelyStalkerAuthFailure(initial.message, initial.exception)) {- Log.w(- TAG,- "Retrying Stalker wildcard ${contentType.name} page $page after auth refresh for category $categoryId"- )- api.invalidateAuthentication()- return fetchStalkerWildcardSummaryPage(api, contentType, categoryId, page)- }- return initial- }-- private fun detectStalkerPageAnomaly(- hydration: StalkerHydrationSnapshot?,- requestedPage: Int,- pagedResult: com.streamvault.data.remote.stalker.StalkerPagedResult<out Any>,- pageFingerprint: String?- ): String? {- if (pagedResult.page != requestedPage) {- return "Portal returned page ${pagedResult.page} while page $requestedPage was requested."- }- if (hydration != null && hydration.totalPages > 0 && pagedResult.totalPages > 0) {- if (pagedResult.totalPages < hydration.lastSuccessfulPage) {- return "Portal page count regressed below the last successful page."- }- if (- hydration.advertisedTotalPages != null &&- pagedResult.advertisedTotalPages != null &&- hydration.advertisedTotalPages != pagedResult.advertisedTotalPages- ) {- return "Portal changed its advertised catalog page count while indexing."- }- if (- hydration.lastAttemptedPage == requestedPage &&- hydration.lastPageFingerprint != null &&- hydration.lastPageFingerprint == pageFingerprint &&- hydration.lastStatus in setOf("FAILED_RETRYABLE", "RUNNING", "ANOMALY")- ) {- return "Portal repeated the same page payload for page $requestedPage."- }- }- return null- }-- private fun stalkerPageFingerprint(- items: List<out Any>,- contentType: ContentType- ): String? {- if (items.isEmpty()) return "empty"- val classifiedSeeds = items.filterIsInstance<StalkerVodCatalogItem>()- .map { entry -> "${entry.rawItemId}:${entry.item.stableId}" }- if (classifiedSeeds.isNotEmpty()) return sha1Hex(classifiedSeeds.joinToString("|"))- val seeds = when (contentType) {- ContentType.MOVIE -> items.filterIsInstance<Movie>().map { movie ->- "${movie.streamId}:${movie.categoryId}:${movie.addedAt}"- }- ContentType.SERIES -> items.filterIsInstance<Series>().map { series ->- "${series.providerSeriesId ?: series.seriesId}:${series.categoryId}:${series.lastModified}"- }- else -> emptyList()- }- if (seeds.isEmpty()) return null- return sha1Hex(seeds.joinToString("|"))- }-- private fun dedupeStalkerPageItems(- items: List<out Any>,- contentType: ContentType- ): List<out Any> {- val classified = items.filterIsInstance<StalkerVodCatalogItem>()- if (classified.isNotEmpty()) return classified.distinctBy(StalkerVodCatalogItem::rawItemId)- return when (contentType) {- ContentType.MOVIE -> items.filterIsInstance<Movie>().distinctBy(Movie::streamId)- ContentType.SERIES -> items.filterIsInstance<Series>().distinctBy { it.providerSeriesId ?: it.seriesId.toString() }- else -> items- }- }-- private fun filterStalkerItemsToCategories(- items: List<out Any>,- contentType: ContentType,- visibleCategoryIds: Set<Long>?- ): List<out Any> = when (contentType) {- ContentType.MOVIE -> items.filterIsInstance<Movie>().filter { movie ->- visibleCategoryIds == null || movie.categoryId in visibleCategoryIds- }- ContentType.SERIES -> items.filterIsInstance<Series>().filter { series ->- visibleCategoryIds == null || series.categoryId in visibleCategoryIds- }- else -> items- }-- private fun isLikelyStalkerAuthFailure(message: String, exception: Throwable?): Boolean {- return com.streamvault.data.remote.stalker.isStalkerAuthorizationFailure(message, exception)- }-- private fun sha1Hex(value: String): String {- val bytes = MessageDigest.getInstance("SHA-1").digest(value.toByteArray(Charsets.UTF_8))- return buildString(bytes.size * 2) {- bytes.forEach { byte -> append("%02x".format(byte)) }- }- }-- private fun stalkerIndexFailureState(error: Throwable): String {- if (isLikelyStalkerAuthFailure(sanitizeThrowableMessage(error), error)) {- return "FAILED_PERMANENT"- }- val message = sanitizeThrowableMessage(error).lowercase()- if (message.contains("not accessible") || message.contains("no accessible catalog")) {- return "FAILED_PERMANENT"- }- return "FAILED_RETRYABLE"- }-- private suspend fun fetchStalkerSummaryPage(- api: StalkerProvider,- contentType: ContentType,- categoryId: Long,- page: Int- ): Result<com.streamvault.data.remote.stalker.StalkerPagedResult<out Any>> = when (contentType) {- ContentType.MOVIE -> api.getVodStreamsPage(categoryId, page)- ContentType.SERIES -> api.getSeriesListPage(categoryId, page)- else -> Result.error("Unsupported Stalker summary page section: $contentType")- }-- private suspend fun fetchStalkerWildcardSummaryPage(- api: StalkerProvider,- contentType: ContentType,- categoryId: Long,- page: Int- ): Result<com.streamvault.data.remote.stalker.StalkerPagedResult<out Any>> = when (contentType) {- ContentType.MOVIE -> api.getVodStreamsPageUsingItemCategories(categoryId, page)- ContentType.SERIES -> api.getSeriesListPage(categoryId, page)- else -> Result.error("Unsupported Stalker wildcard summary page section: $contentType")- }-- private suspend fun allVisibleStalkerIndexCategories(- providerId: Long,- contentType: ContentType,- categories: List<CategoryEntity>- ): List<CategoryEntity> {- val hiddenCategoryIds = preferencesRepository.getHiddenCategoryIds(providerId, contentType).first()- return categories.filterNot { category -> category.categoryId in hiddenCategoryIds }- }-- private suspend fun visibleStalkerIndexCategories(- contentType: ContentType,- categories: List<CategoryEntity>,- api: StalkerProvider- ): List<CategoryEntity> {- val visible = categories- if (visible.isEmpty()) return emptyList()- val normalCategories = visible.filterNot { category -> api.isWildcardCategory(contentType, category.categoryId) }- return if (normalCategories.isNotEmpty()) normalCategories else visible- }-- private suspend fun currentStalkerIndexedRowCount(providerId: Long, contentType: ContentType): Int =- when (contentType) {- ContentType.MOVIE -> movieDao.getCount(providerId).first()- ContentType.SERIES -> seriesDao.getCount(providerId).first()- else -> 0- }-- private suspend fun currentStalkerCategoryCount(providerId: Long, contentType: ContentType, categoryId: Long): Int =- when (contentType) {- ContentType.MOVIE -> movieDao.getCountByCategory(providerId, categoryId).first()- ContentType.SERIES -> seriesDao.getCountByCategory(providerId, categoryId).first()- else -> 0- }-- private suspend fun updateStalkerSummaryMetadata(- providerId: Long,- contentType: ContentType,- indexedRows: Int,- finalState: String,- now: Long- ) {- val metadata = syncMetadataRepository.getMetadata(providerId) ?: SyncMetadata(providerId)- when (contentType) {- ContentType.MOVIE -> syncMetadataRepository.updateMetadata(- metadata.copy(- lastMovieSync = now,- lastMovieAttempt = now,- lastMovieSuccess = if (finalState == "SUCCESS") now else metadata.lastMovieSuccess,- lastMoviePartial = if (finalState != "SUCCESS") now else metadata.lastMoviePartial,- movieCount = if (finalState == "SUCCESS") indexedRows else metadata.movieCount.coerceAtLeast(indexedRows),- movieCatalogStale = finalState != "SUCCESS",- movieSyncMode = VodSyncMode.PAGED- )- )- ContentType.SERIES -> syncMetadataRepository.updateMetadata(- metadata.copy(- lastSeriesSync = now,- lastSeriesSuccess = if (finalState == "SUCCESS") now else metadata.lastSeriesSuccess,- seriesCount = if (finalState == "SUCCESS") indexedRows else metadata.seriesCount.coerceAtLeast(indexedRows)- )- )- else -> Unit- }- }-- private suspend fun processXtreamSummaryIndexSection(- provider: Provider,- api: XtreamProvider,- contentType: ContentType,- maxCategories: Int?,- onProgress: ((String) -> Unit)?- ) {- require(contentType == ContentType.MOVIE || contentType == ContentType.SERIES) {- "Unsupported Xtream summary index section: $contentType"- }- val now = System.currentTimeMillis()- val categories = categoryDao.getByProviderAndTypeSync(provider.id, contentType.name)- if (categories.isEmpty()) {- syncXtreamCategoryShell(- provider = provider,- api = api,- contentType = contentType,- label = xtreamIndexSectionLabel(contentType),- now = now,- onProgress = onProgress- ).getOrThrow()- }- val initialJob = xtreamIndexJobDao.get(provider.id, contentType.name)- val priorityCategoryId = initialJob?.priorityCategoryId- val indexedCategories = categoryDao.getByProviderAndTypeSync(provider.id, contentType.name)- val resumeJob = initialJob?.takeIf { it.state in setOf("QUEUED", "RUNNING", "PARTIAL") }- val categoryLimit = maxCategories?.coerceAtLeast(1) ?: Int.MAX_VALUE- var nextCategoryIndex = resumeJob?.nextCategoryIndex?.coerceIn(0, indexedCategories.size) ?: 0- var restoreMovieWatchProgressPending = false- try {- if (shouldAttemptFullXtreamSummaryStream(resumeJob, priorityCategoryId)) {- when (val streamed = streamFullXtreamSummaryIndex(- provider = provider,- api = api,- contentType = contentType,- categories = indexedCategories,- totalCategories = indexedCategories.size,- now = now,- onProgress = onProgress- )) {- is Result.Success -> return- is Result.Error -> {- Log.w(- TAG,- "Full ${contentType.name} stream index failed for provider ${provider.id}; falling back to category slices: ${streamed.message}"- )- upsertXtreamIndexJob(- providerId = provider.id,- section = contentType.name,- state = "QUEUED",- now = System.currentTimeMillis(),- totalCategories = indexedCategories.size,- completedCategories = 0,- nextCategoryIndex = 0,- failedCategories = 0,- lastAttemptAt = now,- lastError = streamed.message- )- nextCategoryIndex = 0- }- Result.Loading -> Unit- }- }- upsertXtreamIndexJob(- providerId = provider.id,- section = contentType.name,- state = "RUNNING",- now = now,- totalCategories = indexedCategories.size,- completedCategories = resumeJob?.completedCategories ?: 0,- nextCategoryIndex = nextCategoryIndex,- failedCategories = resumeJob?.failedCategories ?: 0,- indexedRows = resumeJob?.indexedRows ?: 0,- skippedMalformedRows = resumeJob?.skippedMalformedRows ?: 0,- lastAttemptAt = now,- lastError = null- )-- var completedCategories = resumeJob?.completedCategories ?: 0- var failedCategories = resumeJob?.failedCategories ?: 0- var indexedRows = resumeJob?.indexedRows ?: 0- var skippedMalformedRows = resumeJob?.skippedMalformedRows ?: 0- var lastError: Throwable? = null- var priorityHandled = false-- data class CategoryIndexWork(- val category: CategoryEntity,- val advancesCursor: Boolean- )-- val workItems = buildList {- val priorityIndex = priorityCategoryId?.let { id ->- indexedCategories.indexOfFirst { it.categoryId == id }.takeIf { index -> index >= 0 }- }- if (priorityIndex != null && priorityIndex != nextCategoryIndex && size < categoryLimit) {- add(CategoryIndexWork(indexedCategories[priorityIndex], advancesCursor = false))- }- while (nextCategoryIndex < indexedCategories.size && size < categoryLimit) {- val category = indexedCategories[nextCategoryIndex]- nextCategoryIndex++- if (- priorityCategoryId != null &&- category.categoryId == priorityCategoryId &&- any { it.category.categoryId == priorityCategoryId }- ) {- continue- }- add(CategoryIndexWork(category, advancesCursor = true))- }- }-- for (workItem in workItems) {- val category = workItem.category- progress(provider.id, onProgress, "Indexing ${xtreamIndexSectionLabel(contentType)}: ${category.name}")- val outcome = when (contentType) {- ContentType.MOVIE -> fetchMovieCategoryOutcome(provider, api, category.toXtreamCategory())- ContentType.SERIES -> fetchSeriesCategoryOutcome(provider, api, category.toXtreamCategory())- else -> error("Unsupported section")- }- when (val categoryOutcome = outcome.outcome) {- is CategoryFetchOutcome.Success -> {- val accepted = when (contentType) {- ContentType.MOVIE -> upsertXtreamMovieSummaryBatch(- providerId = provider.id,- movies = categoryOutcome.items.filterIsInstance<Movie>(),- indexedAt = System.currentTimeMillis(),- restoreWatchProgress = false- )- ContentType.SERIES -> upsertXtreamSeriesSummaryBatch(- providerId = provider.id,- series = categoryOutcome.items.filterIsInstance<Series>(),- indexedAt = System.currentTimeMillis()- )- else -> 0- }- if (workItem.advancesCursor) {- indexedRows += accepted- skippedMalformedRows += (categoryOutcome.rawCount - categoryOutcome.items.size).coerceAtLeast(0)- completedCategories++- }- if (contentType == ContentType.MOVIE && accepted > 0) {- restoreMovieWatchProgressPending = true- }- if (category.categoryId == priorityCategoryId) {- priorityHandled = true- upsertXtreamIndexJob(- providerId = provider.id,- section = contentType.name,- state = "RUNNING",- now = System.currentTimeMillis(),- clearPriority = true- )- }- }- is CategoryFetchOutcome.Empty -> {- if (workItem.advancesCursor) {- completedCategories++- }- if (category.categoryId == priorityCategoryId) {- priorityHandled = true- upsertXtreamIndexJob(- providerId = provider.id,- section = contentType.name,- state = "RUNNING",- now = System.currentTimeMillis(),- clearPriority = true- )- }- }- is CategoryFetchOutcome.Failure -> {- if (workItem.advancesCursor) {- failedCategories++- }- lastError = categoryOutcome.error- }- }- upsertXtreamIndexJob(- providerId = provider.id,- section = contentType.name,- state = if (failedCategories > 0) "PARTIAL" else "RUNNING",- now = System.currentTimeMillis(),- totalCategories = indexedCategories.size,- completedCategories = completedCategories,- nextCategoryIndex = nextCategoryIndex,- failedCategories = failedCategories,- indexedRows = indexedRows,- skippedMalformedRows = skippedMalformedRows,- lastAttemptAt = now,- lastError = lastError?.let(::sanitizeThrowableMessage)- )- }-- val finishedAt = System.currentTimeMillis()- val hasMoreCategories = nextCategoryIndex < indexedCategories.size- val finalState = when {- hasMoreCategories -> "QUEUED"- failedCategories > 0 -> "PARTIAL"- else -> "SUCCESS"- }- val priorityWasNotPresent = priorityCategoryId != null &&- indexedCategories.none { it.categoryId == priorityCategoryId }- upsertXtreamIndexJob(- providerId = provider.id,- section = contentType.name,- state = finalState,- now = finishedAt,- totalCategories = indexedCategories.size,- completedCategories = completedCategories,- nextCategoryIndex = nextCategoryIndex,- failedCategories = failedCategories,- indexedRows = indexedRows,- skippedMalformedRows = skippedMalformedRows,- clearPriority = finalState == "SUCCESS" || priorityWasNotPresent || priorityHandled,- lastAttemptAt = now,- lastSuccessAt = if (finalState == "SUCCESS") finishedAt else null,- lastError = lastError?.let(::sanitizeThrowableMessage)- )- updateXtreamSummaryMetadata(provider.id, contentType, indexedRows, finalState, finishedAt)- if (hasMoreCategories) {- scheduleXtreamIndexSync(provider.id, contentType, force = false)- }- if (!hasMoreCategories && failedCategories > 0) {- throw IllegalStateException(- "${xtreamIndexSectionLabel(contentType)} indexing completed partially.",- lastError- )- }- } finally {- if (contentType == ContentType.MOVIE && restoreMovieWatchProgressPending) {- movieDao.restoreWatchProgress(provider.id)- }- }- }-- private fun shouldAttemptFullXtreamSummaryStream(- resumeJob: XtreamIndexJobEntity?,- priorityCategoryId: Long?- ): Boolean {- if (priorityCategoryId != null && resumeJob?.nextCategoryIndex != 0) return false- if (resumeJob == null) return true- return resumeJob.nextCategoryIndex == 0 &&- resumeJob.completedCategories == 0 &&- resumeJob.failedCategories == 0 &&- resumeJob.indexedRows == 0- }-- private suspend fun streamFullXtreamSummaryIndex(- provider: Provider,- api: XtreamProvider,- contentType: ContentType,- categories: List<CategoryEntity>,- totalCategories: Int,- now: Long,- onProgress: ((String) -> Unit)?- ): Result<Int> {- progress(provider.id, onProgress, "Indexing ${xtreamIndexSectionLabel(contentType)}...")- upsertXtreamIndexJob(- providerId = provider.id,- section = contentType.name,- state = "RUNNING",- now = now,- totalCategories = totalCategories,- completedCategories = 0,- nextCategoryIndex = 0,- failedCategories = 0,- indexedRows = 0,- skippedMalformedRows = 0,- lastAttemptAt = now,- lastError = null- )-- var indexedRows = 0- var restoreMovieWatchProgressPending = false- val categoryNamesById = categories.associate { it.categoryId to it.name }- val adultCategoryIds = categories.filter { it.isAdult }.mapTo(mutableSetOf()) { it.categoryId }- try {- val streamResult = when (contentType) {- ContentType.MOVIE -> api.streamVodSummaries(adultCategoryIds = adultCategoryIds) { batch ->- val accepted = upsertXtreamMovieSummaryBatch(- providerId = provider.id,- movies = batch.withMovieCategoryNames(categoryNamesById),- indexedAt = System.currentTimeMillis(),- restoreWatchProgress = false- )- indexedRows += accepted- if (accepted > 0) {- restoreMovieWatchProgressPending = true- }- upsertXtreamIndexJob(- providerId = provider.id,- section = contentType.name,- state = "RUNNING",- now = System.currentTimeMillis(),- totalCategories = totalCategories,- completedCategories = 0,- nextCategoryIndex = 0,- indexedRows = indexedRows,- lastAttemptAt = now,- lastError = null- )- }- ContentType.SERIES -> api.streamSeriesSummaries(adultCategoryIds = adultCategoryIds) { batch ->- val accepted = upsertXtreamSeriesSummaryBatch(- providerId = provider.id,- series = batch.withSeriesCategoryNames(categoryNamesById),- indexedAt = System.currentTimeMillis()- )- indexedRows += accepted- upsertXtreamIndexJob(- providerId = provider.id,- section = contentType.name,- state = "RUNNING",- now = System.currentTimeMillis(),- totalCategories = totalCategories,- completedCategories = 0,- nextCategoryIndex = 0,- indexedRows = indexedRows,- lastAttemptAt = now,- lastError = null- )- }- else -> Result.error("Unsupported Xtream summary stream section: $contentType")- }-- return when (streamResult) {- is Result.Success -> {- val finishedAt = System.currentTimeMillis()- val acceptedCount = indexedRows.coerceAtLeast(streamResult.data)- upsertXtreamIndexJob(- providerId = provider.id,- section = contentType.name,- state = "SUCCESS",- now = finishedAt,- totalCategories = totalCategories,- completedCategories = totalCategories,- nextCategoryIndex = totalCategories,- failedCategories = 0,- indexedRows = acceptedCount,- skippedMalformedRows = 0,- clearPriority = true,- lastAttemptAt = now,- lastSuccessAt = finishedAt,- lastError = null- )- updateXtreamSummaryMetadata(provider.id, contentType, acceptedCount, "SUCCESS", finishedAt)- Result.success(acceptedCount)- }- is Result.Error -> streamResult- Result.Loading -> Result.error("Xtream summary stream did not complete")- }- } finally {- if (contentType == ContentType.MOVIE && restoreMovieWatchProgressPending) {- movieDao.restoreWatchProgress(provider.id)- }- }- }-- private fun List<Movie>.withMovieCategoryNames(categoryNamesById: Map<Long, String>): List<Movie> =- map { movie ->- val categoryName = movie.categoryId?.let(categoryNamesById::get)- if (categoryName == null || categoryName == movie.categoryName) movie else movie.copy(categoryName = categoryName)- }-- private fun List<Series>.withSeriesCategoryNames(categoryNamesById: Map<Long, String>): List<Series> =- map { series ->- val categoryName = series.categoryId?.let(categoryNamesById::get)- if (categoryName == null || categoryName == series.categoryName) series else series.copy(categoryName = categoryName)- }-- private suspend fun upsertXtreamMovieSummaryBatch(- providerId: Long,- movies: List<Movie>,- indexedAt: Long,- restoreWatchProgress: Boolean = true- ): Int {- if (movies.isEmpty()) return 0- val incoming = movies.map { movie -> movie.toEntity().copy(cacheState = "SUMMARY_ONLY", detailHydratedAt = 0L, remoteStaleAt = 0L) }- val existingByStreamId = loadMoviesByStreamIds(providerId, incoming.map { it.streamId })- val merged = incoming.map { summary ->- val existing = existingByStreamId[summary.streamId]- mergeMovieSummary(existing, summary)- }- transactionRunner.inTransaction {- movieDao.insertAll(merged)- val persistedByStreamId = loadMoviesByStreamIds(providerId, merged.map { it.streamId })- xtreamContentIndexDao.upsertAll(- merged.map { movie ->- val persisted = persistedByStreamId[movie.streamId] ?: movie- movie.toXtreamIndexRow(providerId, persisted.id, indexedAt)- }- )- }- if (restoreWatchProgress) {- movieDao.restoreWatchProgress(providerId)- }- return merged.size- }-- private suspend fun upsertXtreamSeriesSummaryBatch(- providerId: Long,- series: List<Series>,- indexedAt: Long- ): Int {- if (series.isEmpty()) return 0- val incoming = series.map { item -> item.toEntity().copy(cacheState = "SUMMARY_ONLY", detailHydratedAt = 0L, remoteStaleAt = 0L) }- val existingBySeriesId = loadSeriesByIds(providerId, incoming.map { it.seriesId })- val merged = incoming.map { summary ->- val existing = existingBySeriesId[summary.seriesId]- mergeSeriesSummary(existing, summary)- }- transactionRunner.inTransaction {- seriesDao.insertAll(merged)- val persistedBySeriesId = loadSeriesByIds(providerId, merged.map { it.seriesId })- xtreamContentIndexDao.upsertAll(- merged.map { item ->- val persisted = persistedBySeriesId[item.seriesId] ?: item- item.toXtreamIndexRow(providerId, persisted.id, indexedAt)- }- )- }- return merged.size- }-- private suspend fun upsertVodDerivedSeriesSummaryBatch(- providerId: Long,- series: List<Series>,- indexedAt: Long- ): Int {- if (series.isEmpty()) return 0- val incoming = series.map { item ->- item.toEntity().copy(- catalogOrigin = com.streamvault.domain.model.SeriesCatalogOrigin.VOD_DERIVED,- cacheState = "SUMMARY_ONLY",- detailHydratedAt = 0L,- remoteStaleAt = 0L- )- }- var accepted = emptyList<SeriesEntity>()- transactionRunner.inTransaction {- val existing = seriesDao.getBySeriesIds(providerId, incoming.map { it.seriesId })- .associateBy { it.seriesId }- accepted = incoming.mapNotNull { summary ->- val current = existing[summary.seriesId]- if (current?.catalogOrigin == com.streamvault.domain.model.SeriesCatalogOrigin.NATIVE) {- null- } else {- mergeSeriesSummary(current, summary)- }- }- val projectedCategories = accepted.mapNotNull { item ->- val categoryId = item.categoryId ?: return@mapNotNull null- CategoryEntity(- providerId = providerId,- categoryId = categoryId,- name = item.categoryName ?: "Category $categoryId",- type = ContentType.SERIES,- isAdult = item.isAdult,- isUserProtected = item.isUserProtected- )- }.distinctBy { it.categoryId }- if (projectedCategories.isNotEmpty()) categoryDao.insertAll(projectedCategories)- if (accepted.isNotEmpty()) {- seriesDao.insertAll(accepted)- val persisted = seriesDao.getBySeriesIds(providerId, accepted.map { it.seriesId })- .associateBy { it.seriesId }- xtreamContentIndexDao.upsertAll(- accepted.map { item ->- item.toXtreamIndexRow(providerId, persisted[item.seriesId]?.id ?: item.id, indexedAt)- }- )- }- }- return accepted.size- }-- private suspend fun loadMoviesByStreamIds(- providerId: Long,- streamIds: List<Long>- ): Map<Long, MovieEntity> {- return chunkedLookupById(- ids = streamIds,- chunkSize = XTREAM_SQLITE_LOOKUP_CHUNK_SIZE,- fetch = { chunk -> movieDao.getByStreamIds(providerId, chunk) },- keySelector = MovieEntity::streamId- )- }-- private suspend fun loadSeriesByIds(- providerId: Long,- seriesIds: List<Long>- ): Map<Long, SeriesEntity> {- return chunkedLookupById(- ids = seriesIds,- chunkSize = XTREAM_SQLITE_LOOKUP_CHUNK_SIZE,- fetch = { chunk -> seriesDao.getBySeriesIds(providerId, chunk) },- keySelector = SeriesEntity::seriesId- )- }-- private fun mergeMovieSummary(existing: MovieEntity?, summary: MovieEntity): MovieEntity {- if (existing == null) return summary- val preserveDetails = existing.cacheState == "DETAIL_HYDRATED" && existing.detailHydratedAt > 0L- return summary.copy(- id = existing.id,- posterUrl = summary.posterUrl ?: existing.posterUrl,- backdropUrl = if (preserveDetails) existing.backdropUrl else summary.backdropUrl,- plot = if (preserveDetails) existing.plot else summary.plot,- cast = if (preserveDetails) existing.cast else summary.cast,- director = if (preserveDetails) existing.director else summary.director,- genre = summary.genre ?: existing.genre,- releaseDate = if (preserveDetails) existing.releaseDate else summary.releaseDate,- duration = if (preserveDetails) existing.duration else summary.duration,- durationSeconds = if (preserveDetails) existing.durationSeconds else summary.durationSeconds,- year = if (preserveDetails) existing.year else summary.year,- tmdbId = summary.tmdbId ?: existing.tmdbId,- youtubeTrailer = summary.youtubeTrailer ?: existing.youtubeTrailer,- watchProgress = existing.watchProgress,- watchCount = existing.watchCount,- lastWatchedAt = existing.lastWatchedAt,- isUserProtected = existing.isUserProtected,- cacheState = if (preserveDetails) existing.cacheState else "SUMMARY_ONLY",- detailHydratedAt = if (preserveDetails) existing.detailHydratedAt else 0L,- remoteStaleAt = 0L- )- }-- private fun mergeSeriesSummary(existing: SeriesEntity?, summary: SeriesEntity): SeriesEntity {- if (existing == null) return summary- val preserveDetails = existing.cacheState == "DETAIL_HYDRATED" && existing.detailHydratedAt > 0L- return summary.copy(- id = existing.id,- providerSeriesId = summary.providerSeriesId ?: existing.providerSeriesId,- posterUrl = summary.posterUrl ?: existing.posterUrl,- backdropUrl = if (preserveDetails) existing.backdropUrl else summary.backdropUrl,- plot = if (preserveDetails) existing.plot else summary.plot,- cast = if (preserveDetails) existing.cast else summary.cast,- director = if (preserveDetails) existing.director else summary.director,- genre = summary.genre ?: existing.genre,- releaseDate = if (preserveDetails) existing.releaseDate else summary.releaseDate,- tmdbId = summary.tmdbId ?: existing.tmdbId,- youtubeTrailer = summary.youtubeTrailer ?: existing.youtubeTrailer,- episodeRunTime = if (preserveDetails) existing.episodeRunTime else summary.episodeRunTime,- isUserProtected = existing.isUserProtected,- cacheState = if (preserveDetails) existing.cacheState else "SUMMARY_ONLY",- detailHydratedAt = if (preserveDetails) existing.detailHydratedAt else 0L,- remoteStaleAt = 0L- )- }-- private fun MovieEntity.toXtreamIndexRow(- providerId: Long,- localContentId: Long,- indexedAt: Long- ): XtreamContentIndexEntity = XtreamContentIndexEntity(- providerId = providerId,- contentType = ContentType.MOVIE,- remoteId = streamId.toString(),- localContentId = localContentId.takeIf { it > 0L },- name = name,- categoryId = categoryId,- categoryName = categoryName,- imageUrl = posterUrl,- containerExtension = containerExtension,- rating = rating,- addedAt = addedAt,- isAdult = isAdult,- indexedAt = indexedAt,- detailHydratedAt = detailHydratedAt,- staleState = "ACTIVE",- errorState = null,- syncFingerprint = syncFingerprint- )-- private fun SeriesEntity.toXtreamIndexRow(- providerId: Long,- localContentId: Long,- indexedAt: Long- ): XtreamContentIndexEntity = XtreamContentIndexEntity(- providerId = providerId,- contentType = ContentType.SERIES,- remoteId = providerSeriesId?.takeIf { it.isNotBlank() } ?: seriesId.toString(),- localContentId = localContentId.takeIf { it > 0L },- name = name,- categoryId = categoryId,- categoryName = categoryName,- imageUrl = posterUrl,- rating = rating,- remoteUpdatedAt = lastModified,- isAdult = isAdult,- indexedAt = indexedAt,- detailHydratedAt = detailHydratedAt,- staleState = "ACTIVE",- errorState = null,- syncFingerprint = syncFingerprint- )-- private suspend fun updateXtreamSummaryMetadata(- providerId: Long,- contentType: ContentType,- indexedRows: Int,- finalState: String,- now: Long- ) {- val metadata = syncMetadataRepository.getMetadata(providerId) ?: SyncMetadata(providerId)- when (contentType) {- ContentType.MOVIE -> syncMetadataRepository.updateMetadata(- metadata.copy(- lastMovieSync = now,- lastMovieAttempt = now,- lastMovieSuccess = if (finalState == "SUCCESS") now else metadata.lastMovieSuccess,- lastMoviePartial = if (finalState != "SUCCESS") now else metadata.lastMoviePartial,- movieCount = if (finalState == "SUCCESS") indexedRows else metadata.movieCount.coerceAtLeast(indexedRows),- movieCatalogStale = finalState != "SUCCESS",- movieSyncMode = VodSyncMode.UNKNOWN- )- )- ContentType.SERIES -> syncMetadataRepository.updateMetadata(- metadata.copy(- lastSeriesSync = now,- lastSeriesSuccess = if (finalState == "SUCCESS") now else metadata.lastSeriesSuccess,- seriesCount = if (finalState == "SUCCESS") indexedRows else metadata.seriesCount.coerceAtLeast(indexedRows)- )- )- else -> Unit- }- }-- private fun CategoryEntity.toXtreamCategory(): XtreamCategory = XtreamCategory(- categoryId = categoryId.toString(),- categoryName = name,- parentId = parentId?.toInt() ?: 0,- isAdult = isAdult- )-- private fun xtreamIndexSectionLabel(contentType: ContentType): String = when (contentType) {- ContentType.MOVIE -> "Movies"- ContentType.SERIES -> "Series"- ContentType.LIVE -> "Live TV"- ContentType.VOD -> "VOD"- ContentType.SERIES_EPISODE -> "Episodes"- }-- private suspend fun processXtreamLiveIndexBackfillSection(- providerId: Long,- onProgress: ((String) -> Unit)?- ) {- val now = System.currentTimeMillis()- progress(providerId, onProgress, "Preparing Live TV index...")- upsertXtreamIndexJob(- providerId = providerId,- section = ContentType.LIVE.name,- state = "RUNNING",- now = now,- lastAttemptAt = now,- lastError = null- )- val categoryCount = categoryDao.getByProviderAndTypeSync(providerId, ContentType.LIVE.name).size- val indexedRows = backfillXtreamLiveIndex(providerId, now)- upsertXtreamIndexJob(- providerId = providerId,- section = ContentType.LIVE.name,- state = "SUCCESS",- now = System.currentTimeMillis(),- totalCategories = categoryCount,- completedCategories = categoryCount,- nextCategoryIndex = categoryCount,- failedCategories = 0,- indexedRows = indexedRows,- skippedMalformedRows = 0,- lastAttemptAt = now,- lastSuccessAt = System.currentTimeMillis(),- lastError = null- )- }-- private suspend fun backfillXtreamLiveIndex(providerId: Long, indexedAt: Long): Int {- val channels = channelDao.getByProviderSync(providerId)- if (channels.isEmpty()) return 0- val indexRows = channels.map { channel ->- XtreamContentIndexEntity(- providerId = providerId,- contentType = ContentType.LIVE,- remoteId = channel.streamId.toString(),- localContentId = channel.id.takeIf { it > 0 },- name = channel.name,- categoryId = channel.categoryId,- categoryName = channel.categoryName ?: channel.groupTitle,- imageUrl = channel.logoUrl,- isAdult = channel.isAdult,- indexedAt = indexedAt,- detailHydratedAt = indexedAt,- syncFingerprint = channel.syncFingerprint- )- }- transactionRunner.inTransaction {- xtreamContentIndexDao.deleteByProviderAndType(providerId, ContentType.LIVE.name)- xtreamContentIndexDao.upsertAll(indexRows)- }- return channels.size- }-- private fun xtreamIndexFailureState(error: Throwable): String {- val chain = generateSequence(error as Throwable?) { it.cause }.toList()- if (chain.any { it is XtreamAuthenticationException }) {- return "FAILED_PERMANENT"- }- val requestFailure = chain.filterIsInstance<XtreamRequestException>().firstOrNull()- if (requestFailure?.statusCode == 401 || requestFailure?.statusCode == 403) {- return "FAILED_PERMANENT"- }- return "FAILED_RETRYABLE"- }-- private suspend fun upsertXtreamIndexJob(- providerId: Long,- section: String,- state: String,- now: Long,- totalCategories: Int? = null,- completedCategories: Int? = null,- nextCategoryIndex: Int? = null,- failedCategories: Int? = null,- indexedRows: Int? = null,- skippedMalformedRows: Int? = null,- deletedPrunedRows: Int? = null,- priorityCategoryId: Long? = null,- priorityRequestedAt: Long? = null,- clearPriority: Boolean = false,- lastAttemptAt: Long? = null,- lastSuccessAt: Long? = null,- lastError: String? = null- ) {- val providerType = providerDao.getById(providerId)?.type- val stalkerSection = runCatching { ContentType.valueOf(section) }.getOrNull()- if (- providerType == ProviderType.STALKER_PORTAL &&- stalkerSection in setOf(ContentType.MOVIE, ContentType.SERIES)- ) {- val existing = stalkerIndexJobDao.get(providerId, section)- val mappedState = when (state) {- "QUEUED", "STALE" -> StalkerIndexState.QUEUED- "RUNNING" -> StalkerIndexState.RUNNING- "FAILED_RETRYABLE" -> StalkerIndexState.RETRY_WAIT- "PARTIAL" -> StalkerIndexState.PARTIAL- "SUCCESS", "COMPLETE" -> StalkerIndexState.COMPLETE- "TRUNCATED" -> StalkerIndexState.TRUNCATED- "FAILED_PERMANENT", "FAILED" -> StalkerIndexState.FAILED- "DISABLED", "IDLE" -> StalkerIndexState.DISABLED- else -> StalkerIndexState.PARTIAL- }- stalkerIndexJobDao.upsert(- (existing ?: StalkerIndexJobEntity(- providerId = providerId,- section = requireNotNull(stalkerSection)- )).copy(- state = mappedState,- totalCategories = totalCategories ?: existing?.totalCategories ?: 0,- completedCategories = completedCategories ?: existing?.completedCategories ?: 0,- nextCategoryIndex = nextCategoryIndex ?: existing?.nextCategoryIndex ?: 0,- failedCategories = failedCategories ?: existing?.failedCategories ?: 0,- indexedRows = indexedRows ?: existing?.indexedRows ?: 0,- skippedMalformedRows = skippedMalformedRows ?: existing?.skippedMalformedRows ?: 0,- deletedPrunedRows = deletedPrunedRows ?: existing?.deletedPrunedRows ?: 0,- lastError = lastError,- lastAttemptAt = lastAttemptAt ?: existing?.lastAttemptAt ?: 0L,- lastSuccessAt = lastSuccessAt ?: existing?.lastSuccessAt ?: 0L,- updatedAt = now- )- )- return- }- val existing = xtreamIndexJobDao.get(providerId, section)- xtreamIndexJobDao.upsert(- (existing ?: XtreamIndexJobEntity(providerId = providerId, section = section)).copy(- state = state,- totalCategories = totalCategories ?: existing?.totalCategories ?: 0,- completedCategories = completedCategories ?: existing?.completedCategories ?: 0,- nextCategoryIndex = nextCategoryIndex ?: existing?.nextCategoryIndex ?: 0,- failedCategories = failedCategories ?: existing?.failedCategories ?: 0,- indexedRows = indexedRows ?: existing?.indexedRows ?: 0,- skippedMalformedRows = skippedMalformedRows ?: existing?.skippedMalformedRows ?: 0,- deletedPrunedRows = deletedPrunedRows ?: existing?.deletedPrunedRows ?: 0,- priorityCategoryId = if (clearPriority) null else priorityCategoryId ?: existing?.priorityCategoryId,- priorityRequestedAt = if (clearPriority) 0L else priorityRequestedAt ?: existing?.priorityRequestedAt ?: 0L,- lastError = lastError,- lastAttemptAt = lastAttemptAt ?: existing?.lastAttemptAt ?: 0L,- lastSuccessAt = lastSuccessAt ?: existing?.lastSuccessAt ?: 0L,- updatedAt = now- )- )- }-- private suspend fun syncM3u(- provider: Provider,- force: Boolean,- onProgress: ((String) -> Unit)?,- afterCatalogApply: suspend () -> Unit = {}- ): SyncOutcome {- val warnings = mutableListOf<String>()- var metadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)- val now = System.currentTimeMillis()-- if (force || ContentCachePolicy.shouldRefresh(metadata.lastLiveSuccess, ContentCachePolicy.CATALOG_TTL_MILLIS, now)) {- val stats = withContext(Dispatchers.IO) {- m3uImporter.importPlaylist(provider, onProgress, afterCatalogApply = afterCatalogApply)- }- if (stats.liveCount == 0 && stats.movieCount == 0) {- throw IllegalStateException("Playlist is empty or contains no supported entries")- }- warnings += stats.warnings- val playlistEpgUrl = stats.header.tvgUrl- if (provider.epgUrl.isBlank() && !playlistEpgUrl.isNullOrBlank()) {- val existingSourcesByUrl = epgSourceRepository.getAllSources().first().associateBy { it.url }- val assignedSourceIds = epgSourceRepository.getAssignmentsForProvider(provider.id)- .first()- .mapTo(mutableSetOf()) { it.epgSourceId }- stats.header.tvgUrls.forEachIndexed { priority, url ->- try {- val source = existingSourcesByUrl[url] ?: when (- val addResult = epgSourceRepository.addSource("Playlist EPG ${priority + 1}", url)- ) {- is Result.Success -> addResult.data- is Result.Error -> {- warnings += "Could not add playlist EPG source ${priority + 1}: ${addResult.message}"- null- }- Result.Loading -> null- }- if (source != null && assignedSourceIds.add(source.id)) {- when (val assignment = epgSourceRepository.assignSourceToProvider(provider.id, source.id, priority)) {- is Result.Error -> warnings += "Could not assign playlist EPG source ${priority + 1}: ${assignment.message}"- else -> Unit- }- }- } catch (e: CancellationException) {- throw e- } catch (e: Exception) {- warnings += "Could not configure playlist EPG source ${priority + 1}: ${sanitizeThrowableMessage(e)}"- }- }- }- metadata = metadata.copy(- lastLiveSync = now,- lastLiveSuccess = now,- lastMovieSync = now,- lastSeriesSync = now,- lastSeriesSuccess = now,- lastMovieAttempt = now,- lastMovieSuccess = now,- liveCount = stats.liveCount,- movieCount = stats.movieCount,- movieSyncMode = VodSyncMode.FULL,- movieWarningsCount = stats.warnings.size,- movieCatalogStale = false,- movieHealthySyncStreak = 0- )- syncMetadataRepository.updateMetadata(metadata)- }-- if (shouldSyncEpgUpfront(provider)) {- updateXtreamEpgJobState(- provider = provider,- state = "RUNNING",- now = now,- lastAttemptAt = now,- lastError = null- )- val epgResult = syncM3uProviderEpg(- provider = provider,- metadata = metadata,- now = now,- force = force,- onProgress = onProgress- )- val finishedAt = System.currentTimeMillis()- updateXtreamEpgJobState(- provider = provider,- state = when {- epgResult.warnings.isEmpty() -> "SUCCESS"- epgResult.hasRetryableFailure -> "FAILED_RETRYABLE"- else -> "PARTIAL"- },- now = finishedAt,- indexedRows = programDao.countByProvider(provider.id),- lastAttemptAt = now,- lastSuccessAt = finishedAt.takeIf { epgResult.warnings.isEmpty() },- lastError = epgResult.warnings.takeIf { it.isNotEmpty() }?.joinToString("; ")- )- warnings += epgResult.warnings- } else if (provider.epgSyncMode != ProviderEpgSyncMode.SKIP) {- upsertXtreamIndexJob(- providerId = provider.id,- section = "EPG",- state = "QUEUED",- now = now,- totalCategories = 1,- completedCategories = 0,- nextCategoryIndex = 0,- failedCategories = 0,- lastAttemptAt = now,- lastError = null- )- scheduleBackgroundEpgSync(provider.id)- }-- return if (warnings.isEmpty()) SyncOutcome() else SyncOutcome(partial = true, warnings = warnings.distinct())- }-- private suspend fun queueStalkerIndexSection(- providerId: Long,- contentType: ContentType,- totalCategories: Int,- now: Long- ) {- require(contentType == ContentType.MOVIE || contentType == ContentType.SERIES) {- "Unsupported Stalker index section: $contentType"- }- when (contentType) {- ContentType.MOVIE -> movieCategoryHydrationDao.deleteByProvider(providerId)- ContentType.SERIES -> seriesCategoryHydrationDao.deleteByProvider(providerId)- else -> Unit- }- xtreamContentIndexDao.markRowsStaleForProviderAndType(providerId, contentType.name)- upsertXtreamIndexJob(- providerId = providerId,- section = contentType.name,- state = "QUEUED",- now = now,- totalCategories = totalCategories,- completedCategories = 0,- nextCategoryIndex = 0,- failedCategories = 0,- indexedRows = 0,- skippedMalformedRows = 0,- deletedPrunedRows = 0,- clearPriority = true,- lastAttemptAt = now,- lastError = null- )- }-- private suspend fun syncStalker(- provider: Provider,- force: Boolean,- onProgress: ((String) -> Unit)?,- afterCatalogApply: suspend () -> Unit = {},- deferProviderStateUntilCatalogCommit: Boolean = false- ): SyncOutcome {- val warnings = mutableListOf<String>()- stalkerReadinessTracker.start(provider.id)- UrlSecurityPolicy.validateStalkerPortalUrl(provider.serverUrl)?.let { message ->- throw IllegalStateException(message)- }- emitCatalogSyncProgress(provider.id, section = Section.LIVE)- progress(provider.id, onProgress, "Connecting to portal...")- val api = createStalkerSyncProvider(provider)- val authenticatedProvider = requireResult(api.authenticate(), "Failed to authenticate with portal")- val effectiveCatalogLayout = authenticatedProvider.catalogLayout- .takeUnless { it == com.streamvault.domain.model.CatalogLayout.UNKNOWN }- ?: provider.catalogLayout- val catalogLayoutChanged =- authenticatedProvider.catalogLayout != com.streamvault.domain.model.CatalogLayout.UNKNOWN &&- authenticatedProvider.catalogLayout != provider.catalogLayout- val catalogLayoutDetectionChanged =- catalogLayoutChanged ||- authenticatedProvider.catalogLayoutDetectionVersion != provider.catalogLayoutDetectionVersion- var catalogCommitCallback = afterCatalogApply- if (catalogLayoutDetectionChanged) {- suspend fun clearIncompatibleVodCatalog() {- if (catalogLayoutChanged) {- categoryDao.deleteByProviderAndType(provider.id, ContentType.MOVIE.name)- categoryDao.deleteByProviderAndType(provider.id, ContentType.SERIES.name)- categoryDao.deleteByProviderAndType(provider.id, ContentType.VOD.name)- movieCategoryHydrationDao.deleteByProvider(provider.id)- seriesCategoryHydrationDao.deleteByProvider(provider.id)- vodCategoryHydrationDao.deleteByProvider(provider.id)- vodCatalogEntryDao.deleteByProvider(provider.id)- }- }-- if (deferProviderStateUntilCatalogCommit) {- // A candidate edit must not rewrite the committed provider row or delete its- // existing VOD catalog before the first replacement catalog transaction has- // passed the revision commit gate. The callback executes inside that same Room- // transaction, so a superseded/cancelled candidate rolls everything back.- val originalCallback = catalogCommitCallback- catalogCommitCallback = {- originalCallback()- clearIncompatibleVodCatalog()- }- } else {- transactionRunner.inTransaction {- if (authenticatedProvider.catalogLayout != com.streamvault.domain.model.CatalogLayout.UNKNOWN) {- providerSnapshotRepository?.updateCatalogLayout(- provider.id,- authenticatedProvider.catalogLayout,- authenticatedProvider.catalogLayoutDetectionVersion- )- }- clearIncompatibleVodCatalog()- }- }- }- stalkerReadinessTracker.authenticated(provider.id)-- var metadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)- 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)) {- progress(provider.id, onProgress, "Downloading Live TV...")- val hiddenLiveCategoryIds = preferencesRepository.getHiddenCategoryIds(provider.id, ContentType.LIVE).first()- val liveCatalogResult = syncStalkerLiveCatalogStaged(- api,- provider,- hiddenLiveCategoryIds,- onProgress,- catalogCommitCallback- )- metadata = metadata.copy(- lastLiveSync = now,- lastLiveSuccess = now,- liveCount = liveCatalogResult.acceptedCount- )- liveCount = liveCatalogResult.acceptedCount- syncMetadataRepository.updateMetadata(metadata)- emitCatalogSyncProgress(provider.id,- section = Section.LIVE,- itemsIndexed = liveCatalogResult.acceptedCount- )- warnings += liveCatalogResult.warnings- }- // LIVE_READY is emitted only after either the refreshed catalog transaction has- // committed or the previously committed live cache was accepted as fresh.- stalkerReadinessTracker.liveReady(provider.id)-- if (force || catalogLayoutChanged || ContentCachePolicy.shouldRefresh(metadata.lastMovieSuccess, ContentCachePolicy.CATALOG_TTL_MILLIS, now)) {- progress(provider.id, onProgress, "Preparing Movies...")- val categories = when (val categoriesResult = if (effectiveCatalogLayout == CatalogLayout.UNIFIED_VOD) {- api.getUnifiedVodCategories()- } else {- 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(provider.id,- section = Section.VOD,- total = categories.size,- itemsIndexed = metadata.liveCount- )- // Stalker uses lazy-by-category VoD loading — only categories are persisted up- // front. Using replaceMovieCatalog with an empty sequence would run full stale- // deletion and destroy any movies already hydrated via on-demand category loads.- // replaceCategories updates/inserts category rows without touching movie rows.- val storedCategoryType = if (effectiveCatalogLayout == CatalogLayout.UNIFIED_VOD) ContentType.VOD else ContentType.MOVIE- syncCatalogStore.replaceCategories(- providerId = provider.id,- type = storedCategoryType.name,- categories = categories.mapIndexed { index, category ->- CategoryEntity(- providerId = provider.id,- categoryId = category.id,- name = category.name,- parentId = category.parentId,- type = storedCategoryType,- providerOrder = index,- isAdult = category.isAdult- )- }- )- if (effectiveCatalogLayout == CatalogLayout.SPLIT) {- // Raw VOD pages must be scanned again after a category refresh so derived- // Series can be restored after native-Series pruning.- movieCategoryHydrationDao.deleteByProvider(provider.id)- }- categoryDao.deleteByProviderAndType(- provider.id,- if (storedCategoryType == ContentType.VOD) ContentType.MOVIE.name else ContentType.VOD.name- )- movieCategoryCount = categories.size- if (effectiveCatalogLayout != CatalogLayout.UNIFIED_VOD && provider.stalkerCatalogMode == StalkerCatalogMode.BACKGROUND_INDEX) {- queueStalkerIndexSection(- providerId = provider.id,- contentType = ContentType.MOVIE,- totalCategories = categories.size,- now = now- )- }- metadata = metadata.copy(- lastMovieSync = now,- lastMovieAttempt = now,- movieCount = movieDao.getCount(provider.id).first(),- movieSyncMode = VodSyncMode.PAGED,- movieWarningsCount = 0,- movieCatalogStale = true- )- syncMetadataRepository.updateMetadata(metadata)- queuedMovieIndex = provider.stalkerCatalogMode == StalkerCatalogMode.BACKGROUND_INDEX- }-- if (effectiveCatalogLayout == CatalogLayout.UNIFIED_VOD) {- categoryDao.deleteByProviderAndType(provider.id, ContentType.SERIES.name)- seriesCategoryHydrationDao.deleteByProvider(provider.id)- } else if (force || catalogLayoutChanged || ContentCachePolicy.shouldRefresh(metadata.lastSeriesSuccess, ContentCachePolicy.CATALOG_TTL_MILLIS, now)) {- progress(provider.id, onProgress, "Preparing Series...")- 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(provider.id,- section = Section.SERIES,- total = categories.size,- itemsIndexed = metadata.liveCount- )- // Same rationale as movies: use replaceCategories to avoid destroying any- // already-hydrated series rows when running a category-only Stalker sync.- syncCatalogStore.replaceCategories(- providerId = provider.id,- type = "SERIES",- categories = categories.mapIndexed { index, category ->- CategoryEntity(- providerId = provider.id,- categoryId = category.id,- name = category.name,- parentId = category.parentId,- type = ContentType.SERIES,- providerOrder = index,- isAdult = category.isAdult- )- }- )- seriesCategoryCount = categories.size- if (provider.stalkerCatalogMode == StalkerCatalogMode.BACKGROUND_INDEX) {- queueStalkerIndexSection(- providerId = provider.id,- contentType = ContentType.SERIES,- totalCategories = categories.size,- now = now- )- }- metadata = metadata.copy(- lastSeriesSync = now,- seriesCount = seriesDao.getCount(provider.id).first()- )- syncMetadataRepository.updateMetadata(metadata)- queuedSeriesIndex = provider.stalkerCatalogMode == StalkerCatalogMode.BACKGROUND_INDEX- }-- 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)- }- }- // Both category shells are now committed (or their committed cache is still fresh).- stalkerReadinessTracker.categoriesReady(provider.id)-- when {- queuedMovieIndex && queuedSeriesIndex -> scheduleStalkerIndexSync(provider.id, force = force)- queuedMovieIndex -> scheduleStalkerIndexContinuation(provider, ContentType.MOVIE, force = force)- queuedSeriesIndex -> scheduleStalkerIndexContinuation(provider, ContentType.SERIES, force = force)- }-- when (provider.epgSyncMode) {- ProviderEpgSyncMode.UPFRONT -> {- val epgResult = syncStalkerProviderEpg(- provider = provider,- metadata = metadata,- now = now,- force = force,- onProgress = onProgress- )- warnings += epgResult.warnings- }- ProviderEpgSyncMode.BACKGROUND -> scheduleBackgroundEpgSync(provider.id)- ProviderEpgSyncMode.SKIP -> Unit- }-- stalkerReadinessTracker.ready(provider.id, warnings.size)-- return if (warnings.isEmpty()) SyncOutcome() else SyncOutcome(partial = true, warnings = warnings)- }-- private suspend fun syncJellyfin(- provider: Provider,- force: Boolean,- onProgress: ((String) -> Unit)?,- afterCatalogApply: suspend () -> Unit = {}- ): SyncOutcome {- val decryptedPassword = credentialCrypto.decryptIfNeeded(provider.password)- val decryptedProvider = provider.copy(password = decryptedPassword)- android.util.Log.d("JellyfinSync", "Starting Jellyfin sync for provider=${provider.id}")-- val restoredCheckpoint = if (force) null else loadJellyfinCheckpoint(provider.id)- val canResume = restoredCheckpoint != null &&- isJellyfinCheckpointConsistent(provider.id, restoredCheckpoint)- var checkpoint = if (canResume) {- requireNotNull(restoredCheckpoint)- } else {- withContext(NonCancellable) { syncCatalogStore.clearProviderStaging(provider.id) }- JellyfinCatalogCheckpoint(- movieSessionId = syncCatalogStore.newSessionId(),- seriesSessionId = syncCatalogStore.newSessionId(),- phase = JellyfinCatalogPhase.MOVIES- ).also { saveJellyfinCheckpoint(provider.id, it) }- }-- try {- if (checkpoint.phase == JellyfinCatalogPhase.MOVIES) {- progress(provider.id, onProgress, "Loading Jellyfin movies...")- do {- when (val result = jellyfinProvider.fetchMoviesPage(decryptedProvider, checkpoint.movieStartIndex)) {- is com.streamvault.domain.model.Result.Error -> throw result.exception ?: IllegalStateException(result.message)- is com.streamvault.domain.model.Result.Success -> {- val page = result.data- syncCatalogStore.stageMovieBatch(provider.id, checkpoint.movieSessionId, page.items)- checkpoint = checkpoint.afterMoviePage(- reportedTotal = page.totalRecordCount,- pageItemCount = page.items.size,- stagedCount = catalogSyncDao.countMovieStages(provider.id, checkpoint.movieSessionId)- )- saveJellyfinCheckpoint(provider.id, checkpoint)- }- is com.streamvault.domain.model.Result.Loading ->- throw JellyfinPaginationException("Jellyfin movie page did not complete")- }- } while (checkpoint.movieStartIndex < (checkpoint.movieTotal ?: 0))- checkpoint = checkpoint.copy(phase = JellyfinCatalogPhase.SERIES)- saveJellyfinCheckpoint(provider.id, checkpoint)- }-- if (checkpoint.phase == JellyfinCatalogPhase.SERIES) {- progress(provider.id, onProgress, "Loading Jellyfin series...")- do {- when (val result = jellyfinProvider.fetchSeriesPage(decryptedProvider, checkpoint.seriesStartIndex)) {- is com.streamvault.domain.model.Result.Error -> throw result.exception ?: IllegalStateException(result.message)- is com.streamvault.domain.model.Result.Success -> {- val page = result.data- syncCatalogStore.stageSeriesBatch(provider.id, checkpoint.seriesSessionId, page.items)- checkpoint = checkpoint.afterSeriesPage(- reportedTotal = page.totalRecordCount,- pageItemCount = page.items.size,- stagedCount = catalogSyncDao.countSeriesStages(provider.id, checkpoint.seriesSessionId)- )- saveJellyfinCheckpoint(provider.id, checkpoint)- }- is com.streamvault.domain.model.Result.Loading ->- throw JellyfinPaginationException("Jellyfin series page did not complete")- }- } while (checkpoint.seriesStartIndex < (checkpoint.seriesTotal ?: 0))- checkpoint = checkpoint.copy(phase = JellyfinCatalogPhase.READY)- saveJellyfinCheckpoint(provider.id, checkpoint)- }-- progress(provider.id, onProgress, "Importing Jellyfin library...")- syncCatalogStore.applyStagedJellyfinCatalog(- providerId = provider.id,- movieSessionId = checkpoint.movieSessionId,- seriesSessionId = checkpoint.seriesSessionId,- movieCategories = listOf(com.streamvault.data.local.entity.CategoryEntity(- providerId = provider.id,- categoryId = 1L,- name = "Movies",- type = com.streamvault.domain.model.ContentType.MOVIE- )),- seriesCategories = listOf(com.streamvault.data.local.entity.CategoryEntity(- providerId = provider.id,- categoryId = 2L,- name = "Series",- type = com.streamvault.domain.model.ContentType.SERIES- )),- afterCatalogApply = afterCatalogApply- )- saveJellyfinCheckpoint(provider.id, null)- return SyncOutcome()- } catch (cancelled: CancellationException) {- if (!hasDurableWorkflowContext(provider.id)) {- withContext(NonCancellable) { syncCatalogStore.clearProviderStaging(provider.id) }- }- throw cancelled- } catch (error: Exception) {- if (!isResumableJellyfinFailure(error) || !hasDurableWorkflowContext(provider.id)) {- withContext(NonCancellable) {- syncCatalogStore.clearProviderStaging(provider.id)- saveJellyfinCheckpoint(provider.id, null)- }- }- throw error- }- }-- private suspend fun loadJellyfinCheckpoint(providerId: Long): JellyfinCatalogCheckpoint? {- val lease = coroutineContext[ProviderWorkflowExecutionContext]?.lease ?: return null- if (lease.providerId != providerId) return null- return JellyfinCatalogCheckpoint.decode(- providerWorkflowDao?.getCheckpoint(providerId, lease.generation, lease.phase)- )- }-- private suspend fun saveJellyfinCheckpoint(providerId: Long, checkpoint: JellyfinCatalogCheckpoint?) {- val lease = coroutineContext[ProviderWorkflowExecutionContext]?.lease ?: return- if (lease.providerId != providerId) throw ProviderWorkflowSupersededException(providerId, lease.generation)- val workflowDao = providerWorkflowDao ?: return- if (workflowDao.updateRunningCheckpoint(- providerId = providerId,- generation = lease.generation,- phase = lease.phase,- token = lease.token,- checkpoint = checkpoint?.encode(),- now = System.currentTimeMillis()- ) != 1- ) {- throw ProviderWorkflowSupersededException(providerId, lease.generation)- }- }-- private suspend fun isJellyfinCheckpointConsistent(- providerId: Long,- checkpoint: JellyfinCatalogCheckpoint- ): Boolean {- val movieCount = catalogSyncDao.countMovieStages(providerId, checkpoint.movieSessionId)- val seriesCount = catalogSyncDao.countSeriesStages(providerId, checkpoint.seriesSessionId)- return checkpoint.isConsistent(movieCount, seriesCount)- }-- private suspend fun hasDurableWorkflowContext(providerId: Long): Boolean =- coroutineContext[ProviderWorkflowExecutionContext]?.lease?.providerId == providerId && providerWorkflowDao != null-- private fun isResumableJellyfinFailure(error: Exception): Boolean =- error is IOException &&- error !is JellyfinPaginationException &&- error !is JellyfinCatalogLimitException &&- error !is JellyfinResponseTooLargeException &&- error !is JellyfinItemLimitException-- /**- * Returns true for transient network/IO exceptions that are worth retrying via- * WorkManager backoff — as opposed to permanent failures (bad URL, auth, parse error)- * that will fail identically on every attempt.- */- private fun isRetryableEpgException(e: Exception): Boolean =- e is java.io.IOException ||- e is java.net.SocketTimeoutException ||- e is java.net.ConnectException ||- e is java.net.UnknownHostException ||- e.cause?.let {- it is java.io.IOException ||- it is java.net.SocketTimeoutException ||- it is java.net.ConnectException ||- it is java.net.UnknownHostException- } == true-- private suspend fun syncProviderEpg(- provider: Provider,- metadata: SyncMetadata,- now: Long,- force: Boolean,- onProgress: ((String) -> Unit)?,- syncNativeGuide: suspend (MutableList<String>) -> Boolean- ): ProviderGuideSyncResult {- val warnings = mutableListOf<String>()- var hasRetryableFailure = syncNativeGuide(warnings)- val hiddenLiveCategoryIds = preferencesRepository.getHiddenCategoryIds(provider.id, ContentType.LIVE).first()- val guidePolicy = provider.guideSourcePolicy-- if (shouldUseExternalGuide(guidePolicy)) {- try {- progress(provider.id, onProgress, "Refreshing external EPG sources...")- retryTransient {- requireResult(- epgSourceRepository.refreshAllForProvider(provider.id),- "External EPG source refresh failed"- )- }- progress(provider.id, onProgress, "Resolving EPG mappings...")- epgSourceRepository.resolveForProvider(provider.id, hiddenLiveCategoryIds)- } catch (e: CancellationException) {- throw e- } catch (e: Exception) {- Log.e(TAG, "External EPG resolution failed (non-fatal): ${sanitizeThrowableMessage(e)}")- if (isRetryableEpgException(e)) hasRetryableFailure = true- warnings.add("External EPG source refresh/resolution failed.")- }- } else if (guidePolicy == GuideSourcePolicy.DISABLED) {- progress(provider.id, onProgress, "Guide data disabled for this provider.")- epgSourceRepository.resolveForProvider(provider.id, hiddenLiveCategoryIds)- } else {- progress(provider.id, onProgress, "Resolving provider EPG mappings...")- epgSourceRepository.resolveForProvider(provider.id, hiddenLiveCategoryIds)- }-- return ProviderGuideSyncResult(warnings = warnings, hasRetryableFailure = hasRetryableFailure)- }-- private suspend fun syncXtreamProviderEpg(- provider: Provider,- metadata: SyncMetadata,- now: Long,- force: Boolean,- onProgress: ((String) -> Unit)?- ): ProviderGuideSyncResult = syncProviderEpg(provider, metadata, now, force, onProgress) { warnings ->- var retryable = false- if (shouldUseProviderGuide(provider.guideSourcePolicy) &&- (force || ContentCachePolicy.shouldRefresh(metadata.lastEpgSuccess, ContentCachePolicy.EPG_TTL_MILLIS, now))- ) {- try {- progress(provider.id, onProgress, "Downloading EPG...")- val base = provider.serverUrl.trimEnd('/')- val xmltvUrl = provider.epgUrl.ifBlank {- XtreamUrlFactory.buildXmltvUrl(base, provider.username, provider.password)- }- UrlSecurityPolicy.validateXtreamEpgUrl(xmltvUrl)?.let { throw IllegalStateException(it) }- retryTransient {- requireResult(epgRepository.refreshEpg(provider.id, xmltvUrl), "Failed to refresh EPG")- }- val epgCount = programDao.countByProvider(provider.id)- syncMetadataRepository.updateMetadata(- metadata.copy(lastEpgSync = now, lastEpgSuccess = now, epgCount = epgCount)- )- if (epgCount == 0) warnings += "EPG imported zero programs; live guide may require provider fallback."- } catch (e: CancellationException) {- throw e- } catch (e: Exception) {- Log.e(TAG, "EPG sync failed (non-fatal): ${sanitizeThrowableMessage(e)}")- retryable = isRetryableEpgException(e)- warnings += "EPG XMLTV sync failed."- }- }- retryable- }-- private suspend fun syncM3uProviderEpg(- provider: Provider,- metadata: SyncMetadata,- now: Long,- force: Boolean,- onProgress: ((String) -> Unit)?- ): ProviderGuideSyncResult = syncProviderEpg(provider, metadata, now, force, onProgress) { warnings ->- var retryable = false- val epgUrl = provider.epgUrl- if (shouldUseProviderGuide(provider.guideSourcePolicy) && epgUrl.isNotBlank() &&- (force || ContentCachePolicy.shouldRefresh(metadata.lastEpgSuccess, ContentCachePolicy.EPG_TTL_MILLIS, now))- ) {- val validationError = UrlSecurityPolicy.validateOptionalEpgUrl(epgUrl)- if (validationError != null) {- warnings += validationError- } else {- try {- progress(provider.id, onProgress, "Downloading EPG...")- retryTransient {- requireResult(epgRepository.refreshEpg(provider.id, epgUrl), "Failed to refresh EPG")- }- syncMetadataRepository.updateMetadata(- metadata.copy(- lastEpgSync = now,- lastEpgSuccess = now,- epgCount = programDao.countByProvider(provider.id)- )- )- } catch (e: CancellationException) {- throw e- } catch (e: Exception) {- Log.e(TAG, "EPG sync failed (non-fatal): ${sanitizeThrowableMessage(e)}")- retryable = isRetryableEpgException(e)- warnings += "EPG sync failed"- }- }- }- retryable- }-- private suspend fun syncStalkerProviderEpg(- provider: Provider,- metadata: SyncMetadata,- now: Long,- force: Boolean,- onProgress: ((String) -> Unit)?- ): ProviderGuideSyncResult = syncProviderEpg(provider, metadata, now, force, onProgress) { warnings ->- var retryable = false- if (shouldUseProviderGuide(provider.guideSourcePolicy) &&- (force || ContentCachePolicy.shouldRefresh(metadata.lastEpgSuccess, ContentCachePolicy.EPG_TTL_MILLIS, now))- ) {- val learnedEpgSupport = stalkerPortalStateStore.getValidated(provider.id)?.epgSupported- if (learnedEpgSupport == false && provider.epgUrl.isBlank()) {- StalkerTelemetry.strategySelected(provider.id, "EPG_SKIP", "EPG_KNOWN_UNSUPPORTED")- warnings += "Stalker portal guide is known to be unsupported; keeping cached guide data."- } else {- val stalkerWarnings = syncStalkerPreferredEpg(provider, now, onProgress)- retryable = stalkerWarnings.isNotEmpty()- warnings += stalkerWarnings- }- }- retryable- }-- private suspend fun syncJellyfinProviderEpg(- provider: Provider,- metadata: SyncMetadata,- now: Long,- force: Boolean,- onProgress: ((String) -> Unit)?- ): ProviderGuideSyncResult = syncProviderEpg(provider, metadata, now, force, onProgress) { false }-- private suspend fun syncXtreamEpgOnly(- provider: Provider,- onProgress: ((String) -> Unit)?- ) = syncXmlTvEpgOnly(- provider = provider,- epgUrl = provider.epgUrl.ifBlank {- XtreamUrlFactory.buildXmltvUrl(- provider.serverUrl.trimEnd('/'),- provider.username,- provider.password- )- },- validateUrl = UrlSecurityPolicy::validateXtreamEpgUrl,- onProgress = onProgress- )-- private suspend fun syncM3uEpgOnly(- provider: Provider,- onProgress: ((String) -> Unit)?- ) = syncXmlTvEpgOnly(- provider = provider,- epgUrl = provider.epgUrl,- validateUrl = UrlSecurityPolicy::validateOptionalEpgUrl,- onProgress = onProgress- )-- private suspend fun syncXmlTvEpgOnly(- provider: Provider,- epgUrl: String,- validateUrl: (String) -> String?,- onProgress: ((String) -> Unit)?- ) {- progress(provider.id, onProgress, "Retrying EPG...")- val hiddenLiveCategoryIds = preferencesRepository.getHiddenCategoryIds(provider.id, ContentType.LIVE).first()- val guidePolicy = provider.guideSourcePolicy- if (guidePolicy == GuideSourcePolicy.DISABLED) {- progress(provider.id, onProgress, "Guide data disabled for this provider.")- epgSourceRepository.resolveForProvider(provider.id, hiddenLiveCategoryIds)- return- }- if (!shouldUseProviderGuide(guidePolicy)) {- if (shouldUseExternalGuide(guidePolicy)) {- progress(provider.id, onProgress, "Refreshing external EPG sources...")- retryTransient {- requireResult(- epgSourceRepository.refreshAllForProvider(provider.id),- "External EPG source refresh failed"- )- }- progress(provider.id, onProgress, "Resolving EPG mappings...")- epgSourceRepository.resolveForProvider(provider.id, hiddenLiveCategoryIds)- }- return- }- if (epgUrl.isBlank()) {- throw IllegalStateException("No EPG URL configured for this provider")- }- validateUrl(epgUrl)?.let { message ->- throw IllegalStateException(message)- }- retryTransient {- requireResult(epgRepository.refreshEpg(provider.id, epgUrl), "Failed to refresh EPG")- }- val now = System.currentTimeMillis()- val metadata = (syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id))- .copy(- lastEpgSync = now,- lastEpgSuccess = now,- epgCount = programDao.countByProvider(provider.id)- )- syncMetadataRepository.updateMetadata(metadata)-- // Also refresh external sources and run resolution- if (shouldUseExternalGuide(guidePolicy)) {- progress(provider.id, onProgress, "Refreshing external EPG sources...")- retryTransient {- requireResult(- epgSourceRepository.refreshAllForProvider(provider.id),- "External EPG source refresh failed"- )- }- progress(provider.id, onProgress, "Resolving EPG mappings...")- epgSourceRepository.resolveForProvider(provider.id, hiddenLiveCategoryIds)- } else {- progress(provider.id, onProgress, "Resolving provider EPG mappings...")- epgSourceRepository.resolveForProvider(provider.id, hiddenLiveCategoryIds)- }- }-- private suspend fun syncStalkerEpgOnly(- provider: Provider,- onProgress: ((String) -> Unit)?- ) {- progress(provider.id, onProgress, "Retrying EPG...")- val hiddenLiveCategoryIds = preferencesRepository.getHiddenCategoryIds(provider.id, ContentType.LIVE).first()- val guidePolicy = provider.guideSourcePolicy- if (guidePolicy == GuideSourcePolicy.DISABLED) {- progress(provider.id, onProgress, "Guide data disabled for this provider.")- epgSourceRepository.resolveForProvider(provider.id, hiddenLiveCategoryIds)- return- }- if (shouldUseProviderGuide(guidePolicy)) {- syncStalkerPreferredEpg(provider, System.currentTimeMillis(), onProgress)- }- if (shouldUseExternalGuide(guidePolicy)) {- progress(provider.id, onProgress, "Refreshing external EPG sources...")- retryTransient {- requireResult(- epgSourceRepository.refreshAllForProvider(provider.id),- "External EPG source refresh failed"- )- }- progress(provider.id, onProgress, "Resolving EPG mappings...")- epgSourceRepository.resolveForProvider(provider.id, hiddenLiveCategoryIds)- } else {- progress(provider.id, onProgress, "Resolving provider EPG mappings...")- epgSourceRepository.resolveForProvider(provider.id, hiddenLiveCategoryIds)- }- }-- private suspend fun syncStalkerPreferredEpg(- provider: Provider,- now: Long,- onProgress: ((String) -> Unit)?- ): List<String> {- val warnings = mutableListOf<String>()- val currentEpgUrl = provider.epgUrl- var shouldUseNativeGuide = currentEpgUrl.isBlank()-- if (currentEpgUrl.isNotBlank()) {- val epgValidationError = UrlSecurityPolicy.validateOptionalEpgUrl(currentEpgUrl)- if (epgValidationError != null) {- Log.w(TAG, "Portal XMLTV URL invalid for provider ${provider.id}: $epgValidationError")- warnings.add("Portal XMLTV URL is invalid; using the Stalker portal guide instead.")- shouldUseNativeGuide = true- } else {- try {- progress(provider.id, onProgress, "Downloading EPG...")- retryTransient {- requireResult(epgRepository.refreshEpg(provider.id, currentEpgUrl), "Failed to refresh EPG")- }- val epgCount = programDao.countByProvider(provider.id)- if (epgCount > 0) {- syncMetadataRepository.updateMetadata(- (syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)).copy(- lastEpgSync = now,- lastEpgSuccess = now,- epgCount = epgCount- )- )- } else {- warnings.add("Portal XMLTV imported zero programs; using the Stalker portal guide instead.")- shouldUseNativeGuide = true- }- } catch (e: CancellationException) {- throw e- } catch (e: Exception) {- Log.e(TAG, "Portal XMLTV sync failed for provider ${provider.id}: ${sanitizeThrowableMessage(e)}")- warnings.add("Portal XMLTV sync failed; using the Stalker portal guide instead.")- shouldUseNativeGuide = true- }- }- }-- if (shouldUseNativeGuide) {- warnings += syncStalkerPortalEpg(- provider = provider,- now = now,- onProgress = onProgress- )- }-- return warnings- }-- private suspend fun syncStalkerPortalEpg(- provider: Provider,- now: Long,- onProgress: ((String) -> Unit)?- ): List<String> {- val channels = channelDao.getGuideSyncEntriesByProvider(provider.id)- if (channels.isEmpty()) {- return emptyList()- }-- val guideRequests = channels- .mapNotNull(::toStalkerGuideRequest)- .distinctBy(StalkerGuideRequest::channelKey)- if (guideRequests.isEmpty()) {- return listOf("Stalker portal guide sync skipped because no valid guide channel IDs were available.")- }-- val previousProgramCount = programDao.countByProvider(provider.id)- val api = createStalkerSyncProvider(provider)- val aliasToChannelKey = buildMap {- guideRequests.forEach { request ->- request.aliases.forEach { alias -> putIfAbsent(alias, request.channelKey) }- }- }- val failedChannels = mutableListOf<String>()- val insertBuffer = ArrayList<com.streamvault.data.local.entity.ProgramEntity>(STALKER_GUIDE_PROGRAM_BATCH_SIZE)- val replacedChannelKeys = linkedSetOf<String>()- val bulkCoveredChannelKeys = linkedSetOf<String>()- var importedProgramCount = 0- var providerRateLimited = false-- suspend fun flushPrograms() {- if (insertBuffer.isEmpty()) return- val chunk = insertBuffer.toList()- insertBuffer.clear()- transactionRunner.inTransaction {- chunk- .map { it.channelId }- .distinct()- .forEach { channelId ->- if (replacedChannelKeys.add(channelId)) {- programDao.deleteForChannel(provider.id, channelId)- }- }- if (chunk.isNotEmpty()) {- programDao.insertAll(chunk)- importedProgramCount += chunk.size- }- }- }-- runSuspendCatching {- // Stream the bulk EPG payload program-by-program; the previous buffered API- // could materialise >30 MB JSON trees on certain Stalker portals which led to- // OOM crashes when re-entering content screens.- stalkerRequestCoordinator.execute(- providerId = provider.id,- priority = StalkerRequestPriority.EPG,- descriptor = StalkerRequestDescriptor(- contentType = "EPG",- action = "BULK_GUIDE"- )- ) {- api.streamBulkEpg(periodHours = 6) { program ->- val resolvedChannelKey = aliasToChannelKey[program.channelId] ?: return@streamBulkEpg- if (program.endTime <= program.startTime) return@streamBulkEpg- bulkCoveredChannelKeys += resolvedChannelKey- insertBuffer += program.copy(- providerId = provider.id,- channelId = resolvedChannelKey- ).toEntity()- if (insertBuffer.size >= STALKER_GUIDE_PROGRAM_BATCH_SIZE) {- flushPrograms()- }- }- }.let { result ->- if (result is com.streamvault.domain.model.Result.Error) {- throw result.exception ?: IllegalStateException(result.message)- }- }- }.onFailure { error ->- providerRateLimited = error.hasStalkerRateLimit()- Log.d(TAG, "Bulk Stalker portal EPG fetch unavailable for provider ${provider.id}", error)- }-- val uncoveredGuideRequests = guideRequests.filterNot { request -> request.channelKey in bulkCoveredChannelKeys }- val perChannelGuideWindowed = uncoveredGuideRequests.size > STALKER_PER_CHANNEL_EPG_REQUESTS_PER_RUN- val fallbackGuideRequests = if (providerRateLimited) {- emptyList()- } else if (perChannelGuideWindowed) {- val windowCount = (uncoveredGuideRequests.size + STALKER_PER_CHANNEL_EPG_REQUESTS_PER_RUN - 1) /- STALKER_PER_CHANNEL_EPG_REQUESTS_PER_RUN- val windowIndex = ((now / MILLIS_PER_DAY) % windowCount).toInt()- uncoveredGuideRequests- .drop(windowIndex * STALKER_PER_CHANNEL_EPG_REQUESTS_PER_RUN)- .take(STALKER_PER_CHANNEL_EPG_REQUESTS_PER_RUN)- } else {- uncoveredGuideRequests- }-- // Some portals ignore `ch_id` and return the entire bulk EPG for every per-channel- // request. After the first per-channel call we sample the response shape; if it- // looks like the portal is repeatedly emitting the bulk payload we abort the- // per-channel loop to avoid downloading the same multi-megabyte payload N times.- var ignorePerChannelGuide = false-- fallbackGuideRequests.forEachIndexed { index, request ->- if (ignorePerChannelGuide) return@forEachIndexed- progress(provider.id, onProgress, "Downloading portal EPG... ${index + 1} of ${fallbackGuideRequests.size}")- runSuspendCatching {- var perChannelRecordCount = 0- val foreignChannelIds = HashSet<String>()- val streamResult = stalkerRequestCoordinator.execute(- providerId = provider.id,- priority = StalkerRequestPriority.EPG,- descriptor = StalkerRequestDescriptor(- contentType = "EPG",- action = "CHANNEL_GUIDE",- itemKey = request.channelKey- )- ) {- api.streamEpg(request.channelKey) { program ->- if (program.endTime <= program.startTime) return@streamEpg- if (program.channelId != request.channelKey) {- foreignChannelIds += program.channelId- }- insertBuffer += program.copy(- providerId = provider.id,- channelId = request.channelKey- ).toEntity()- perChannelRecordCount++- if (perChannelRecordCount >= STALKER_PER_CHANNEL_RECORD_SANITY_CAP || foreignChannelIds.size > 1) {- // Bail out of this single response — the portal is clearly returning- // the bulk payload again. The outer loop will then disable any- // remaining per-channel calls.- throw StalkerBrokenPerChannelEpgException(request.channelName)- }- if (insertBuffer.size >= STALKER_GUIDE_PROGRAM_BATCH_SIZE) {- flushPrograms()- }- }- }- if (streamResult is com.streamvault.domain.model.Result.Error) {- throw streamResult.exception ?: IllegalStateException(streamResult.message)- }- }.onFailure { error ->- if (error.hasStalkerRateLimit()) {- providerRateLimited = true- ignorePerChannelGuide = true- Log.w(- TAG,- "Stalker provider ${provider.id} entered rate-limit cooldown; cancelling remaining per-channel EPG requests."- )- } else if (error is StalkerBrokenPerChannelEpgException) {- ignorePerChannelGuide = true- Log.w(- TAG,- "Stalker portal returned bulk-shaped payload for per-channel EPG request " +- "(${request.channelKey}); skipping remaining per-channel guide calls."- )- } else {- failedChannels += request.channelName- Log.w(- TAG,- "Stalker portal EPG fetch failed for provider ${provider.id} channel ${request.channelKey}",- error- )- }- }- }-- flushPrograms()-- if (replacedChannelKeys.isEmpty() && failedChannels.isNotEmpty()) {- api.recordEpgCapability(supported = false)- return listOf(- "Stalker portal guide sync failed for all ${failedChannels.size} channels; keeping existing guide data."- )- }-- val epgCount = programDao.countByProvider(provider.id)- if (replacedChannelKeys.isNotEmpty() || bulkCoveredChannelKeys.isNotEmpty()) {- api.recordEpgCapability(supported = true)- }- val guideLooksHealthy = epgCount >= STALKER_MIN_HEALTHY_EPG_PROGRAMS || previousProgramCount == 0- val existingMetadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)- syncMetadataRepository.updateMetadata(- existingMetadata.copy(- lastEpgSync = now,- lastEpgSuccess = if (guideLooksHealthy) now else existingMetadata.lastEpgSuccess,- epgCount = epgCount- )- )-- val warnings = mutableListOf<String>()- if (providerRateLimited) {- warnings.add("Stalker portal rate limit reached; remaining guide requests were cancelled.")- }- if (perChannelGuideWindowed) {- warnings.add(- "Portal EPG fallback was limited to $STALKER_PER_CHANNEL_EPG_REQUESTS_PER_RUN channels this run; " +- "later background runs rotate through the remaining channels."- )- }- if (epgCount == 0) {- warnings.add("Stalker portal guide import returned zero programs.")- }- if (failedChannels.isNotEmpty()) {- warnings.add(- "Stalker portal guide imported $epgCount programs, but ${failedChannels.size} channels failed (${summarizeChannelNames(failedChannels)})."- )- }- if (!guideLooksHealthy && previousProgramCount >= STALKER_MIN_HEALTHY_EPG_PROGRAMS) {- warnings.add(- "Stalker portal guide import looked incomplete ($importedProgramCount programs across ${replacedChannelKeys.size} channels); preserved untouched prior guide data for the rest."- )- }- return warnings- }-- private data class StalkerGuideRequest(- val channelKey: String,- val channelName: String,- val aliases: Set<String>- )-- private fun toStalkerGuideRequest(channel: ChannelGuideSyncEntity): StalkerGuideRequest? {- val normalizedEpgKey = channel.epgChannelId- ?.trim()- ?.takeIf { it.isNotEmpty() }- ?.takeUnless(::isLikelyPlaceholderStalkerGuideKey)- val streamKey = channel.streamId.takeIf { it > 0L }?.toString()- val channelKey = normalizedEpgKey ?: streamKey ?: return null- val aliases = linkedSetOf<String>().apply {- normalizedEpgKey?.let(::add)- streamKey?.let(::add)- }- return StalkerGuideRequest(- channelKey = channelKey,- channelName = channel.name.ifBlank { channelKey },- aliases = aliases+ seriesIds: List<Long>+ ): Map<Long, SeriesEntity> {+ return chunkedLookupById(+ ids = seriesIds,+ chunkSize = XTREAM_SQLITE_LOOKUP_CHUNK_SIZE,+ fetch = { chunk -> seriesDao.getBySeriesIds(providerId, chunk) },+ keySelector = SeriesEntity::seriesId)}- private fun isLikelyPlaceholderStalkerGuideKey(value: String): Boolean {- return when (value.trim().lowercase()) {- "no details available",- "n/a",- "null",- "none",- "unknown" -> true- else -> false- }- }-- private fun summarizeChannelNames(channelNames: List<String>): String {- val distinctNames = channelNames.distinct()- if (distinctNames.isEmpty()) {- return "unknown channels"- }- val preview = distinctNames.take(3).joinToString()- val remaining = distinctNames.size - 3- return if (remaining > 0) {- "$preview, and $remaining more"- } else {- preview- }- }-- private suspend fun syncXtreamLiveOnly(- provider: Provider,- syncReason: XtreamLiveSyncReason,- onProgress: ((String) -> Unit)?- ): SyncOutcome {- val now = System.currentTimeMillis()- val sectionWarnings = mutableListOf<String>()- progress(provider.id, onProgress, "Retrying Live TV...")- val useTextClassification = preferencesRepository.useXtreamTextClassification.first()- val enableBase64TextCompatibility = preferencesRepository.xtreamBase64TextCompatibility.first()- val hiddenLiveCategoryIds = preferencesRepository.getHiddenCategoryIds(provider.id, ContentType.LIVE).first()- val api = createXtreamSyncProvider(provider, useTextClassification, enableBase64TextCompatibility)- val currentMetadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)- val runtimeProfile = CatalogSyncRuntimeProfile.from(applicationContext)- val liveSyncResult = syncXtreamLiveCatalog(- provider = provider,- api = api,- existingMetadata = currentMetadata,- hiddenLiveCategoryIds = hiddenLiveCategoryIds,- onProgress = onProgress,- runtimeProfile = runtimeProfile,- trackInitialLiveOnboarding = false,- syncReason = syncReason- )- val liveSequentialStress = liveSyncResult.strategyFeedback.segmentedStressDetected- val liveProviderAdaptation = updateSequentialProviderAdaptation(- previousRemembered = currentMetadata.liveSequentialFailuresRemembered,- previousHealthyStreak = currentMetadata.liveHealthySyncStreak,- sawSequentialStress = liveSequentialStress- )- val liveAvoidFullUntil = updateAvoidFullUntil(- previousAvoidFullUntil = currentMetadata.liveAvoidFullUntil,- now = now,- feedback = liveSyncResult.strategyFeedback- )-- when (val liveResult = liveSyncResult.catalogResult) {- is CatalogStrategyResult.Success -> {- val acceptedCount = finalizeXtreamLiveCatalog(- providerId = provider.id,- liveSyncResult = liveSyncResult,- hiddenLiveCategoryIds = hiddenLiveCategoryIds,- onProgress = onProgress- ).acceptedCount- syncMetadataRepository.updateMetadata(- currentMetadata.copy(- lastLiveSync = now,- lastLiveSuccess = now,- liveCount = acceptedCount,- liveAvoidFullUntil = liveAvoidFullUntil,- liveSequentialFailuresRemembered = liveProviderAdaptation.rememberSequential,- liveHealthySyncStreak = liveProviderAdaptation.healthyStreak- )- )- }- is CatalogStrategyResult.Partial -> {- val commitResult = finalizeXtreamLiveCatalog(- providerId = provider.id,- liveSyncResult = liveSyncResult,- hiddenLiveCategoryIds = hiddenLiveCategoryIds,- onProgress = onProgress,- partialCompletionWarning = "Live TV retry completed partially."- )- val acceptedCount = commitResult.acceptedCount- syncMetadataRepository.updateMetadata(- currentMetadata.copy(- lastLiveSync = now,- liveCount = acceptedCount,- liveAvoidFullUntil = liveAvoidFullUntil,- liveSequentialFailuresRemembered = currentMetadata.liveSequentialFailuresRemembered || liveSequentialStress,- liveHealthySyncStreak = 0- )- )- sectionWarnings += commitResult.warnings- }- is CatalogStrategyResult.EmptyValid -> {- val existingLiveCount = channelDao.getCount(provider.id).first()- syncMetadataRepository.updateMetadata(- currentMetadata.copy(- liveAvoidFullUntil = liveAvoidFullUntil,- liveSequentialFailuresRemembered = currentMetadata.liveSequentialFailuresRemembered || liveSequentialStress,- liveHealthySyncStreak = 0- )- )- throw IllegalStateException(- if (existingLiveCount > 0) {- "Live TV refresh returned an empty catalog; existing library was preserved."- } else {- "Live TV catalog was empty."- }- )- }- is CatalogStrategyResult.Failure -> {- syncMetadataRepository.updateMetadata(- currentMetadata.copy(- liveAvoidFullUntil = liveAvoidFullUntil,- liveSequentialFailuresRemembered = currentMetadata.liveSequentialFailuresRemembered || liveSequentialStress || shouldRememberSequentialPreference(liveResult.error),- liveHealthySyncStreak = 0- )- )- throw IllegalStateException(- syncErrorSanitizer.userMessage(liveResult.error, "Failed to fetch live channels"),- liveResult.error- )- }- }- return if (sectionWarnings.isEmpty()) SyncOutcome() else SyncOutcome(partial = true, warnings = sectionWarnings)- }-- private suspend fun syncM3uLiveOnly(- provider: Provider,- onProgress: ((String) -> Unit)?- ): SyncOutcome {- val now = System.currentTimeMillis()- progress(provider.id, onProgress, "Retrying Live TV...")- val stats = withContext(Dispatchers.IO) {- m3uImporter.importPlaylist(provider, onProgress, includeLive = true, includeMovies = false)- }- if (stats.liveCount == 0) {- throw IllegalStateException("Playlist contains no live TV entries")- }- val metadata = (syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id))- .copy(- lastLiveSync = now,- lastLiveSuccess = now,- liveCount = stats.liveCount- )- syncMetadataRepository.updateMetadata(metadata)- return SyncOutcome()- }-- private suspend fun syncStalkerLiveOnly(- provider: Provider,- onProgress: ((String) -> Unit)?- ): SyncOutcome {- val now = System.currentTimeMillis()- val sectionWarnings = mutableListOf<String>()- emitCatalogSyncProgress(provider.id, section = Section.LIVE)- progress(provider.id, onProgress, "Retrying Live TV...")- val api = createStalkerSyncProvider(provider)- val hiddenLiveCategoryIds = preferencesRepository.getHiddenCategoryIds(provider.id, ContentType.LIVE).first()- val liveCatalogResult = syncStalkerLiveCatalogStaged(api, provider, hiddenLiveCategoryIds, onProgress)- val metadata = (syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id))- .copy(- lastLiveSync = now,- lastLiveSuccess = now,- liveCount = liveCatalogResult.acceptedCount- )- syncMetadataRepository.updateMetadata(metadata)- emitCatalogSyncProgress(provider.id,- section = Section.LIVE,- itemsIndexed = liveCatalogResult.acceptedCount- )- sectionWarnings += liveCatalogResult.warnings- return if (sectionWarnings.isEmpty()) SyncOutcome() else SyncOutcome(partial = true, warnings = sectionWarnings)- }-- private suspend fun syncXtreamMoviesOnly(- provider: Provider,- onProgress: ((String) -> Unit)?- ): SyncOutcome {- val now = System.currentTimeMillis()- progress(provider.id, onProgress, "Queueing Movies index...")- val useTextClassification = preferencesRepository.useXtreamTextClassification.first()- val enableBase64TextCompatibility = preferencesRepository.xtreamBase64TextCompatibility.first()- val api = createXtreamSyncProvider(provider, useTextClassification, enableBase64TextCompatibility)- val currentMetadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)- val categoryCount = syncXtreamCategoryShell(- provider = provider,- api = api,- contentType = ContentType.MOVIE,- label = "Movies",- now = now,- onProgress = onProgress- ).getOrElse { error ->- upsertXtreamIndexJob(- providerId = provider.id,- section = ContentType.MOVIE.name,- state = xtreamIndexFailureState(error),- now = now,- lastAttemptAt = now,- lastError = sanitizeThrowableMessage(error)- )- throw IllegalStateException(- syncErrorSanitizer.userMessage(error, "Failed to queue movie index"),- error- )- }- syncMetadataRepository.updateMetadata(- currentMetadata.copy(- lastMovieAttempt = now,- movieCatalogStale = true,- movieSyncMode = VodSyncMode.UNKNOWN- )- )- scheduleXtreamIndexSync(provider.id, ContentType.MOVIE)- Log.i(TAG, "Queued Xtream movie index for provider ${provider.id}: $categoryCount categories.")- return SyncOutcome()+ private fun mergeMovieSummary(existing: MovieEntity?, summary: MovieEntity): MovieEntity {+ if (existing == null) return summary+ val preserveDetails = existing.cacheState == "DETAIL_HYDRATED" && existing.detailHydratedAt > 0L+ return summary.copy(+ id = existing.id,+ posterUrl = summary.posterUrl ?: existing.posterUrl,+ backdropUrl = if (preserveDetails) existing.backdropUrl else summary.backdropUrl,+ plot = if (preserveDetails) existing.plot else summary.plot,+ cast = if (preserveDetails) existing.cast else summary.cast,+ director = if (preserveDetails) existing.director else summary.director,+ genre = summary.genre ?: existing.genre,+ releaseDate = if (preserveDetails) existing.releaseDate else summary.releaseDate,+ duration = if (preserveDetails) existing.duration else summary.duration,+ durationSeconds = if (preserveDetails) existing.durationSeconds else summary.durationSeconds,+ year = if (preserveDetails) existing.year else summary.year,+ tmdbId = summary.tmdbId ?: existing.tmdbId,+ youtubeTrailer = summary.youtubeTrailer ?: existing.youtubeTrailer,+ watchProgress = existing.watchProgress,+ watchCount = existing.watchCount,+ lastWatchedAt = existing.lastWatchedAt,+ isUserProtected = existing.isUserProtected,+ cacheState = if (preserveDetails) existing.cacheState else "SUMMARY_ONLY",+ detailHydratedAt = if (preserveDetails) existing.detailHydratedAt else 0L,+ remoteStaleAt = 0L+ )}- private suspend fun syncM3uMoviesOnly(- provider: Provider,- onProgress: ((String) -> Unit)?- ): SyncOutcome {- val now = System.currentTimeMillis()- progress(provider.id, onProgress, "Retrying Movies...")- val stats = withContext(Dispatchers.IO) {- m3uImporter.importPlaylist(provider, onProgress, includeLive = false, includeMovies = true)- }- if (stats.movieCount == 0) {- throw IllegalStateException("Playlist contains no movie entries")- }- val metadata = (syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id))- .copy(- lastMovieSync = now,- lastMovieAttempt = now,- lastMovieSuccess = now,- movieCount = stats.movieCount,- movieSyncMode = VodSyncMode.FULL,- movieWarningsCount = stats.warnings.size,- movieCatalogStale = false- )- syncMetadataRepository.updateMetadata(metadata)- return SyncOutcome()+ private fun mergeSeriesSummary(existing: SeriesEntity?, summary: SeriesEntity): SeriesEntity {+ if (existing == null) return summary+ val preserveDetails = existing.cacheState == "DETAIL_HYDRATED" && existing.detailHydratedAt > 0L+ return summary.copy(+ id = existing.id,+ providerSeriesId = summary.providerSeriesId ?: existing.providerSeriesId,+ posterUrl = summary.posterUrl ?: existing.posterUrl,+ backdropUrl = if (preserveDetails) existing.backdropUrl else summary.backdropUrl,+ plot = if (preserveDetails) existing.plot else summary.plot,+ cast = if (preserveDetails) existing.cast else summary.cast,+ director = if (preserveDetails) existing.director else summary.director,+ genre = summary.genre ?: existing.genre,+ releaseDate = if (preserveDetails) existing.releaseDate else summary.releaseDate,+ tmdbId = summary.tmdbId ?: existing.tmdbId,+ youtubeTrailer = summary.youtubeTrailer ?: existing.youtubeTrailer,+ episodeRunTime = if (preserveDetails) existing.episodeRunTime else summary.episodeRunTime,+ isUserProtected = existing.isUserProtected,+ cacheState = if (preserveDetails) existing.cacheState else "SUMMARY_ONLY",+ detailHydratedAt = if (preserveDetails) existing.detailHydratedAt else 0L,+ remoteStaleAt = 0L+ )}- private suspend fun syncStalkerMoviesOnly(- provider: Provider,- onProgress: ((String) -> Unit)?- ): SyncOutcome {- val now = System.currentTimeMillis()- progress(provider.id, onProgress, "Queueing Movies index...")- val api = createStalkerSyncProvider(provider)- val categories = requireResult(api.getVodCategories(), "Failed to load movie categories")- emitCatalogSyncProgress(provider.id,- section = Section.VOD,- total = categories.size,- itemsIndexed = movieDao.getCount(provider.id).first()- )- syncCatalogStore.replaceCategories(- providerId = provider.id,- type = "MOVIE",- categories = categories.map { category ->- CategoryEntity(- providerId = provider.id,- categoryId = category.id,- name = category.name,- parentId = category.parentId,- type = ContentType.MOVIE,- isAdult = category.isAdult- )- }- )- queueStalkerIndexSection(- providerId = provider.id,- contentType = ContentType.MOVIE,- totalCategories = categories.size,- now = now- )- val metadata = (syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id))- .copy(- lastMovieSync = now,- lastMovieAttempt = now,- movieCount = movieDao.getCount(provider.id).first(),- movieSyncMode = VodSyncMode.PAGED,- movieWarningsCount = 0,- movieCatalogStale = true- )- syncMetadataRepository.updateMetadata(metadata)- scheduleStalkerIndexContinuation(provider, ContentType.MOVIE, force = true)- return SyncOutcome()- }+ private fun MovieEntity.toXtreamIndexRow(+ providerId: Long,+ localContentId: Long,+ indexedAt: Long+ ): XtreamContentIndexEntity = XtreamContentIndexEntity(+ providerId = providerId,+ contentType = ContentType.MOVIE,+ remoteId = streamId.toString(),+ localContentId = localContentId.takeIf { it > 0L },+ name = name,+ categoryId = categoryId,+ categoryName = categoryName,+ imageUrl = posterUrl,+ containerExtension = containerExtension,+ rating = rating,+ addedAt = addedAt,+ isAdult = isAdult,+ indexedAt = indexedAt,+ detailHydratedAt = detailHydratedAt,+ staleState = "ACTIVE",+ errorState = null,+ syncFingerprint = syncFingerprint+ )- private suspend fun syncXtreamSeriesOnly(- provider: Provider,- onProgress: ((String) -> Unit)?- ): SyncOutcome {- val now = System.currentTimeMillis()- progress(provider.id, onProgress, "Queueing Series index...")- val useTextClassification = preferencesRepository.useXtreamTextClassification.first()- val enableBase64TextCompatibility = preferencesRepository.xtreamBase64TextCompatibility.first()- val api = createXtreamSyncProvider(provider, useTextClassification, enableBase64TextCompatibility)- val currentMetadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)- val categoryCount = syncXtreamCategoryShell(- provider = provider,- api = api,- contentType = ContentType.SERIES,- label = "Series",- now = now,- onProgress = onProgress- ).getOrElse { error ->- upsertXtreamIndexJob(- providerId = provider.id,- section = ContentType.SERIES.name,- state = xtreamIndexFailureState(error),- now = now,- lastAttemptAt = now,- lastError = sanitizeThrowableMessage(error)- )- throw IllegalStateException(- syncErrorSanitizer.userMessage(error, "Failed to queue series index"),- error- )- }- syncMetadataRepository.updateMetadata(- currentMetadata.copy(- lastSeriesSync = now- )- )- scheduleXtreamIndexSync(provider.id, ContentType.SERIES)- Log.i(TAG, "Queued Xtream series index for provider ${provider.id}: $categoryCount categories.")- return SyncOutcome()+ private fun SeriesEntity.toXtreamIndexRow(+ providerId: Long,+ localContentId: Long,+ indexedAt: Long+ ): XtreamContentIndexEntity = XtreamContentIndexEntity(+ providerId = providerId,+ contentType = ContentType.SERIES,+ remoteId = providerSeriesId?.takeIf { it.isNotBlank() } ?: seriesId.toString(),+ localContentId = localContentId.takeIf { it > 0L },+ name = name,+ categoryId = categoryId,+ categoryName = categoryName,+ imageUrl = posterUrl,+ rating = rating,+ remoteUpdatedAt = lastModified,+ isAdult = isAdult,+ indexedAt = indexedAt,+ detailHydratedAt = detailHydratedAt,+ staleState = "ACTIVE",+ errorState = null,+ syncFingerprint = syncFingerprint+ )++ private suspend fun updateXtreamSummaryMetadata(+ providerId: Long,+ contentType: ContentType,+ indexedRows: Int,+ finalState: String,+ now: Long+ ) {+ syncStatusPublicationCoordinator.updateSummaryMetadata(+ providerId = providerId,+ contentType = contentType,+ indexedRows = indexedRows,+ finalState = finalState,+ now = now,+ movieSyncMode = VodSyncMode.UNKNOWN+ )}- private suspend fun syncStalkerSeriesOnly(- provider: Provider,- onProgress: ((String) -> Unit)?- ): SyncOutcome {- progress(provider.id, onProgress, "Queueing Series index...")- val api = createStalkerSyncProvider(provider)- val categories = requireResult(api.getSeriesCategories(), "Failed to load series categories")- emitCatalogSyncProgress(provider.id,- section = Section.SERIES,- total = categories.size,- itemsIndexed = seriesDao.getCount(provider.id).first()- )- syncCatalogStore.replaceCategories(- providerId = provider.id,- type = "SERIES",- categories = categories.map { category ->- CategoryEntity(- providerId = provider.id,- categoryId = category.id,- name = category.name,- parentId = category.parentId,- type = ContentType.SERIES,- isAdult = category.isAdult- )- }- )- val now = System.currentTimeMillis()- queueStalkerIndexSection(- providerId = provider.id,- contentType = ContentType.SERIES,- totalCategories = categories.size,- now = now- )- val metadata = (syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id))- .copy(- lastSeriesSync = now,- seriesCount = seriesDao.getCount(provider.id).first()- )- syncMetadataRepository.updateMetadata(metadata)- scheduleStalkerIndexContinuation(provider, ContentType.SERIES, force = true)- return SyncOutcome()+ private fun CategoryEntity.toXtreamCategory(): XtreamCategory = XtreamCategory(+ categoryId = categoryId.toString(),+ categoryName = name,+ parentId = parentId?.toInt() ?: 0,+ isAdult = isAdult+ )++ private fun xtreamIndexSectionLabel(contentType: ContentType): String = when (contentType) {+ ContentType.MOVIE -> "Movies"+ ContentType.SERIES -> "Series"+ ContentType.LIVE -> "Live TV"+ ContentType.VOD -> "VOD"+ ContentType.SERIES_EPISODE -> "Episodes"}- private suspend fun syncJellyfinMoviesOnly(- provider: Provider,+ private suspend fun processXtreamLiveIndexBackfillSection(+ providerId: Long,onProgress: ((String) -> Unit)?) {- progress(provider.id, onProgress, "Retrying Jellyfin movies...")- val decrypted = provider- val sessionId = syncCatalogStore.newSessionId()- var startIndex = 0- var expectedTotal: Int? = null- try {- do {- when (val result = jellyfinProvider.fetchMoviesPage(decrypted, startIndex)) {- is Result.Success -> {- val page = result.data- expectedTotal = expectedTotal ?: page.totalRecordCount- if (page.totalRecordCount != expectedTotal) {- throw JellyfinPaginationException("Jellyfin movie catalog changed during retry")- }- syncCatalogStore.stageMovieBatch(provider.id, sessionId, page.items)- startIndex = page.nextStartIndex- }- is Result.Error -> throw result.exception ?: IllegalStateException(result.message)- is Result.Loading -> throw JellyfinPaginationException("Jellyfin movie retry did not complete")- }- } while (startIndex < (expectedTotal ?: 0))- syncCatalogStore.applyStagedMovieCatalog(- providerId = provider.id,- sessionId = sessionId,- categories = listOf(CategoryEntity(- providerId = provider.id,- categoryId = 1L,- name = "Movies",- type = ContentType.MOVIE- ))- )- val now = System.currentTimeMillis()- val metadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)- syncMetadataRepository.updateMetadata(- metadata.copy(- lastMovieSync = now,- lastMovieAttempt = now,- lastMovieSuccess = now,- movieCount = movieDao.getCount(provider.id).first(),- movieCatalogStale = false- )- )- } catch (cancelled: CancellationException) {- withContext(NonCancellable) { syncCatalogStore.discardStagedImport(provider.id, sessionId) }- throw cancelled- } catch (error: Exception) {- withContext(NonCancellable) { syncCatalogStore.discardStagedImport(provider.id, sessionId) }- throw error- }+ val now = System.currentTimeMillis()+ progress(providerId, onProgress, "Preparing Live TV index...")+ upsertXtreamIndexJob(+ providerId = providerId,+ section = ContentType.LIVE.name,+ state = "RUNNING",+ now = now,+ lastAttemptAt = now,+ lastError = null+ )+ val categoryCount = categoryDao.getByProviderAndTypeSync(providerId, ContentType.LIVE.name).size+ val indexedRows = backfillXtreamLiveIndex(providerId, now)+ upsertXtreamIndexJob(+ providerId = providerId,+ section = ContentType.LIVE.name,+ state = "SUCCESS",+ now = System.currentTimeMillis(),+ totalCategories = categoryCount,+ completedCategories = categoryCount,+ nextCategoryIndex = categoryCount,+ failedCategories = 0,+ indexedRows = indexedRows,+ skippedMalformedRows = 0,+ lastAttemptAt = now,+ lastSuccessAt = System.currentTimeMillis(),+ lastError = null+ )}- private suspend fun syncJellyfinSeriesOnly(- provider: Provider,- onProgress: ((String) -> Unit)?- ) {- progress(provider.id, onProgress, "Retrying Jellyfin series...")- val decrypted = provider- val sessionId = syncCatalogStore.newSessionId()- var startIndex = 0- var expectedTotal: Int? = null- try {- do {- when (val result = jellyfinProvider.fetchSeriesPage(decrypted, startIndex)) {- is Result.Success -> {- val page = result.data- expectedTotal = expectedTotal ?: page.totalRecordCount- if (page.totalRecordCount != expectedTotal) {- throw JellyfinPaginationException("Jellyfin series catalog changed during retry")- }- syncCatalogStore.stageSeriesBatch(provider.id, sessionId, page.items)- startIndex = page.nextStartIndex- }- is Result.Error -> throw result.exception ?: IllegalStateException(result.message)- is Result.Loading -> throw JellyfinPaginationException("Jellyfin series retry did not complete")- }- } while (startIndex < (expectedTotal ?: 0))- syncCatalogStore.applyStagedSeriesCatalog(- providerId = provider.id,- sessionId = sessionId,- categories = listOf(CategoryEntity(- providerId = provider.id,- categoryId = 2L,- name = "Series",- type = ContentType.SERIES- ))- )- val now = System.currentTimeMillis()- val metadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)- syncMetadataRepository.updateMetadata(- metadata.copy(- lastSeriesSync = now,- seriesCount = seriesDao.getCount(provider.id).first()- )+ private suspend fun backfillXtreamLiveIndex(providerId: Long, indexedAt: Long): Int {+ val channels = channelDao.getByProviderSync(providerId)+ if (channels.isEmpty()) return 0+ val indexRows = channels.map { channel ->+ XtreamContentIndexEntity(+ providerId = providerId,+ contentType = ContentType.LIVE,+ remoteId = channel.streamId.toString(),+ localContentId = channel.id.takeIf { it > 0 },+ name = channel.name,+ categoryId = channel.categoryId,+ categoryName = channel.categoryName ?: channel.groupTitle,+ imageUrl = channel.logoUrl,+ isAdult = channel.isAdult,+ indexedAt = indexedAt,+ detailHydratedAt = indexedAt,+ syncFingerprint = channel.syncFingerprint)- } catch (cancelled: CancellationException) {- withContext(NonCancellable) { syncCatalogStore.discardStagedImport(provider.id, sessionId) }- throw cancelled- } catch (error: Exception) {- withContext(NonCancellable) { syncCatalogStore.discardStagedImport(provider.id, sessionId) }- throw error}+ transactionRunner.inTransaction {+ xtreamContentIndexDao.deleteByProviderAndType(providerId, ContentType.LIVE.name)+ xtreamContentIndexDao.upsertAll(indexRows)+ }+ return channels.size}- private suspend fun syncXtreamLiveCatalog(- provider: Provider,- api: XtreamProvider,- existingMetadata: SyncMetadata,- hiddenLiveCategoryIds: Set<Long>,- onProgress: ((String) -> Unit)?,- runtimeProfile: CatalogSyncRuntimeProfile = CatalogSyncRuntimeProfile.from(applicationContext),- trackInitialLiveOnboarding: Boolean = false,- syncReason: XtreamLiveSyncReason = XtreamLiveSyncReason.FOREGROUND- ): CatalogSyncPayload<Channel> {- // Emission d'entree LIVE : signale tot a l'UI que la section LIVE demarre,- // avant meme la requete `get_live_categories`. `total = 0` = indetermine ;- // la premiere fin de fenetre (T5) viendra raffiner avec le vrai denominateur.- emitProviderProgress(provider.id,- com.streamvault.domain.sync.SyncProgress(- section = com.streamvault.domain.sync.Section.LIVE,- current = 0,- total = 0,- currentLabel = "",- itemsIndexed = 0+ private suspend fun upsertXtreamIndexJob(+ providerId: Long,+ section: String,+ state: String,+ now: Long,+ totalCategories: Int? = null,+ completedCategories: Int? = null,+ nextCategoryIndex: Int? = null,+ failedCategories: Int? = null,+ indexedRows: Int? = null,+ skippedMalformedRows: Int? = null,+ deletedPrunedRows: Int? = null,+ priorityCategoryId: Long? = null,+ priorityRequestedAt: Long? = null,+ clearPriority: Boolean = false,+ lastAttemptAt: Long? = null,+ lastSuccessAt: Long? = null,+ lastError: String? = null+ ) {+ catalogIndexJobStore.upsert(+ CatalogIndexJobUpdate(+ providerId = providerId,+ section = section,+ state = state,+ now = now,+ totalCategories = totalCategories,+ completedCategories = completedCategories,+ nextCategoryIndex = nextCategoryIndex,+ failedCategories = failedCategories,+ indexedRows = indexedRows,+ skippedMalformedRows = skippedMalformedRows,+ deletedPrunedRows = deletedPrunedRows,+ priorityCategoryId = priorityCategoryId,+ priorityRequestedAt = priorityRequestedAt,+ clearPriority = clearPriority,+ lastAttemptAt = lastAttemptAt,+ lastSuccessAt = lastSuccessAt,+ lastError = lastError))- val effectiveLiveSyncMethod = XtreamLiveSyncPolicy.resolve(- userMode = provider.xtreamLiveSyncMode,- runtimeProfile = runtimeProfile,- syncReason = syncReason,- metadata = existingMetadata,- now = System.currentTimeMillis(),- hiddenLiveCategoryIds = hiddenLiveCategoryIds- )- Log.i(- TAG,- "Xtream live sync method for provider ${provider.id}: user=${provider.xtreamLiveSyncMode} effective=$effectiveLiveSyncMethod reason=$syncReason profile=${runtimeProfile.diagnosticsLabel}."- )- return xtreamLiveStrategy.syncXtreamLiveCatalog(- provider,- api,- existingMetadata,- hiddenLiveCategoryIds,- onProgress,- runtimeProfile,- trackInitialLiveOnboarding,- effectiveLiveSyncMethod- )}- private suspend fun loadXtreamLiveFull(- provider: Provider,- api: XtreamProvider- ): CatalogSyncPayload<Channel> = xtreamLiveStrategy.loadXtreamLiveFull(provider, api, CatalogSyncRuntimeProfile.from(applicationContext))- private suspend fun loadXtreamLiveByCategory(- provider: Provider,- api: XtreamProvider,- rawCategories: List<XtreamCategory>,- onProgress: ((String) -> Unit)?,- preferSequential: Boolean- ): CatalogSyncPayload<Channel> =- xtreamLiveStrategy.loadXtreamLiveByCategory(provider, api, rawCategories, onProgress, preferSequential, CatalogSyncRuntimeProfile.from(applicationContext))+ /**+ * Returns true for transient network/IO exceptions that are worth retrying via+ * WorkManager backoff — as opposed to permanent failures (bad URL, auth, parse error)+ * that will fail identically on every attempt.+ */+ private fun isRetryableEpgException(e: Exception): Boolean =+ e is java.io.IOException ||+ e is java.net.SocketTimeoutException ||+ e is java.net.ConnectException ||+ e is java.net.UnknownHostException ||+ e.cause?.let {+ it is java.io.IOException ||+ it is java.net.SocketTimeoutException ||+ it is java.net.ConnectException ||+ it is java.net.UnknownHostException+ } == true++private suspend fun updateSyncStatusMetadata(providerId: Long, status: String) {- val metadata = (syncMetadataRepository.getMetadata(providerId) ?: SyncMetadata(providerId))- .copy(lastSyncStatus = status)- syncMetadataRepository.updateMetadata(metadata)+ syncStatusPublicationCoordinator.updateStatus(providerId, status)}private fun syncFailureStatus(provider: Provider, error: Throwable): String {@@ -6466,10 +2144,6 @@ class SyncManager @Inject constructor(}}- private fun Throwable.hasStalkerRateLimit(): Boolean =- generateSequence(this as Throwable?) { it.cause }- .any { it is StalkerApiError.RateLimited }-private fun shouldRememberSequentialPreference(error: Throwable): Boolean {return xtreamAdaptiveSyncPolicy.isProviderStress(error) ||error is XtreamAuthenticationException ||@@ -6478,55 +2152,6 @@ class SyncManager @Inject constructor((error is XtreamNetworkException && error.message.orEmpty().contains("reset", ignoreCase = true))}- private fun updateSequentialProviderAdaptation(- previousRemembered: Boolean,- previousHealthyStreak: Int,- sawSequentialStress: Boolean- ): SequentialProviderAdaptation {- if (sawSequentialStress) {- return SequentialProviderAdaptation(rememberSequential = true, healthyStreak = 0)- }- if (!previousRemembered) {- return SequentialProviderAdaptation(rememberSequential = false, healthyStreak = 0)- }- val nextHealthyStreak = (previousHealthyStreak + 1).coerceAtMost(2)- return if (nextHealthyStreak >= 2) {- SequentialProviderAdaptation(rememberSequential = false, healthyStreak = 0)- } else {- SequentialProviderAdaptation(rememberSequential = true, healthyStreak = nextHealthyStreak)- }- }-- private fun updateAvoidFullUntil(- previousAvoidFullUntil: Long,- now: Long,- feedback: XtreamStrategyFeedback- ): Long = catalogStrategySupport.updateAvoidFullUntil(previousAvoidFullUntil, now, feedback)-- private fun shouldPreferSegmentedLiveSync(- metadata: SyncMetadata,- now: Long- ): Boolean = catalogStrategySupport.shouldPreferSegmentedLiveSync(metadata, now)-- private fun shouldPreferSegmentedMovieSync(- metadata: SyncMetadata,- now: Long- ): Boolean = catalogStrategySupport.shouldPreferSegmentedMovieSync(metadata, now)-- private fun shouldPreferSegmentedSeriesSync(- metadata: SyncMetadata,- now: Long- ): Boolean = catalogStrategySupport.shouldPreferSegmentedSeriesSync(metadata, now)-- private fun shouldAvoidFullCatalogStrategy(error: Throwable): Boolean =- catalogStrategySupport.shouldAvoidFullCatalogStrategy(error)-- private fun sawSegmentedStress(- warnings: List<String>,- result: CatalogStrategyResult<*>,- sequentialWarnings: Set<String>- ): Boolean = catalogStrategySupport.sawSegmentedStress(warnings, result, sequentialWarnings)-private fun buildFallbackMovieCategories(providerId: Long, movies: List<Movie>): List<CategoryEntity> =catalogStrategySupport.buildFallbackMovieCategories(providerId, movies)@@ -6541,155 +2166,9 @@ class SyncManager @Inject constructor(fallback: List<CategoryEntity>?): List<CategoryEntity>? = catalogStrategySupport.mergePreferredAndFallbackCategories(preferred, fallback)- private suspend fun finalizeXtreamLiveCatalog(- providerId: Long,- liveSyncResult: CatalogSyncPayload<Channel>,- hiddenLiveCategoryIds: Set<Long>,- onProgress: ((String) -> Unit)? = null,- partialCompletionWarning: String? = null,- afterCatalogApply: suspend () -> Unit = {}- ): XtreamLiveCommitResult {- progress(providerId, onProgress, "Saving Live TV channels...")- val warnings = buildList {- addAll(liveSyncResult.warnings)- addAll(catalogStrategySupport.strategyWarnings(liveSyncResult.catalogResult))- partialCompletionWarning?.let(::add)- }- val acceptedCount = when (val liveResult = liveSyncResult.catalogResult) {- is CatalogStrategyResult.Success -> {- liveSyncResult.stagedSessionId?.let { sessionId ->- val mergedCategories = mergeVisibleLiveCategoriesWithHiddenStoredContent(- providerId = providerId,- visibleCategories = liveSyncResult.categories,- hiddenLiveCategoryIds = hiddenLiveCategoryIds- )- if (hiddenLiveCategoryIds.isNotEmpty()) {- mergeHiddenChannelsIntoStaging(providerId, sessionId, hiddenLiveCategoryIds)- }- syncCatalogStore.applyStagedLiveCatalog(- providerId = providerId,- sessionId = sessionId,- categories = mergedCategories,- afterCatalogApply = afterCatalogApply- )- liveSyncResult.stagedAcceptedCount- } ?: run {- val liveCatalog = mergeVisibleLiveSyncWithHiddenStoredContent(- providerId = providerId,- visibleCategories = liveSyncResult.categories,- visibleChannels = liveResult.items.map { it.toEntity() },- hiddenLiveCategoryIds = hiddenLiveCategoryIds- )- syncCatalogStore.replaceLiveCatalog(- providerId = providerId,- categories = liveCatalog.categories,- channels = liveCatalog.channels,- afterCatalogApply = afterCatalogApply- )- }- }- is CatalogStrategyResult.Partial -> {- liveSyncResult.stagedSessionId?.let { sessionId ->- val mergedCategories = mergeVisibleLiveCategoriesWithHiddenStoredContent(- providerId = providerId,- visibleCategories = liveSyncResult.categories,- hiddenLiveCategoryIds = hiddenLiveCategoryIds- )- if (hiddenLiveCategoryIds.isNotEmpty()) {- mergeHiddenChannelsIntoStaging(providerId, sessionId, hiddenLiveCategoryIds)- }- syncCatalogStore.applyStagedLiveCatalogUpsertOnly(- providerId = providerId,- sessionId = sessionId,- categories = mergedCategories,- afterCatalogApply = afterCatalogApply- )- liveSyncResult.stagedAcceptedCount- } ?: run {- val liveCatalog = mergeVisibleLiveSyncWithHiddenStoredContent(- providerId = providerId,- visibleCategories = liveSyncResult.categories,- visibleChannels = liveResult.items.map { it.toEntity() },- hiddenLiveCategoryIds = hiddenLiveCategoryIds- )- syncCatalogStore.upsertLiveCatalog(- providerId = providerId,- categories = liveCatalog.categories,- channels = liveCatalog.channels,- afterCatalogApply = afterCatalogApply- )- }- }- is CatalogStrategyResult.EmptyValid,- is CatalogStrategyResult.Failure -> {- throw IllegalArgumentException(- "finalizeXtreamLiveCatalog only supports success or partial results"- )- }- }- return XtreamLiveCommitResult(acceptedCount = acceptedCount, warnings = warnings)- }-- private suspend fun mergeHiddenChannelsIntoStaging(- providerId: Long,- sessionId: Long,- hiddenLiveCategoryIds: Set<Long>- ) {- val hiddenChannels = channelDao.getByProviderSync(providerId)- .filter { channel -> channel.categoryId != null && channel.categoryId in hiddenLiveCategoryIds }- if (hiddenChannels.isNotEmpty()) {- syncCatalogStore.stageChannelBatch(providerId, sessionId, hiddenChannels)- }- }-- private suspend fun mergeVisibleLiveCategoriesWithHiddenStoredContent(- providerId: Long,- visibleCategories: List<CategoryEntity>?,- hiddenLiveCategoryIds: Set<Long>- ): List<CategoryEntity>? {- if (hiddenLiveCategoryIds.isEmpty()) {- return visibleCategories- }-- return ((visibleCategories ?: emptyList()) + categoryDao.getByProviderAndTypeSync(providerId, ContentType.LIVE.name)- .filter { category -> category.categoryId in hiddenLiveCategoryIds })- .distinctBy { it.categoryId to it.type }- .sortedBy { it.categoryId }- .takeIf { it.isNotEmpty() }- }-- private suspend fun mergeVisibleLiveSyncWithHiddenStoredContent(- providerId: Long,- visibleCategories: List<CategoryEntity>?,- visibleChannels: List<ChannelEntity>,- hiddenLiveCategoryIds: Set<Long>- ): LiveCatalogSnapshot {- if (hiddenLiveCategoryIds.isEmpty()) {- return LiveCatalogSnapshot(visibleCategories, visibleChannels)- }-- val hiddenCategories = categoryDao.getByProviderAndTypeSync(providerId, ContentType.LIVE.name)- .filter { category -> category.categoryId in hiddenLiveCategoryIds }- val hiddenChannels = channelDao.getByProviderSync(providerId)- .filter { channel -> channel.categoryId != null && channel.categoryId in hiddenLiveCategoryIds }-- val mergedCategories = ((visibleCategories ?: emptyList()) + hiddenCategories)- .distinctBy { it.categoryId to it.type }- .sortedBy { it.categoryId }- .takeIf { it.isNotEmpty() }- val mergedChannels = (visibleChannels + hiddenChannels)- .distinctBy { it.streamId }- .sortedBy { it.number }-- return LiveCatalogSnapshot(- categories = mergedCategories,- channels = mergedChannels- )- }private fun progress(providerId: Long, callback: ((String) -> Unit)?, message: String) {- publishSyncState(providerId, SyncState.Syncing(message))- callback?.invoke(message)+ syncStatusPublicationCoordinator.progress(providerId, callback, message)}private fun emitCatalogSyncProgress(@@ -6712,21 +2191,26 @@ class SyncManager @Inject constructor(}private fun publishSyncState(providerId: Long, state: SyncState) {- syncStateTracker.publish(providerId, state)+ syncStatusPublicationCoordinator.publish(providerId, state)}- private val progressSessions = ConcurrentHashMap<Long, SyncProgressSession>()+ private fun beginSyncStateSession(providerId: Long): SyncStateSession =+ syncStatusPublicationCoordinator.beginStateSession(providerId)++ private fun finishSyncStateSession(session: SyncStateSession) {+ syncStatusPublicationCoordinator.finishStateSession(session)+ }- private fun beginProgressSession(providerId: Long): SyncProgressSession =- syncProgressBus.begin(providerId).also { progressSessions[providerId] = it }+ private fun beginProgressSession(providerId: Long): SyncProgressSession {+ return syncStatusPublicationCoordinator.beginProgressSession(providerId)+ }private fun finishProgressSession(session: SyncProgressSession) {- progressSessions.remove(session.providerId, session)- syncProgressBus.finish(session)+ syncStatusPublicationCoordinator.finishProgressSession(session)}private fun emitProviderProgress(providerId: Long, progress: SyncProgress) {- progressSessions[providerId]?.let { session -> syncProgressBus.emit(session, progress) }+ syncStatusPublicationCoordinator.emitProgress(providerId, progress)}private fun redactUrlForLogs(url: String?): String {@@ -6828,7 +2312,7 @@ class SyncManager @Inject constructor(enableBase64TextCompatibility: Boolean = false): XtreamProvider {return when (val resolution = typedProviderClientFactory.xtream(- provider.toProviderSnapshot(),+ syncProviderSnapshotAdapter.toSnapshot(provider),XtreamClientOptions(useTextClassification, enableBase64TextCompatibility))) {is CapabilityResolution.Available -> resolution.capability@@ -6839,7 +2323,7 @@ class SyncManager @Inject constructor(}private fun createStalkerSyncProvider(provider: Provider): StalkerProvider {- return when (val resolution = typedProviderClientFactory.stalker(provider.toProviderSnapshot())) {+ return when (val resolution = typedProviderClientFactory.stalker(syncProviderSnapshotAdapter.toSnapshot(provider))) {is CapabilityResolution.Available -> resolution.capabilityis CapabilityResolution.ConfigurationError -> throw IllegalArgumentException(resolution.reason)is CapabilityResolution.Restricted -> throw IllegalArgumentException(resolution.reason)@@ -6887,556 +2371,10 @@ class SyncManager @Inject constructor(return StalkerTransportOrigin(scheme, host, port)}- private suspend fun loadStalkerChannelsByCategory(- api: StalkerProvider,- categories: List<com.streamvault.domain.model.Category>,- onProgress: ((String) -> Unit)?- ): StalkerLiveCategoryLoadResult {- progress(api.providerId, onProgress, "Loading live channels...")- val bulkChannels = requireResult(api.getLiveStreams(null), "Failed to load live channels")- if (categories.isEmpty()) {- return StalkerLiveCategoryLoadResult(channels = bulkChannels)- }-- val hasResolvedCategories = bulkChannels.any { channel -> channel.categoryId != null }- if (bulkChannels.isNotEmpty() && hasResolvedCategories) {- return StalkerLiveCategoryLoadResult(channels = bulkChannels.distinctBy { it.streamId })- }-- return fetchStalkerLiveChannelsByCategory(- provider = requireNotNull(providerDao.getById(api.providerId)) {- "Provider ${api.providerId} not found while loading live channels"- }.toDomain(),- api = api,- categories = categories.map { category ->- XtreamCategory(- categoryId = category.id.toString(),- categoryName = category.name,- isAdult = category.isAdult- )- },- onProgress = onProgress- )- }-- private data class StalkerLiveCategoryLoadResult(- val channels: List<Channel>,- val warnings: List<String> = emptyList()- )-- private data class StalkerLiveCatalogResult(- val categories: List<CategoryEntity>,- val channels: List<Channel>,- val warnings: List<String> = emptyList()- )-- private data class StagedStalkerLiveCatalogResult(- val acceptedCount: Int,- val warnings: List<String> = emptyList()- )-- private suspend fun syncStalkerLiveCatalogStaged(- api: StalkerProvider,- provider: Provider,- hiddenLiveCategoryIds: Set<Long>,- onProgress: ((String) -> Unit)?,- afterCatalogApply: suspend () -> Unit = {}- ): StagedStalkerLiveCatalogResult {- val warnings = mutableListOf<String>()- var categoriesErrorMessage: String? = null- val preferredCategories = when (val categoriesResult = api.getLiveCategories()) {- is com.streamvault.domain.model.Result.Success -> categoriesResult.data- .map { it.toEntity(provider.id) }- .filterNot { category -> category.categoryId in hiddenLiveCategoryIds }- is com.streamvault.domain.model.Result.Error -> {- Log.w(- TAG,- "Stalker live categories failed for provider ${provider.id}; streaming bulk live channels with fallback categories: ${categoriesResult.message}",- categoriesResult.exception- )- warnings += "Live categories failed; recovered using bulk live channels."- categoriesErrorMessage = categoriesResult.message- null- }- is com.streamvault.domain.model.Result.Loading -> throw IllegalStateException("Unexpected loading state")- }-- progress(provider.id, onProgress, "Loading live channels...")- val fallbackCollector = FallbackCategoryCollector(provider.id, ContentType.LIVE)- val seenStreamIds = HashSet<Long>()- val batch = ArrayList<Channel>(XTREAM_FALLBACK_STAGE_BATCH_SIZE)- var stagedSessionId: Long? = null- var acceptedCount = 0- var bulkRowsWithResolvedCategories = 0-- suspend fun flushBatch() {- if (batch.isEmpty()) return- val staged = catalogStager.stageChannelItems(- providerId = provider.id,- items = batch,- seenStreamIds = seenStreamIds,- fallbackCollector = fallbackCollector,- sessionId = stagedSessionId- )- stagedSessionId = staged.sessionId- acceptedCount += staged.acceptedCount- batch.clear()- }-- suspend fun finalizeStagedImport(): StagedStalkerLiveCatalogResult {- val sessionId = stagedSessionId- if (hiddenLiveCategoryIds.isNotEmpty()) {- sessionId?.let { mergeHiddenChannelsIntoStaging(provider.id, it, hiddenLiveCategoryIds) }- }- val hiddenCategories = if (hiddenLiveCategoryIds.isNotEmpty()) {- categoryDao.getByProviderAndTypeSync(provider.id, ContentType.LIVE.name)- .filter { category -> category.categoryId in hiddenLiveCategoryIds }- } else {- emptyList()- }- val categories = (- mergePreferredAndFallbackCategories(- preferredCategories,- fallbackCollector.entities().takeIf { it.isNotEmpty() }- ).orEmpty() + hiddenCategories- )- .distinctBy { it.categoryId to it.type }- .takeIf { it.isNotEmpty() }- if (acceptedCount == 0 || sessionId == null) {- // An empty discovery result is not proof that a previously working- // catalog became empty. Keep the committed generation intact and- // discard only rows owned by this attempt.- sessionId?.let { syncCatalogStore.discardStagedImport(provider.id, it) }- return StagedStalkerLiveCatalogResult(- acceptedCount = 0,- warnings = (- warnings +- "Live TV returned no usable channels; keeping the last verified Live catalog."- ).distinct()- )- }- syncCatalogStore.applyStagedLiveCatalog(- provider.id,- sessionId,- categories,- afterCatalogApply- )- return StagedStalkerLiveCatalogResult(acceptedCount, warnings)- }-- try {- var bulkFailure: Exception? = null- val learnedState = api.validatedPortalState()- val bulkUnsupportedVerdictFresh = learnedState?.bulkLiveSupported == false &&- learnedState.validatedAt > 0L &&- System.currentTimeMillis() - learnedState.validatedAt <= STALKER_BULK_LIVE_UNSUPPORTED_TTL_MILLIS- val shouldTryBulk = (- !bulkUnsupportedVerdictFresh &&- learnedState?.bulkLiveCategoryFidelity != false- ) || preferredCategories.isNullOrEmpty()- if (shouldTryBulk) {- StalkerTelemetry.strategySelected(- provider.id,- "BULK_LIVE",- when (learnedState?.bulkLiveSupported) {- true -> "VALIDATED_CACHE"- false -> "STALE_UNSUPPORTED_REPROBE"- else -> "CAPABILITY_PROBE"- }- )- } else {- StalkerTelemetry.strategySelected(- provider.id,- "CATEGORY_LIVE",- if (learnedState?.bulkLiveCategoryFidelity == false) {- "BULK_CATEGORY_FIDELITY_FAILED"- } else {- "BULK_KNOWN_UNSUPPORTED"- }- )- }- val streamResult = if (shouldTryBulk) {- withStalkerBulkLiveStallTimeout { markBulkProgress ->- api.streamLiveStreams { channel ->- markBulkProgress()- if (channel.categoryId != null && channel.categoryId in hiddenLiveCategoryIds) {- return@streamLiveStreams- }- if (channel.categoryId != null) bulkRowsWithResolvedCategories += 1- batch += channel- if (batch.size >= XTREAM_FALLBACK_STAGE_BATCH_SIZE) {- flushBatch()- progress(- provider.id,- onProgress,- "Loading live channels... $acceptedCount imported"- )- }- }- }- } else {- null- }- when (streamResult) {- is com.streamvault.domain.model.Result.Success -> {- flushBatch()- api.recordBulkLiveCapability(- supported = true,- categoryFidelity = acceptedCount == 0 || bulkRowsWithResolvedCategories > 0- )- return finalizeStagedImport()- }- is com.streamvault.domain.model.Result.Error -> {- // Only definitive portal verdicts (auth denial, malformed payload,- // blocked action) prove bulk is unsupported. Transport failures and- // 5xx/rate-limit responses are transient: keep bulk eligible so the- // next sync retries it instead of locking in the slow per-category- // path for the validation TTL.- if (isDefinitiveBulkLiveFailure(streamResult.exception)) {- api.recordBulkLiveCapability(supported = false)- }- val profileDiagnostic = stalkerCatalogAccessDiagnostic(- api = api,- primaryMessage = categoriesErrorMessage.orEmpty(),- fallbackMessage = streamResult.message- )- bulkFailure = IllegalStateException(- buildString {- append(streamResult.message.ifBlank { "Failed to load live channels" })- profileDiagnostic?.let {- append(' ')- append(it)- }- },- streamResult.exception- )- }- is com.streamvault.domain.model.Result.Loading -> throw IllegalStateException("Unexpected loading state")- null -> if (shouldTryBulk) {- // A stalled/timed-out bulk transfer reflects link throughput, not- // portal capability. Leave bulkLiveSupported unset so the next sync- // retries the bulk path.- bulkFailure = IOException("Bulk live request timed out; switching to category requests.")- progress(provider.id, onProgress, "Bulk live request is slow; loading categories instead...")- }- }-- stagedSessionId?.let { syncCatalogStore.discardStagedImport(provider.id, it) }- stagedSessionId = null- acceptedCount = 0- batch.clear()- seenStreamIds.clear()-- val fallbackCategories = preferredCategories.orEmpty()- if (fallbackCategories.isEmpty()) {- 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(- TAG,- "Stalker bulk live sync failed for provider ${provider.id}; falling back to category live fetches.",- bulkFailure- )- warnings += "Bulk live request failed; recovered using per-category live fetches."-- val fallbackResult = fetchStalkerLiveChannelsByCategory(- provider = provider,- api = api,- categories = fallbackCategories.map { category ->- XtreamCategory(- categoryId = category.categoryId.toString(),- categoryName = category.name,- isAdult = category.isAdult- )- },- onProgress = onProgress- )- warnings += fallbackResult.warnings- fallbackResult.channels.forEach { channel ->- if (channel.categoryId != null && channel.categoryId in hiddenLiveCategoryIds) {- return@forEach- }- batch += channel- if (batch.size >= XTREAM_FALLBACK_STAGE_BATCH_SIZE) {- flushBatch()- }- }- flushBatch()- return finalizeStagedImport()- } catch (error: CancellationException) {- stagedSessionId?.let { syncCatalogStore.discardStagedImport(provider.id, it) }- throw error- } catch (error: Exception) {- stagedSessionId?.let { syncCatalogStore.discardStagedImport(provider.id, it) }- throw error- }- }-- /**- * Runs the bulk live stream with a stall watchdog instead of a fixed wall-clock- * cap. Large portals stream tens of MB in one response, so the attempt is- * cancelled only when no items arrive for [STALKER_BULK_LIVE_STALL_TIMEOUT_MILLIS].- * There is intentionally no absolute wall-clock timeout: a large catalog may take- * longer than five minutes while still making healthy progress. Returns null when- * the attempt ended by a stall, while propagating cancellation of the worker itself.- */- private suspend fun <T> withStalkerBulkLiveStallTimeout(- block: suspend (markProgress: () -> Unit) -> T- ): T? = coroutineScope {- val lastProgressAt = AtomicLong(System.currentTimeMillis())- val streamDeferred = async {- block { lastProgressAt.set(System.currentTimeMillis()) }- }- val watchdog = launch {- while (isActive) {- delay(STALKER_BULK_LIVE_STALL_CHECK_INTERVAL_MILLIS)- val stalledFor = System.currentTimeMillis() - lastProgressAt.get()- if (stalledFor >= STALKER_BULK_LIVE_STALL_TIMEOUT_MILLIS) {- streamDeferred.cancel()- break- }- }- }- try {- try {- streamDeferred.await()- } catch (cancelled: CancellationException) {- // Propagate cancellation of the outer scope (worker stopped); only the- // watchdog's stall-cancel maps to null.- if (!isActive) throw cancelled- null- }- } finally {- watchdog.cancel()- streamDeferred.cancel()- }- }-- /**- * Only definitive portal verdicts prove the bulk live action is unsupported.- * Transport failures, consent challenges, rate limits and 5xx responses are- * transient conditions and must not downgrade the learned portal state.- */- private fun isDefinitiveBulkLiveFailure(error: Throwable?): Boolean = when (error) {- is StalkerApiError.Authorization,- is StalkerApiError.ModelRejected,- is StalkerApiError.AccountBlocked,- is StalkerApiError.Malformed,- is StalkerApiError.ResponseTooLarge,- is StalkerApiError.CatalogTruncated,- is StalkerApiError.BlockedOrConfiguration -> true- else -> false- }-- private suspend fun loadStalkerLiveCatalog(- api: StalkerProvider,- provider: Provider,- onProgress: ((String) -> Unit)?- ): StalkerLiveCatalogResult {- return when (val categoriesResult = api.getLiveCategories()) {- is com.streamvault.domain.model.Result.Success -> {- val channelResult = loadStalkerChannelsByCategory(api, categoriesResult.data, onProgress)- StalkerLiveCatalogResult(- categories = categoriesResult.data.map { it.toEntity(provider.id) },- channels = channelResult.channels,- warnings = channelResult.warnings- )- }- is com.streamvault.domain.model.Result.Error -> {- Log.w(- TAG,- "Stalker live categories failed for provider ${provider.id}; trying bulk live fallback: ${categoriesResult.message}",- categoriesResult.exception- )- when (val bulkResult = api.getLiveStreams(null)) {- is com.streamvault.domain.model.Result.Success -> {- val channels = bulkResult.data.distinctBy { it.streamId }- if (channels.isEmpty()) {- throw IllegalStateException(- "${categoriesResult.message.ifBlank { "Failed to load live categories" }} Bulk live fallback returned no channels.",- categoriesResult.exception- )- }- StalkerLiveCatalogResult(- categories = synthesizeStalkerLiveCategories(provider.id, channels),- channels = channels,- warnings = listOf("Live categories failed; recovered using bulk live channels.")- )- }- is com.streamvault.domain.model.Result.Error -> {- val profileDiagnostic = stalkerCatalogAccessDiagnostic(- api = api,- primaryMessage = categoriesResult.message,- fallbackMessage = bulkResult.message- )- throw IllegalStateException(- buildString {- append(categoriesResult.message.ifBlank { "Failed to load live categories" })- bulkResult.message.takeIf { it.isNotBlank() }?.let {- append(" Bulk live fallback also failed: ")- append(it)- }- profileDiagnostic?.let {- append(' ')- append(it)- }- },- bulkResult.exception ?: categoriesResult.exception- )- }- is com.streamvault.domain.model.Result.Loading -> throw IllegalStateException("Unexpected loading state")- }- }- is com.streamvault.domain.model.Result.Loading -> throw IllegalStateException("Unexpected loading state")- }- }-- private suspend fun fetchStalkerLiveChannelsByCategory(- provider: Provider,- api: StalkerProvider,- categories: List<XtreamCategory>,- onProgress: ((String) -> Unit)?- ): StalkerLiveCategoryLoadResult {- if (categories.isEmpty()) {- return StalkerLiveCategoryLoadResult(emptyList())- }-- val runtimeProfile = CatalogSyncRuntimeProfile.from(applicationContext)- val concurrency = minOf(- categories.size,- runtimeProfile.maxCategoryConcurrency,- STALKER_MAX_PARALLEL_CATEGORY_FETCHES- ).coerceAtLeast(1)- val executionPlan = executeCategoryRecoveryPlan(- provider = provider,- categories = categories,- initialConcurrency = concurrency,- sectionLabel = "Live TV",- sequentialModeWarning = LIVE_CATEGORY_SEQUENTIAL_MODE_WARNING,- onProgress = onProgress,- fetch = { category -> fetchStalkerLiveCategoryOutcome(api, category) }- )- var timedOutcomes = executionPlan.outcomes-- val categoryOutcomes = timedOutcomes.map { it.outcome }- val failureCount = timedOutcomes.count { it.outcome is CategoryFetchOutcome.Failure }- val fastFailureCount = timedOutcomes.count {- it.elapsedMs <= 5_000L && it.outcome is CategoryFetchOutcome.Failure- }- val downgradeRecommended = catalogStrategySupport.shouldDowngradeCategorySync(- categories.size,- failureCount,- fastFailureCount,- categoryOutcomes- )- var warnings = executionPlan.warnings-- if (concurrency > 1 && catalogStrategySupport.shouldRetryFailedCategories(- categories.size,- failureCount,- downgradeRecommended,- categoryOutcomes- )- ) {- val failedRetryTotal = timedOutcomes.count { it.outcome is CategoryFetchOutcome.Failure }- Log.w(- TAG,- "Stalker live category sync is continuing in sequential mode for failed categories on provider ${provider.id}."- )- progress(provider.id, onProgress, "Retrying failed Live TV categories 0/$failedRetryTotal...")- timedOutcomes = continueFailedCategoryOutcomes(- provider = provider,- timedOutcomes = timedOutcomes,- fetchSequentially = { category -> fetchStalkerLiveCategoryOutcome(api, category) },- onCategoryRetried = { completed, total, _ ->- progress(provider.id, onProgress, "Retrying failed Live TV categories $completed/$total...")- }- )- warnings = (- warnings + if (downgradeRecommended) listOf(LIVE_CATEGORY_SEQUENTIAL_MODE_WARNING) else emptyList()- ).distinct()- }-- val finalOutcomes = timedOutcomes.map { it.outcome }- val channels = finalOutcomes- .filterIsInstance<CategoryFetchOutcome.Success<Channel>>()- .flatMap { outcome -> outcome.items }- .distinctBy { channel -> channel.streamId }- val outcomeWarnings = finalOutcomes- .filterIsInstance<CategoryFetchOutcome.Failure>()- .map { failure -> categoryFailureWarning("Live TV", failure.categoryName, failure.error) }-- return StalkerLiveCategoryLoadResult(- channels = channels,- warnings = (outcomeWarnings + warnings).distinct()- )- }-- private suspend fun stalkerCatalogAccessDiagnostic(- api: StalkerProvider,- primaryMessage: String,- fallbackMessage: String?- ): String? {- if (!isStalkerEmptyResponse(primaryMessage) || !isStalkerEmptyResponse(fallbackMessage)) {- return null- }- val profile = when (val profileResult = api.getAccountProfile()) {- is com.streamvault.domain.model.Result.Success -> profileResult.data- else -> return null- }- if (profile.ambiguousState) {- return "Portal profile is ambiguous; playback/session validation failed. Check that the MAC is activated and that this portal supports MAG-style playback for the assigned account."- }- if (!profile.hasLikelyMissingCatalogAccess()) {- return null- }- return "Portal authenticated, but the returned Stalker profile indicates this account has no accessible catalog data. Check that the MAC is activated and assigned a live/VOD package on the provider side."- }-- private fun isStalkerEmptyResponse(message: String?): Boolean =- !message.isNullOrBlank() && message.contains("empty response", ignoreCase = true)- private fun shouldUseProviderGuide(policy: GuideSourcePolicy): Boolean =- policy == GuideSourcePolicy.AUTO || policy == GuideSourcePolicy.PROVIDER_ONLY- private fun shouldUseExternalGuide(policy: GuideSourcePolicy): Boolean =- policy == GuideSourcePolicy.AUTO || policy == GuideSourcePolicy.EXTERNAL_ONLY- private fun StalkerProviderProfile.hasLikelyMissingCatalogAccess(): Boolean {- val normalizedAccountId = accountId?.trim().orEmpty()- val normalizedAccountName = accountName?.trim().orEmpty()- return authAccess == false &&- (normalizedAccountId.isBlank() || normalizedAccountId == "0") &&- (normalizedAccountName.isBlank() || normalizedAccountName == "0")- }- private fun synthesizeStalkerLiveCategories(- providerId: Long,- channels: List<Channel>- ): List<CategoryEntity> {- return channels- .mapNotNull { channel ->- val categoryId = channel.categoryId ?: return@mapNotNull null- CategoryEntity(- providerId = providerId,- categoryId = categoryId,- name = channel.categoryName?.takeIf { it.isNotBlank() } ?: "Category $categoryId",- type = ContentType.LIVE,- isAdult = channel.isAdult- )- }- .distinctBy { it.categoryId }- }private suspend fun loadStalkerMoviesByCategory(api: StalkerProvider,@@ -7490,39 +2428,6 @@ class SyncManager @Inject constructor(category: XtreamCategory): TimedCategoryOutcome<Channel> = xtreamFetcher.fetchLiveCategoryOutcome(provider, api, category)- private suspend fun fetchStalkerLiveCategoryOutcome(- api: StalkerProvider,- category: XtreamCategory- ): TimedCategoryOutcome<Channel> {- val startedAt = System.currentTimeMillis()- val outcome = try {- val categoryId = category.categoryId.toLongOrNull()- ?: throw IllegalArgumentException("Invalid Stalker live category id '${category.categoryId}'")- val channels = requireResult(- api.getLiveStreams(categoryId),- "Failed to load live channels for ${category.categoryName}"- ).distinctBy { it.streamId }- if (channels.isEmpty()) {- CategoryFetchOutcome.Empty(category.categoryName)- } else {- CategoryFetchOutcome.Success(- categoryName = category.categoryName,- items = channels,- rawCount = channels.size- )- }- } catch (error: CancellationException) {- throw error- } catch (error: Throwable) {- CategoryFetchOutcome.Failure(category.categoryName, error)- }-- return TimedCategoryOutcome(- category = category,- outcome = outcome,- elapsedMs = System.currentTimeMillis() - startedAt- )- }private suspend fun fetchMovieCategoryOutcome(provider: Provider,diff --git a/data/src/main/java/com/streamvault/data/sync/SyncManagerPlanDelegate.kt b/data/src/main/java/com/streamvault/data/sync/SyncManagerPlanDelegate.ktnew file mode 100644index 00000000..3be0ab52--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/SyncManagerPlanDelegate.kt@@ -0,0 +1,173 @@+package com.streamvault.data.sync++import com.streamvault.domain.model.ProviderSnapshot+import com.streamvault.domain.model.SyncMetadata+import com.streamvault.domain.repository.SyncMetadataRepository++/**+ * Bridges the provider-neutral plan contract to the existing provider executors.+ *+ * This is intentionally outside [SyncManager]. The compatibility projection is an adapter concern+ * while the executor ports are migrated to typed snapshots; the manager only assembles this+ * delegate and coordinates lifecycle/state policy.+ */+internal class SyncManagerPlanDelegate(+ private val snapshotAdapter: SyncProviderSnapshotAdapter,+ private val syncMetadataRepository: SyncMetadataRepository,+ private val xtreamCatalogExecutor: XtreamCatalogSyncExecutor,+ private val xtreamCatalogSectionExecutor: XtreamCatalogSectionExecutor,+ private val providerEpgExecutor: ProviderEpgSyncExecutor,+ private val m3uCatalogExecutor: M3uCatalogSyncExecutor,+ private val stalkerSyncExecutor: StalkerCatalogSyncExecutor,+ private val stalkerCatalogSectionExecutor: StalkerCatalogSectionExecutor,+ private val jellyfinCatalogExecutor: JellyfinCatalogSyncExecutor+) : CatalogSyncPlanDelegate {+ private fun ProviderSnapshot.toLegacyProvider() = snapshotAdapter.toLegacyProvider(this)++ override suspend fun syncXtreamFull(request: FullProviderSyncRequest): SyncOutcome =+ xtreamCatalogExecutor.syncFull(+ provider = request.snapshot.toLegacyProvider(),+ force = request.force,+ onProgress = request.onProgress,+ trackInitialLiveOnboarding = request.trackInitialLiveOnboarding,+ syncReason = if (request.trackInitialLiveOnboarding) {+ XtreamLiveSyncReason.INITIAL_ONBOARDING+ } else {+ XtreamLiveSyncReason.FOREGROUND+ },+ afterCatalogApply = request.afterCatalogApply+ )++ override suspend fun syncXtreamLive(request: SectionProviderSyncRequest): SyncOutcome =+ xtreamCatalogExecutor.syncLive(+ request.snapshot.toLegacyProvider(),+ request.syncReason,+ request.onProgress+ )++ override suspend fun syncXtreamEpg(request: SectionProviderSyncRequest) {+ providerEpgExecutor.syncXtreamEpgOnly(request.snapshot.toLegacyProvider(), request.onProgress)+ }++ override suspend fun syncXtreamMovies(request: SectionProviderSyncRequest): SyncOutcome =+ xtreamCatalogSectionExecutor.syncMovies(+ request.snapshot.toLegacyProvider(),+ request.onProgress+ )++ override suspend fun syncXtreamSeries(request: SectionProviderSyncRequest): SyncOutcome =+ xtreamCatalogSectionExecutor.syncSeries(+ request.snapshot.toLegacyProvider(),+ request.onProgress+ )++ override suspend fun syncXtreamGuide(request: ProviderGuideSyncRequest): ProviderGuideSyncResult {+ val provider = request.snapshot.toLegacyProvider()+ return providerEpgExecutor.syncXtreamProviderEpg(+ provider,+ syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id),+ request.now,+ request.force,+ request.onProgress+ )+ }++ override suspend fun syncM3uFull(request: FullProviderSyncRequest): SyncOutcome =+ m3uCatalogExecutor.syncFull(+ request.snapshot.toLegacyProvider(),+ request.force,+ request.onProgress,+ request.afterCatalogApply+ )++ override suspend fun syncM3uLive(request: SectionProviderSyncRequest): SyncOutcome =+ m3uCatalogExecutor.syncLive(request.snapshot.toLegacyProvider(), request.onProgress)++ override suspend fun syncM3uEpg(request: SectionProviderSyncRequest) {+ providerEpgExecutor.syncM3uEpgOnly(request.snapshot.toLegacyProvider(), request.onProgress)+ }++ override suspend fun syncM3uMovies(request: SectionProviderSyncRequest): SyncOutcome =+ m3uCatalogExecutor.syncMovies(request.snapshot.toLegacyProvider(), request.onProgress)++ override suspend fun syncM3uGuide(request: ProviderGuideSyncRequest): ProviderGuideSyncResult {+ val provider = request.snapshot.toLegacyProvider()+ return providerEpgExecutor.syncM3uProviderEpg(+ provider,+ syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id),+ request.now,+ request.force,+ request.onProgress+ )+ }++ override suspend fun syncStalkerFull(request: FullProviderSyncRequest): SyncOutcome =+ stalkerSyncExecutor.syncFull(+ provider = request.snapshot.toLegacyProvider(),+ force = request.force,+ onProgress = request.onProgress,+ afterCatalogApply = request.afterCatalogApply,+ deferProviderStateUntilCatalogCommit = request.deferProviderStateUntilCatalogCommit+ )++ override suspend fun syncStalkerLive(request: SectionProviderSyncRequest): SyncOutcome =+ stalkerSyncExecutor.syncLive(request.snapshot.toLegacyProvider(), request.onProgress)++ override suspend fun syncStalkerEpg(request: SectionProviderSyncRequest) {+ providerEpgExecutor.syncStalkerEpgOnly(request.snapshot.toLegacyProvider(), request.onProgress)+ }++ override suspend fun syncStalkerMovies(request: SectionProviderSyncRequest): SyncOutcome =+ stalkerCatalogSectionExecutor.syncMovies(+ request.snapshot.toLegacyProvider(),+ request.onProgress+ )++ override suspend fun syncStalkerSeries(request: SectionProviderSyncRequest): SyncOutcome =+ stalkerCatalogSectionExecutor.syncSeries(+ request.snapshot.toLegacyProvider(),+ request.onProgress+ )++ override suspend fun syncStalkerGuide(request: ProviderGuideSyncRequest): ProviderGuideSyncResult {+ val provider = request.snapshot.toLegacyProvider()+ return providerEpgExecutor.syncStalkerProviderEpg(+ provider,+ syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id),+ request.now,+ request.force,+ request.onProgress+ )+ }++ override suspend fun syncJellyfinFull(request: FullProviderSyncRequest): SyncOutcome =+ jellyfinCatalogExecutor.syncFull(+ request.snapshot.toLegacyProvider(),+ request.force,+ request.onProgress,+ request.afterCatalogApply+ )++ override suspend fun syncJellyfinMovies(request: SectionProviderSyncRequest): SyncOutcome =+ jellyfinCatalogExecutor.syncMovies(+ request.snapshot.toLegacyProvider(),+ request.onProgress+ )++ override suspend fun syncJellyfinSeries(request: SectionProviderSyncRequest): SyncOutcome =+ jellyfinCatalogExecutor.syncSeries(+ request.snapshot.toLegacyProvider(),+ request.onProgress+ )++ override suspend fun syncJellyfinGuide(request: ProviderGuideSyncRequest): ProviderGuideSyncResult {+ val provider = request.snapshot.toLegacyProvider()+ return providerEpgExecutor.syncJellyfinProviderEpg(+ provider,+ syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id),+ request.now,+ request.force,+ request.onProgress+ )+ }+}diff --git a/data/src/main/java/com/streamvault/data/sync/SyncManagerSupport.kt b/data/src/main/java/com/streamvault/data/sync/SyncManagerSupport.ktindex 1f137af6..afd8e0b4 100644--- a/data/src/main/java/com/streamvault/data/sync/SyncManagerSupport.kt+++ b/data/src/main/java/com/streamvault/data/sync/SyncManagerSupport.kt@@ -12,9 +12,62 @@ import java.security.MessageDigestinternal data class SyncOutcome(val partial: Boolean = false,- val warnings: List<String> = emptyList()+ val warnings: List<String> = emptyList(),+ /** Number of catalog rows accepted by the staging/activation path during this execution. */+ val stagedMutations: Int = 0,+ /** Durable work that was handed off before this plan returned. */+ val continuationWork: List<SyncContinuation> = emptyList(),+ /** What happened to the active catalog; executors commit before returning this receipt. */+ val activation: SyncActivation = SyncActivation.NO_CATALOG_CHANGE+)++internal data class SyncContinuation(+ val operation: SyncContinuationOperation,+ val section: ContentType? = null,+ val reason: String,+ val force: Boolean = false)+internal enum class SyncContinuationOperation {+ INDEX_CATALOG,+ REFRESH_GUIDE+}++internal enum class SyncActivation {+ /** A staged snapshot (or safe staged subset) was promoted before the executor returned. */+ ACTIVATED_CATALOG,+ /** The operation completed successfully without changing catalog activation. */+ NO_CATALOG_CHANGE,+ /** Existing active rows were deliberately retained because a replacement was not safe. */+ PRESERVED_ACTIVE_CATALOG,+ /** No replacement was activated; declared durable work must finish the requested section. */+ DEFERRED_TO_FOLLOW_UP+}++internal object SyncActivationPolicy {+ fun validate(outcome: SyncOutcome): SyncOutcome {+ require(outcome.stagedMutations >= 0) {+ "stagedMutations must be non-negative"+ }+ if (outcome.activation == SyncActivation.DEFERRED_TO_FOLLOW_UP) {+ require(outcome.continuationWork.isNotEmpty()) {+ "DEFERRED_TO_FOLLOW_UP outcomes must declare continuation work"+ }+ }+ if (outcome.stagedMutations > 0) {+ require(outcome.activation == SyncActivation.ACTIVATED_CATALOG) {+ "staged mutations must be reported as an activated catalog"+ }+ }+ return outcome+ }+}++internal val SyncOutcome.requiresPartialActivation: Boolean+ get() = partial ||+ activation == SyncActivation.PRESERVED_ACTIVE_CATALOG ||+ activation == SyncActivation.DEFERRED_TO_FOLLOW_UP+internal sealed interface CatalogStrategyResult<out T> {val strategyName: Stringdiff --git a/data/src/main/java/com/streamvault/data/sync/SyncProviderSnapshotAdapter.kt b/data/src/main/java/com/streamvault/data/sync/SyncProviderSnapshotAdapter.ktnew file mode 100644index 00000000..551c5065--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/SyncProviderSnapshotAdapter.kt@@ -0,0 +1,28 @@+package com.streamvault.data.sync++import com.streamvault.data.provider.toLegacyProvider+import com.streamvault.data.provider.toProviderSnapshot+import com.streamvault.domain.model.LegacyProvider+import com.streamvault.domain.model.ProviderSnapshot+import com.streamvault.domain.repository.ProviderSnapshotRepository++/**+ * Owns the temporary schema-cutover projection used by the remaining sync adapters.+ *+ * The coordinator and manager exchange [ProviderSnapshot] values. Legacy projections are kept+ * at the adapter edge until the provider-specific executors finish migrating their low-level+ * ports, so the façade does not become the compatibility conversion site again.+ */+internal class SyncProviderSnapshotAdapter(+ private val snapshots: ProviderSnapshotRepository?+) {+ suspend fun getSnapshot(providerId: Long): ProviderSnapshot? =+ snapshots?.getSnapshot(providerId)++ suspend fun getLegacyProvider(providerId: Long): LegacyProvider? =+ getSnapshot(providerId)?.toLegacyProvider()++ fun toSnapshot(provider: LegacyProvider): ProviderSnapshot = provider.toProviderSnapshot()++ fun toLegacyProvider(snapshot: ProviderSnapshot): LegacyProvider = snapshot.toLegacyProvider()+}diff --git a/data/src/main/java/com/streamvault/data/sync/SyncStateMachine.kt b/data/src/main/java/com/streamvault/data/sync/SyncStateMachine.ktnew file mode 100644index 00000000..62a3d077--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/SyncStateMachine.kt@@ -0,0 +1,25 @@+package com.streamvault.data.sync++import com.streamvault.domain.model.SyncState++/**+ * The single transition policy for provider sync status.+ *+ * A terminal status can only be replaced by a new run (Syncing), reset (Idle),+ * or another value of the same terminal kind. This prevents a stale callback+ * from silently changing a completed run into a different terminal outcome.+ */+internal class SyncStateMachine {+ fun transition(current: SyncState, requested: SyncState): SyncState {+ if (current is SyncState.Idle || current is SyncState.Syncing) {+ return requested+ }+ if (requested is SyncState.Idle || requested is SyncState.Syncing) {+ return requested+ }+ require(current::class == requested::class) {+ "Invalid sync state transition: ${current::class.simpleName} -> ${requested::class.simpleName}"+ }+ return requested+ }+}diff --git a/data/src/main/java/com/streamvault/data/sync/SyncStateTracker.kt b/data/src/main/java/com/streamvault/data/sync/SyncStateTracker.ktindex 35aa7c17..a056395a 100644--- a/data/src/main/java/com/streamvault/data/sync/SyncStateTracker.kt+++ b/data/src/main/java/com/streamvault/data/sync/SyncStateTracker.kt@@ -9,6 +9,10 @@ import kotlinx.coroutines.flow.SharingStartedimport kotlinx.coroutines.flow.updateimport kotlinx.coroutines.CoroutineScopeimport kotlinx.coroutines.Dispatchers+import java.util.concurrent.atomic.AtomicLong++/** Identifies one provider sync run for status publication. */+internal data class SyncStateSession(val providerId: Long, val epoch: Long)internal class SyncStateTracker {private data class ProviderStateSnapshot(@@ -17,6 +21,10 @@ internal class SyncStateTracker {)private val scope = CoroutineScope(Dispatchers.Default)+ private val stateMachine = SyncStateMachine()+ private val nextEpoch = AtomicLong(0L)+ private val lock = Any()+ private val activeSessions = mutableMapOf<Long, SyncStateSession>()private val providerSnapshots = MutableStateFlow<Map<Long, ProviderStateSnapshot>>(emptyMap())val statesByProvider: StateFlow<Map<Long, SyncState>> = providerSnapshots@@ -29,18 +37,45 @@ internal class SyncStateTracker {fun current(providerId: Long): SyncState = providerSnapshots.value[providerId]?.state ?: SyncState.Idle- fun publish(providerId: Long, state: SyncState) {- providerSnapshots.update { snapshots ->- snapshots + (providerId to ProviderStateSnapshot(state))+ fun begin(providerId: Long): SyncStateSession {+ val session = SyncStateSession(providerId, nextEpoch.incrementAndGet())+ synchronized(lock) {+ activeSessions[providerId] = session+ }+ return session+ }++ /** Returns false when a stale run attempts to publish after replacement. */+ fun publish(session: SyncStateSession, state: SyncState): Boolean {+ synchronized(lock) {+ if (activeSessions[session.providerId] != session) return false+ providerSnapshots.update { snapshots ->+ val current = snapshots[session.providerId]?.state ?: SyncState.Idle+ snapshots + (+ session.providerId to ProviderStateSnapshot(+ stateMachine.transition(current, state)+ )+ )+ }+ return true+ }+ }++ fun finish(session: SyncStateSession) {+ synchronized(lock) {+ activeSessions.remove(session.providerId, session)}}fun reset(providerId: Long? = null) {- providerSnapshots.update { snapshots ->+ synchronized(lock) {if (providerId == null) {- emptyMap()+ activeSessions.clear()} else {- snapshots - providerId+ activeSessions.remove(providerId)+ }+ providerSnapshots.update { snapshots ->+ if (providerId == null) emptyMap() else snapshots - providerId}}}diff --git a/data/src/main/java/com/streamvault/data/sync/SyncStatusPublicationCoordinator.kt b/data/src/main/java/com/streamvault/data/sync/SyncStatusPublicationCoordinator.ktnew file mode 100644index 00000000..46112dfd--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/SyncStatusPublicationCoordinator.kt@@ -0,0 +1,134 @@+package com.streamvault.data.sync++import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.SyncMetadata+import com.streamvault.domain.model.SyncState+import com.streamvault.domain.model.VodSyncMode+import com.streamvault.domain.repository.SyncMetadataRepository+import com.streamvault.domain.sync.SyncProgress+import kotlinx.coroutines.flow.StateFlow+import java.util.concurrent.ConcurrentHashMap++/**+ * Owns provider-sync status and metadata publication.+ *+ * Catalog executors report durable summary outcomes here, while the manager retains only its+ * historical façade methods. State and progress sessions remain fenced by their respective+ * monotonic session owners, so a late worker cannot overwrite a newer manual run.+ */+internal class SyncStatusPublicationCoordinator(+ private val syncMetadataRepository: SyncMetadataRepository,+ private val syncProgressBus: SyncProgressBus,+ private val syncStateTracker: SyncStateTracker = SyncStateTracker()+) {+ val syncState: StateFlow<SyncState>+ get() = syncStateTracker.aggregateState++ val syncStatesByProvider: StateFlow<Map<Long, SyncState>>+ get() = syncStateTracker.statesByProvider++ private val stateSessions = ConcurrentHashMap<Long, SyncStateSession>()+ private val progressSessions = ConcurrentHashMap<Long, SyncProgressSession>()+ private val progressStateSessions = ConcurrentHashMap<SyncProgressSession, SyncStateSession>()++ fun currentSyncState(providerId: Long): SyncState = syncStateTracker.current(providerId)++ suspend fun updateStatus(providerId: Long, status: String) {+ val metadata = (syncMetadataRepository.getMetadata(providerId) ?: SyncMetadata(providerId))+ .copy(lastSyncStatus = status)+ syncMetadataRepository.updateMetadata(metadata)+ }++ suspend fun updateSummaryMetadata(+ providerId: Long,+ contentType: ContentType,+ indexedRows: Int,+ finalState: String,+ now: Long,+ movieSyncMode: VodSyncMode+ ) {+ val metadata = syncMetadataRepository.getMetadata(providerId) ?: SyncMetadata(providerId)+ when (contentType) {+ ContentType.MOVIE -> syncMetadataRepository.updateMetadata(+ metadata.copy(+ lastMovieSync = now,+ lastMovieAttempt = now,+ lastMovieSuccess = if (finalState == "SUCCESS") now else metadata.lastMovieSuccess,+ lastMoviePartial = if (finalState != "SUCCESS") now else metadata.lastMoviePartial,+ movieCount = if (finalState == "SUCCESS") indexedRows else metadata.movieCount.coerceAtLeast(indexedRows),+ movieCatalogStale = finalState != "SUCCESS",+ movieSyncMode = movieSyncMode+ )+ )+ ContentType.SERIES -> syncMetadataRepository.updateMetadata(+ metadata.copy(+ lastSeriesSync = now,+ lastSeriesSuccess = if (finalState == "SUCCESS") now else metadata.lastSeriesSuccess,+ seriesCount = if (finalState == "SUCCESS") indexedRows else metadata.seriesCount.coerceAtLeast(indexedRows)+ )+ )+ else -> Unit+ }+ }++ suspend fun markMovieIndexRebuildAttempt(providerId: Long, now: Long) {+ val metadata = syncMetadataRepository.getMetadata(providerId) ?: SyncMetadata(providerId)+ syncMetadataRepository.updateMetadata(+ metadata.copy(+ lastMovieAttempt = now,+ movieCatalogStale = true,+ movieSyncMode = VodSyncMode.UNKNOWN+ )+ )+ }++ fun publish(providerId: Long, state: SyncState) {+ stateSessions[providerId]?.let { session ->+ syncStateTracker.publish(session, state)+ }+ }++ fun progress(providerId: Long, callback: ((String) -> Unit)?, message: String) {+ publish(providerId, SyncState.Syncing(message))+ callback?.invoke(message)+ }++ fun beginStateSession(providerId: Long): SyncStateSession =+ syncStateTracker.begin(providerId).also { stateSessions[providerId] = it }++ fun finishStateSession(session: SyncStateSession) {+ stateSessions.remove(session.providerId, session)+ syncStateTracker.finish(session)+ }++ fun beginProgressSession(providerId: Long): SyncProgressSession {+ val stateSession = beginStateSession(providerId)+ return syncProgressBus.begin(providerId).also { progressSession ->+ progressSessions[providerId] = progressSession+ progressStateSessions[progressSession] = stateSession+ }+ }++ fun finishProgressSession(session: SyncProgressSession) {+ progressSessions.remove(session.providerId, session)+ syncProgressBus.finish(session)+ progressStateSessions.remove(session)?.let(::finishStateSession)+ }++ fun emitProgress(providerId: Long, progress: SyncProgress) {+ progressSessions[providerId]?.let { session -> syncProgressBus.emit(session, progress) }+ }++ fun reset(providerId: Long? = null) {+ if (providerId == null) {+ stateSessions.clear()+ progressSessions.clear()+ progressStateSessions.clear()+ } else {+ stateSessions.remove(providerId)+ progressSessions.remove(providerId)+ progressStateSessions.keys.removeIf { it.providerId == providerId }+ }+ syncStateTracker.reset(providerId)+ }+}diff --git a/data/src/main/java/com/streamvault/data/sync/VodCategoryHydrationCoordinator.kt b/data/src/main/java/com/streamvault/data/sync/VodCategoryHydrationCoordinator.ktnew file mode 100644index 00000000..a17370c7--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/VodCategoryHydrationCoordinator.kt@@ -0,0 +1,489 @@+package com.streamvault.data.sync++import com.streamvault.data.local.DatabaseTransactionRunner+import com.streamvault.data.local.dao.CategoryDao+import com.streamvault.data.local.dao.MovieCategoryHydrationDao+import com.streamvault.data.local.dao.MovieDao+import com.streamvault.data.local.dao.SeriesCategoryHydrationDao+import com.streamvault.data.local.dao.SeriesDao+import com.streamvault.data.local.dao.VodCategoryHydrationDao+import com.streamvault.data.local.dao.VodCatalogEntryDao+import com.streamvault.data.local.entity.CategoryEntity+import com.streamvault.data.local.entity.MovieCategoryHydrationEntity+import com.streamvault.data.local.entity.SeriesCategoryHydrationEntity+import com.streamvault.data.local.entity.VodCategoryHydrationEntity+import com.streamvault.data.local.entity.VodCatalogEntryEntity+import com.streamvault.data.mapper.toEntity+import com.streamvault.data.remote.stalker.StalkerProvider+import com.streamvault.domain.model.CatalogLayout+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.LegacyProvider as Provider+import com.streamvault.domain.model.ProviderType+import com.streamvault.domain.model.Result+import com.streamvault.domain.model.SeriesCatalogOrigin+import com.streamvault.domain.model.VodCatalogItem+import com.streamvault.domain.model.VodCategoryHydrationRequest+import kotlinx.coroutines.flow.first++private const val STALKER_COMPLETE_PAGE_BATCH_SIZE = 200+private const val STALKER_CATEGORY_RETRY_BUDGET = 3++/**+ * Owns interactive Stalker VOD category hydration and its page-level commit rules.+ *+ * The manager still exposes the historical methods used by repositories, but it no longer+ * owns category paging, derived-series protection, or hydration checkpoint writes.+ */+internal class VodCategoryHydrationCoordinator(+ private val providerSyncLocks: ProviderSyncLockRegistry,+ private val categoryDao: CategoryDao,+ private val movieCategoryHydrationDao: MovieCategoryHydrationDao,+ private val seriesCategoryHydrationDao: SeriesCategoryHydrationDao,+ private val vodCategoryHydrationDao: VodCategoryHydrationDao,+ private val movieDao: MovieDao,+ private val seriesDao: SeriesDao,+ private val vodCatalogEntryDao: VodCatalogEntryDao,+ private val transactionRunner: DatabaseTransactionRunner,+ private val loadProvider: suspend (Long) -> Provider?,+ private val createProvider: (Provider) -> StalkerProvider+) {+ suspend fun hydrateUnifiedVodCategory(+ providerId: Long,+ categoryId: Long,+ request: VodCategoryHydrationRequest+ ): Result<Unit> {+ val requestedPage = if (request == VodCategoryHydrationRequest.NEXT_PAGE) {+ ((vodCategoryHydrationDao.get(providerId, categoryId)?.lastSuccessfulPage ?: 0) + 1)+ .coerceAtLeast(1)+ } else {+ null+ }+ return providerSyncLocks.withVodCategoryLock(+ providerId = providerId,+ categoryId = categoryId,+ splitCatalog = false+ ) {+ val provider = loadProvider(providerId)+ ?: return@withVodCategoryLock Result.error("Provider not found")+ if (provider.type != ProviderType.STALKER_PORTAL) {+ return@withVodCategoryLock Result.success(Unit)+ }+ val current = vodCategoryHydrationDao.get(providerId, categoryId)+ if (current?.isComplete == true ||+ (requestedPage != null && current != null && current.lastSuccessfulPage >= requestedPage) ||+ (request == VodCategoryHydrationRequest.OPEN && (current?.lastSuccessfulPage ?: 0) > 0)+ ) {+ return@withVodCategoryLock Result.success(Unit)+ }++ val api = createProvider(provider)+ var hydration = current+ var nextPage = ((current?.lastSuccessfulPage ?: 0) + 1).coerceAtLeast(1)+ var remotePagesRequested = 0+ val seenPageFingerprints = mutableSetOf<String>()+ while (true) {+ val attemptAt = System.currentTimeMillis()+ if (request == VodCategoryHydrationRequest.COMPLETE &&+ remotePagesRequested >= STALKER_COMPLETE_PAGE_BATCH_SIZE+ ) {+ break+ }+ remotePagesRequested += 1+ vodCategoryHydrationDao.upsert(+ (hydration ?: VodCategoryHydrationEntity(providerId, categoryId)).copy(+ lastAttemptedPage = nextPage,+ lastStatus = "RUNNING",+ lastError = null+ )+ )+ when (val pageResult = api.getUnifiedVodPage(categoryId, nextPage)) {+ is Result.Success -> {+ val page = pageResult.data+ if (+ hydration?.advertisedTotalPages != null &&+ page.advertisedTotalPages != null &&+ hydration?.advertisedTotalPages != page.advertisedTotalPages+ ) {+ val prior = hydration ?: VodCategoryHydrationEntity(providerId, categoryId)+ hydration = prior.copy(+ lastAttemptedPage = page.page,+ lastStatus = "ANOMALY",+ lastError = "Portal changed its advertised catalog page count while loading.",+ retryAfterMs = 0L+ )+ vodCategoryHydrationDao.upsert(hydration!!)+ return@withVodCategoryLock Result.error(+ hydration!!.lastError ?: "Portal changed its advertised page count"+ )+ }+ val pageFingerprint = page.items.joinToString("|") { it.rawItemId }+ .takeIf(String::isNotEmpty)+ if (pageFingerprint != null && !seenPageFingerprints.add(pageFingerprint)) {+ val prior = hydration ?: VodCategoryHydrationEntity(providerId, categoryId)+ hydration = prior.copy(+ lastAttemptedPage = page.page,+ lastStatus = "ANOMALY",+ lastError = "Portal repeated a catalog page while loading page ${page.page}.",+ retryAfterMs = 0L+ )+ vodCategoryHydrationDao.upsert(hydration!!)+ return@withVodCategoryLock Result.error(+ hydration!!.lastError ?: "Portal repeated a catalog page"+ )+ }+ val category = categoryDao.getByProviderAndTypeSync(providerId, ContentType.VOD.name)+ .firstOrNull { it.categoryId == categoryId }+ val protected = category?.isUserProtected == true+ val movies = page.items.mapNotNull { entry ->+ (entry.item as? VodCatalogItem.MovieItem)?.movie+ ?.copy(isUserProtected = protected)+ ?.toEntity()+ }+ val series = page.items.mapNotNull { entry ->+ (entry.item as? VodCatalogItem.SeriesItem)?.series+ ?.copy(isUserProtected = protected)+ ?.toEntity()+ }+ val entries = page.items.mapIndexed { rawIndex, entry ->+ when (val item = entry.item) {+ is VodCatalogItem.MovieItem -> VodCatalogEntryEntity(+ providerId = providerId,+ categoryId = categoryId,+ rawItemId = entry.rawItemId,+ itemType = ContentType.MOVIE,+ targetId = item.movie.streamId,+ rawPage = page.page,+ rawIndex = rawIndex+ )+ is VodCatalogItem.SeriesItem -> VodCatalogEntryEntity(+ providerId = providerId,+ categoryId = categoryId,+ rawItemId = entry.rawItemId,+ itemType = ContentType.SERIES,+ targetId = item.series.seriesId,+ rawPage = page.page,+ rawIndex = rawIndex+ )+ }+ }+ val pageLimitReached = request == VodCategoryHydrationRequest.COMPLETE &&+ remotePagesRequested >= STALKER_COMPLETE_PAGE_BATCH_SIZE &&+ !page.isComplete+ val truncated = page.isTruncated || pageLimitReached+ val pageComplete = page.isComplete && !truncated+ val terminationReason = page.terminationReason+ ?: "page_limit".takeIf { pageLimitReached }+ transactionRunner.inTransaction {+ movieDao.upsertCategoryPage(providerId, movies)+ seriesDao.upsertCategoryPage(providerId, series)+ vodCatalogEntryDao.replacePage(providerId, categoryId, page.page, entries)+ val persistedCount = vodCatalogEntryDao.countByCategory(providerId, categoryId)+ hydration = VodCategoryHydrationEntity(+ providerId = providerId,+ categoryId = categoryId,+ lastLoadedPage = page.page,+ lastAttemptedPage = page.page,+ lastSuccessfulPage = page.page,+ totalPages = page.totalPages,+ advertisedTotalItems = page.advertisedTotalItems,+ advertisedTotalPages = page.advertisedTotalPages,+ pageSize = page.pageSize,+ itemCount = persistedCount,+ isComplete = pageComplete,+ hasMovies = (hydration?.hasMovies == true) || movies.isNotEmpty(),+ hasSeries = (hydration?.hasSeries == true) || series.isNotEmpty(),+ lastHydratedAt = attemptAt,+ lastStatus = if (truncated) "TRUNCATED" else "SUCCESS",+ lastError = terminationReason,+ retryAfterMs = 0L,+ failureCount = 0,+ retryBudgetRemaining = STALKER_CATEGORY_RETRY_BUDGET,+ lastPageFingerprint = pageFingerprint+ )+ vodCategoryHydrationDao.upsert(hydration!!)+ }+ if (truncated) {+ return@withVodCategoryLock Result.error(+ terminationReason ?: "VOD response was truncated"+ )+ }+ if (pageComplete || request != VodCategoryHydrationRequest.COMPLETE) {+ return@withVodCategoryLock Result.success(Unit)+ }+ nextPage = page.page + 1+ }+ is Result.Error -> {+ val prior = hydration ?: VodCategoryHydrationEntity(providerId, categoryId)+ hydration = prior.copy(+ lastAttemptedPage = nextPage,+ lastStatus = "FAILED_RETRYABLE",+ lastError = pageResult.message,+ failureCount = prior.failureCount + 1,+ retryBudgetRemaining = (prior.retryBudgetRemaining - 1).coerceAtLeast(0)+ )+ vodCategoryHydrationDao.upsert(hydration!!)+ return@withVodCategoryLock Result.error(pageResult.message, pageResult.exception)+ }+ Result.Loading -> return@withVodCategoryLock Result.error("VOD hydration did not complete")+ }+ }+ @Suppress("UNREACHABLE_CODE")+ Result.success(Unit)+ }+ }++ suspend fun hydrateSplitVodCategory(+ providerId: Long,+ movieCategoryId: Long,+ request: VodCategoryHydrationRequest,+ requestedProjection: ContentType = ContentType.MOVIE+ ): Result<Unit> {+ val requestedPage = if (request == VodCategoryHydrationRequest.NEXT_PAGE) {+ ((movieCategoryHydrationDao.get(providerId, movieCategoryId)?.lastSuccessfulPage ?: 0) + 1)+ .coerceAtLeast(1)+ } else {+ null+ }+ return providerSyncLocks.withVodCategoryLock(+ providerId = providerId,+ categoryId = movieCategoryId,+ splitCatalog = true+ ) {+ val provider = loadProvider(providerId)+ ?: return@withVodCategoryLock Result.error("Provider not found")+ if (provider.type != ProviderType.STALKER_PORTAL || provider.catalogLayout != CatalogLayout.SPLIT) {+ return@withVodCategoryLock Result.success(Unit)+ }+ var hydration = movieCategoryHydrationDao.get(providerId, movieCategoryId)+ var movieCount = movieDao.getCountByCategory(providerId, movieCategoryId).first()+ if (hydration?.isComplete == true ||+ (requestedPage != null && hydration != null && hydration.lastSuccessfulPage >= requestedPage) ||+ (request == VodCategoryHydrationRequest.OPEN && (hydration?.lastSuccessfulPage ?: 0) > 0)+ ) {+ return@withVodCategoryLock Result.success(Unit)+ }+ val api = createProvider(provider)+ val movieCategory = categoryDao.getByProviderAndTypeSync(providerId, ContentType.MOVIE.name)+ .firstOrNull { it.categoryId == movieCategoryId }+ ?: return@withVodCategoryLock Result.error("Movie category not found")+ // Populate the provider's category identity cache before translating it to Series.+ api.getVodCategories()+ val seriesCategoryId = api.projectVodCategoryToSeries(movieCategoryId)+ ?: return@withVodCategoryLock Result.error("Unable to resolve VOD-derived Series category")+ val initialProjectionCount = when (requestedProjection) {+ ContentType.SERIES -> seriesDao.getCountByCategory(providerId, seriesCategoryId).first()+ else -> movieCount+ }+ var nextPage = ((hydration?.lastSuccessfulPage ?: 0) + 1).coerceAtLeast(1)+ var remotePagesRequested = 0+ val seenPageFingerprints = mutableSetOf<String>()+ while (true) {+ val attemptAt = System.currentTimeMillis()+ if (request == VodCategoryHydrationRequest.COMPLETE &&+ remotePagesRequested >= STALKER_COMPLETE_PAGE_BATCH_SIZE+ ) {+ break+ }+ remotePagesRequested += 1+ movieCategoryHydrationDao.upsert(+ (hydration ?: MovieCategoryHydrationEntity(providerId, movieCategoryId)).copy(+ lastAttemptedPage = nextPage,+ lastStatus = "RUNNING",+ lastError = null+ )+ )+ seriesCategoryHydrationDao.get(providerId, seriesCategoryId)?.let { seriesHydration ->+ seriesCategoryHydrationDao.upsert(+ seriesHydration.copy(+ lastAttemptedPage = nextPage,+ lastStatus = "RUNNING",+ lastError = null+ )+ )+ }+ when (val pageResult = api.getSplitVodPage(movieCategoryId, seriesCategoryId, nextPage)) {+ is Result.Success -> {+ val page = pageResult.data+ if (+ hydration?.advertisedTotalPages != null &&+ page.advertisedTotalPages != null &&+ hydration?.advertisedTotalPages != page.advertisedTotalPages+ ) {+ val prior = hydration ?: MovieCategoryHydrationEntity(providerId, movieCategoryId)+ hydration = prior.copy(+ lastAttemptedPage = page.page,+ lastStatus = "ANOMALY",+ lastError = "Portal changed its advertised catalog page count while loading.",+ retryAfterMs = 0L+ )+ movieCategoryHydrationDao.upsert(hydration!!)+ return@withVodCategoryLock Result.error(+ hydration!!.lastError ?: "Portal changed its advertised page count"+ )+ }+ val pageFingerprint = page.items.joinToString("|") { it.rawItemId }+ .takeIf(String::isNotEmpty)+ if (pageFingerprint != null && !seenPageFingerprints.add(pageFingerprint)) {+ val prior = hydration ?: MovieCategoryHydrationEntity(providerId, movieCategoryId)+ hydration = prior.copy(+ lastAttemptedPage = page.page,+ lastStatus = "ANOMALY",+ lastError = "Portal repeated a catalog page while loading page ${page.page}.",+ retryAfterMs = 0L+ )+ movieCategoryHydrationDao.upsert(hydration!!)+ return@withVodCategoryLock Result.error(+ hydration!!.lastError ?: "Portal repeated a catalog page"+ )+ }+ val movies = page.items.mapNotNull { (it.item as? VodCatalogItem.MovieItem)?.movie?.toEntity() }+ val incomingSeries = page.items.mapNotNull {+ (it.item as? VodCatalogItem.SeriesItem)?.series+ ?.copy(isUserProtected = movieCategory.isUserProtected)+ ?.toEntity()+ }+ val pageLimitReached = request == VodCategoryHydrationRequest.COMPLETE &&+ remotePagesRequested >= STALKER_COMPLETE_PAGE_BATCH_SIZE &&+ !page.isComplete+ val truncated = page.isTruncated || pageLimitReached+ val pageComplete = page.isComplete && !truncated+ val terminationReason = page.terminationReason+ ?: "page_limit".takeIf { pageLimitReached }+ val existingSeriesHydration = seriesCategoryHydrationDao.get(providerId, seriesCategoryId)+ transactionRunner.inTransaction {+ movieDao.upsertCategoryPage(providerId, movies)+ if (incomingSeries.isNotEmpty()) {+ categoryDao.insertAll(+ listOf(+ CategoryEntity(+ providerId = providerId,+ categoryId = seriesCategoryId,+ name = movieCategory.name,+ parentId = movieCategory.parentId,+ type = ContentType.SERIES,+ providerOrder = movieCategory.providerOrder,+ isAdult = movieCategory.isAdult,+ isUserProtected = movieCategory.isUserProtected+ )+ )+ )+ }+ // Check inside the same transaction as the write so a concurrent+ // native-Series refresh can never be replaced by derived VOD data.+ val existingSeries = seriesDao.getBySeriesIds(+ providerId,+ incomingSeries.map { it.seriesId }+ ).associateBy { it.seriesId }+ val derivedSeries = incomingSeries.filter { incoming ->+ existingSeries[incoming.seriesId]?.catalogOrigin != SeriesCatalogOrigin.NATIVE+ }+ seriesDao.upsertCategoryPage(providerId, derivedSeries)+ movieCount = movieDao.getCountByCategory(providerId, movieCategoryId).first()+ val seriesCount = seriesDao.getCountByCategory(providerId, seriesCategoryId).first()+ hydration = MovieCategoryHydrationEntity(+ providerId = providerId,+ categoryId = movieCategoryId,+ lastHydratedAt = attemptAt,+ itemCount = movieCount,+ lastStatus = if (truncated) "TRUNCATED" else "SUCCESS",+ lastError = terminationReason,+ lastLoadedPage = page.page,+ lastAttemptedPage = page.page,+ lastSuccessfulPage = page.page,+ totalPages = page.totalPages,+ advertisedTotalItems = page.advertisedTotalItems,+ advertisedTotalPages = page.advertisedTotalPages,+ isComplete = pageComplete,+ pageSize = page.pageSize,+ retryBudgetRemaining = STALKER_CATEGORY_RETRY_BUDGET,+ lastPageFingerprint = pageFingerprint+ )+ movieCategoryHydrationDao.upsert(hydration!!)+ if (incomingSeries.isNotEmpty() || existingSeriesHydration != null) {+ seriesCategoryHydrationDao.upsert(+ SeriesCategoryHydrationEntity(+ providerId = providerId,+ categoryId = seriesCategoryId,+ lastHydratedAt = attemptAt,+ itemCount = seriesCount,+ lastStatus = if (truncated) "TRUNCATED" else "SUCCESS",+ lastError = terminationReason,+ lastLoadedPage = page.page,+ lastAttemptedPage = page.page,+ lastSuccessfulPage = page.page,+ totalPages = page.totalPages,+ advertisedTotalItems = page.advertisedTotalItems,+ advertisedTotalPages = page.advertisedTotalPages,+ isComplete = pageComplete,+ pageSize = page.pageSize,+ retryBudgetRemaining = STALKER_CATEGORY_RETRY_BUDGET,+ lastPageFingerprint = pageFingerprint+ )+ )+ }+ }+ if (truncated) {+ return@withVodCategoryLock Result.error(+ terminationReason ?: "VOD response was truncated"+ )+ }+ val projectionCount = when (requestedProjection) {+ ContentType.SERIES -> seriesDao.getCountByCategory(providerId, seriesCategoryId).first()+ else -> movieCount+ }+ if (pageComplete ||+ (request != VodCategoryHydrationRequest.COMPLETE &&+ projectionCount > initialProjectionCount)+ ) {+ return@withVodCategoryLock Result.success(Unit)+ }+ nextPage = page.page + 1+ }+ is Result.Error -> {+ val prior = hydration ?: MovieCategoryHydrationEntity(providerId, movieCategoryId)+ movieCategoryHydrationDao.upsert(+ prior.copy(+ lastAttemptedPage = nextPage,+ lastStatus = "FAILED_RETRYABLE",+ lastError = pageResult.message,+ failureCount = prior.failureCount + 1,+ retryBudgetRemaining = (prior.retryBudgetRemaining - 1).coerceAtLeast(0)+ )+ )+ seriesCategoryHydrationDao.get(providerId, seriesCategoryId)?.let { seriesHydration ->+ seriesCategoryHydrationDao.upsert(+ seriesHydration.copy(+ lastAttemptedPage = nextPage,+ lastStatus = "FAILED_RETRYABLE",+ lastError = pageResult.message,+ failureCount = seriesHydration.failureCount + 1,+ retryBudgetRemaining = (seriesHydration.retryBudgetRemaining - 1).coerceAtLeast(0)+ )+ )+ }+ return@withVodCategoryLock Result.error(pageResult.message, pageResult.exception)+ }+ Result.Loading -> return@withVodCategoryLock Result.error("Split VOD hydration did not complete")+ }+ }+ @Suppress("UNREACHABLE_CODE")+ Result.success(Unit)+ }+ }++ suspend fun hydrateSplitVodSeriesCategory(+ providerId: Long,+ seriesCategoryId: Long,+ request: VodCategoryHydrationRequest+ ): Result<Unit> {+ val provider = loadProvider(providerId) ?: return Result.error("Provider not found")+ if (provider.type != ProviderType.STALKER_PORTAL || provider.catalogLayout != CatalogLayout.SPLIT) {+ return Result.success(Unit)+ }+ val api = createProvider(provider)+ api.getSeriesCategories()+ val movieCategoryId = api.projectSeriesCategoryToVod(seriesCategoryId)+ ?: return Result.error("Unable to resolve VOD category for derived Series")+ return hydrateSplitVodCategory(providerId, movieCategoryId, request, ContentType.SERIES)+ }+}diff --git a/data/src/main/java/com/streamvault/data/sync/XtreamCatalogSectionExecutor.kt b/data/src/main/java/com/streamvault/data/sync/XtreamCatalogSectionExecutor.ktnew file mode 100644index 00000000..2ff8f303--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/XtreamCatalogSectionExecutor.kt@@ -0,0 +1,143 @@+package com.streamvault.data.sync++import android.util.Log+import com.streamvault.data.mapper.toEntity+import com.streamvault.data.preferences.PreferencesRepository+import com.streamvault.data.remote.xtream.XtreamProvider+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.LegacyProvider as Provider+import com.streamvault.domain.model.Result+import com.streamvault.domain.model.SyncMetadata+import com.streamvault.domain.model.VodSyncMode+import com.streamvault.domain.repository.SyncMetadataRepository+import kotlinx.coroutines.flow.first++/** Owns Xtream category-shell and movie/series repair orchestration. */+internal class XtreamCatalogSectionExecutor(+ private val preferencesRepository: PreferencesRepository,+ private val syncMetadataRepository: SyncMetadataRepository,+ private val syncCatalogStore: SyncCatalogStore,+ private val createProvider: suspend (Provider, Boolean, Boolean) -> XtreamProvider,+ private val markIndexRunning: suspend (Long, ContentType, Long) -> Unit,+ private val markIndexQueued: suspend (Long, ContentType, Long, Int) -> Unit,+ private val markIndexFailure: suspend (Long, ContentType, Long, Throwable) -> Unit,+ private val progress: (Long, ((String) -> Unit)?, String) -> Unit,+ private val sanitizeThrowableMessage: (Throwable) -> String,+ private val userMessage: (Throwable, String) -> String+) {+ suspend fun syncCategoryShell(+ provider: Provider,+ api: XtreamProvider,+ contentType: ContentType,+ label: String,+ now: Long,+ onProgress: ((String) -> Unit)?+ ): kotlin.Result<Int> = runCatching {+ progress(provider.id, onProgress, "Loading $label categories...")+ markIndexRunning(provider.id, contentType, now)+ val categories = when (contentType) {+ ContentType.MOVIE -> requireResult(api.getVodCategories(), "Failed to load VOD categories")+ ContentType.SERIES -> requireResult(api.getSeriesCategories(), "Failed to load series categories")+ else -> throw IllegalArgumentException("Unsupported Xtream category shell: $contentType")+ }+ syncCatalogStore.upsertCategories(+ providerId = provider.id,+ type = contentType.name,+ categories = categories.map { category -> category.toEntity(provider.id) }+ )+ markIndexQueued(provider.id, contentType, now, categories.size)+ categories.size+ }++ suspend fun syncMovies(+ provider: Provider,+ onProgress: ((String) -> Unit)?+ ): SyncOutcome {+ val now = System.currentTimeMillis()+ progress(provider.id, onProgress, "Queueing Movies index...")+ val useTextClassification = preferencesRepository.useXtreamTextClassification.first()+ val enableBase64TextCompatibility = preferencesRepository.xtreamBase64TextCompatibility.first()+ val api = createProvider(provider, useTextClassification, enableBase64TextCompatibility)+ val currentMetadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)+ val categoryCount = syncCategoryShell(+ provider = provider,+ api = api,+ contentType = ContentType.MOVIE,+ label = "Movies",+ now = now,+ onProgress = onProgress+ ).getOrElse { error ->+ markIndexFailure(provider.id, ContentType.MOVIE, now, error)+ throw IllegalStateException(+ userMessage(error, "Failed to queue movie index"),+ error+ )+ }+ syncMetadataRepository.updateMetadata(+ currentMetadata.copy(+ lastMovieAttempt = now,+ movieCatalogStale = true,+ movieSyncMode = VodSyncMode.UNKNOWN+ )+ )+ Log.i(TAG, "Queued Xtream movie index for provider ${provider.id}: $categoryCount categories.")+ return SyncOutcome(+ continuationWork = listOf(+ SyncContinuation(+ operation = SyncContinuationOperation.INDEX_CATALOG,+ section = ContentType.MOVIE,+ reason = "movie category shell is committed; durable item indexing is queued"+ )+ ),+ activation = SyncActivation.DEFERRED_TO_FOLLOW_UP+ )+ }++ suspend fun syncSeries(+ provider: Provider,+ onProgress: ((String) -> Unit)?+ ): SyncOutcome {+ val now = System.currentTimeMillis()+ progress(provider.id, onProgress, "Queueing Series index...")+ val useTextClassification = preferencesRepository.useXtreamTextClassification.first()+ val enableBase64TextCompatibility = preferencesRepository.xtreamBase64TextCompatibility.first()+ val api = createProvider(provider, useTextClassification, enableBase64TextCompatibility)+ val currentMetadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)+ val categoryCount = syncCategoryShell(+ provider = provider,+ api = api,+ contentType = ContentType.SERIES,+ label = "Series",+ now = now,+ onProgress = onProgress+ ).getOrElse { error ->+ markIndexFailure(provider.id, ContentType.SERIES, now, error)+ throw IllegalStateException(+ userMessage(error, "Failed to queue series index"),+ error+ )+ }+ syncMetadataRepository.updateMetadata(currentMetadata.copy(lastSeriesSync = now))+ Log.i(TAG, "Queued Xtream series index for provider ${provider.id}: $categoryCount categories.")+ return SyncOutcome(+ continuationWork = listOf(+ SyncContinuation(+ operation = SyncContinuationOperation.INDEX_CATALOG,+ section = ContentType.SERIES,+ reason = "series category shell is committed; durable item indexing is queued"+ )+ ),+ activation = SyncActivation.DEFERRED_TO_FOLLOW_UP+ )+ }++ private fun <T> requireResult(result: Result<T>, fallbackMessage: String): T = when (result) {+ is Result.Success -> result.data+ is Result.Error -> throw IllegalStateException(result.message.ifBlank { fallbackMessage }, result.exception)+ is Result.Loading -> throw IllegalStateException("Unexpected loading state")+ }++ private companion object {+ const val TAG = "XtreamCatalogSection"+ }+}diff --git a/data/src/main/java/com/streamvault/data/sync/XtreamCatalogSyncExecutor.kt b/data/src/main/java/com/streamvault/data/sync/XtreamCatalogSyncExecutor.ktnew file mode 100644index 00000000..d3ad1e5d--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/XtreamCatalogSyncExecutor.kt@@ -0,0 +1,927 @@+package com.streamvault.data.sync++import android.content.Context+import android.util.Log+import com.streamvault.data.local.dao.CategoryDao+import com.streamvault.data.local.dao.ChannelDao+import com.streamvault.data.local.dao.XtreamLiveOnboardingDao+import com.streamvault.data.local.entity.CategoryEntity+import com.streamvault.data.local.entity.ChannelEntity+import com.streamvault.data.local.entity.XtreamLiveOnboardingStateEntity+import com.streamvault.data.mapper.toEntity+import com.streamvault.data.preferences.PreferencesRepository+import com.streamvault.data.remote.xtream.XtreamProvider+import com.streamvault.data.util.UrlSecurityPolicy+import com.streamvault.data.util.runSuspendCatching+import com.streamvault.domain.model.Channel+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.LegacyProvider as Provider+import com.streamvault.domain.model.ProviderEpgSyncMode+import com.streamvault.domain.model.ProviderType+import com.streamvault.domain.model.SyncMetadata+import com.streamvault.domain.model.VodSyncMode+import com.streamvault.domain.repository.SyncMetadataRepository+import com.streamvault.domain.sync.Section+import com.streamvault.domain.sync.SyncProgress+import kotlinx.coroutines.flow.first++/** The durable update emitted by Xtream catalog orchestration for an index job. */+internal data class XtreamIndexJobUpdate(+ val providerId: Long,+ val section: String,+ val state: String,+ val now: Long,+ val totalCategories: Int? = null,+ val completedCategories: Int? = null,+ val indexedRows: Int? = null,+ val lastAttemptAt: Long? = null,+ val lastError: String? = null+)++/**+ * Owns Xtream full-sync and Live repair orchestration.+ *+ * The live strategy and section executor remain separate collaborators. This class owns the+ * workflow around them: onboarding recovery, staged activation, metadata, durable job state,+ * and continuation scheduling.+ */+internal class XtreamCatalogSyncExecutor(+ private val applicationContext: Context,+ private val preferencesRepository: PreferencesRepository,+ private val syncMetadataRepository: SyncMetadataRepository,+ private val channelDao: ChannelDao,+ private val categoryDao: CategoryDao,+ private val xtreamLiveOnboardingDao: XtreamLiveOnboardingDao,+ private val syncCatalogStore: SyncCatalogStore,+ private val sectionExecutor: XtreamCatalogSectionExecutor,+ private val liveStrategy: SyncManagerXtreamLiveStrategy,+ private val catalogStrategySupport: SyncManagerCatalogStrategySupport,+ private val createProvider: suspend (Provider, Boolean, Boolean) -> XtreamProvider,+ private val updateIndexJob: suspend (XtreamIndexJobUpdate) -> Unit,+ private val indexFailureState: (Throwable) -> String,+ private val shouldRememberSequentialPreference: (Throwable) -> Boolean,+ private val progress: (Long, ((String) -> Unit)?, String) -> Unit,+ private val emitProgress: (Long, SyncProgress) -> Unit,+ private val sanitizeThrowableMessage: (Throwable?) -> String,+ private val userMessage: (Throwable, String) -> String+) {+ suspend fun syncFull(+ provider: Provider,+ force: Boolean,+ onProgress: ((String) -> Unit)?,+ trackInitialLiveOnboarding: Boolean = false,+ syncReason: XtreamLiveSyncReason = XtreamLiveSyncReason.FOREGROUND,+ afterCatalogApply: suspend () -> Unit = {}+ ): SyncOutcome {+ val warnings = mutableListOf<String>()+ val continuationWork = mutableListOf<SyncContinuation>()+ var activatedLiveMutations = 0+ var catalogActivated = false+ var preservedActiveCatalog = false+ UrlSecurityPolicy.validateXtreamServerUrl(provider.serverUrl)?.let { message ->+ throw IllegalStateException(message)+ }++ progress(provider.id, onProgress, "Connecting to server...")+ val useTextClassification = preferencesRepository.useXtreamTextClassification.first()+ val enableBase64TextCompatibility = preferencesRepository.xtreamBase64TextCompatibility.first()+ val hiddenLiveCategoryIds = preferencesRepository.getHiddenCategoryIds(provider.id, ContentType.LIVE).first()+ val api = createProvider(provider, useTextClassification, enableBase64TextCompatibility)+ val runtimeProfile = CatalogSyncRuntimeProfile.from(applicationContext)+ val now = System.currentTimeMillis()+ var metadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)++ if (trackInitialLiveOnboarding) {+ recordOnboardingState(+ provider = provider,+ phase = XTREAM_ONBOARDING_PHASE_STARTING,+ now = now,+ clearError = true,+ runtimeProfile = runtimeProfile+ )+ }++ updateIndexJob(+ XtreamIndexJobUpdate(+ providerId = provider.id,+ section = ContentType.LIVE.name,+ state = "RUNNING",+ now = now,+ lastAttemptAt = now+ )+ )+ val liveOutcome = runSuspendCatching {+ val recoveredLiveCommit = if (trackInitialLiveOnboarding) {+ recoverOnboardingSession(provider, hiddenLiveCategoryIds, afterCatalogApply)+ } else {+ null+ }+ if (recoveredLiveCommit != null) {+ warnings += recoveredLiveCommit.warnings+ val acceptedCount = recoveredLiveCommit.acceptedCount+ val completedAt = System.currentTimeMillis()+ recordOnboardingState(+ provider = provider,+ phase = XTREAM_ONBOARDING_PHASE_COMPLETED,+ now = completedAt,+ acceptedRowCount = acceptedCount,+ stagedFlushCount = stagedFlushCountFor(acceptedCount),+ clearError = true,+ completedAt = completedAt,+ clearStagedSession = true,+ runtimeProfile = runtimeProfile+ )+ metadata = metadata.copy(+ lastLiveSync = now,+ lastLiveSuccess = now,+ liveCount = acceptedCount+ )+ syncMetadataRepository.updateMetadata(metadata)+ activatedLiveMutations = acceptedCount+ catalogActivated = true+ return@runSuspendCatching acceptedCount+ }++ if (trackInitialLiveOnboarding) {+ recordOnboardingState(+ provider = provider,+ phase = XTREAM_ONBOARDING_PHASE_FETCHING,+ now = System.currentTimeMillis(),+ clearError = true,+ runtimeProfile = runtimeProfile+ )+ }+ progress(provider.id, onProgress, "Downloading Live TV...")+ val liveSyncResult = syncLiveCatalog(+ provider = provider,+ api = api,+ existingMetadata = metadata,+ hiddenLiveCategoryIds = hiddenLiveCategoryIds,+ onProgress = onProgress,+ runtimeProfile = runtimeProfile,+ trackInitialLiveOnboarding = trackInitialLiveOnboarding,+ syncReason = syncReason+ )+ if (trackInitialLiveOnboarding) {+ val stagedAcceptedCount = liveSyncResult.stagedAcceptedCount+ recordOnboardingState(+ provider = provider,+ phase = if (liveSyncResult.stagedSessionId != null) {+ XTREAM_ONBOARDING_PHASE_STAGED+ } else {+ XTREAM_ONBOARDING_PHASE_COMMITTING+ },+ now = System.currentTimeMillis(),+ stagedSessionId = liveSyncResult.stagedSessionId,+ importStrategy = liveSyncResult.catalogResult.strategyNameOrNull(),+ acceptedRowCount = stagedAcceptedCount,+ stagedFlushCount = stagedFlushCountFor(stagedAcceptedCount),+ clearError = true,+ runtimeProfile = runtimeProfile,+ syncProfileStrategy = liveSyncResult.profileStrategyName(runtimeProfile, trackInitialLiveOnboarding)+ )+ }+ val liveSequentialStress = liveSyncResult.strategyFeedback.segmentedStressDetected+ val liveProviderAdaptation = updateSequentialProviderAdaptation(+ previousRemembered = metadata.liveSequentialFailuresRemembered,+ previousHealthyStreak = metadata.liveHealthySyncStreak,+ sawSequentialStress = liveSequentialStress+ )+ val liveAvoidFullUntil = catalogStrategySupport.updateAvoidFullUntil(+ previousAvoidFullUntil = metadata.liveAvoidFullUntil,+ now = now,+ feedback = liveSyncResult.strategyFeedback+ )++ val acceptedCount = when (val liveResult = liveSyncResult.catalogResult) {+ is CatalogStrategyResult.Success -> {+ recordCommitPhaseIfNeeded(+ provider,+ liveSyncResult,+ liveResult.strategyName,+ runtimeProfile,+ trackInitialLiveOnboarding+ )+ finalizeLiveCatalog(+ providerId = provider.id,+ liveSyncResult = liveSyncResult,+ hiddenLiveCategoryIds = hiddenLiveCategoryIds,+ onProgress = onProgress,+ afterCatalogApply = afterCatalogApply+ ).also {+ warnings += it.warnings+ activatedLiveMutations = it.acceptedCount+ catalogActivated = true+ }.acceptedCount+ }+ is CatalogStrategyResult.Partial -> {+ recordCommitPhaseIfNeeded(+ provider,+ liveSyncResult,+ liveResult.strategyName,+ runtimeProfile,+ trackInitialLiveOnboarding+ )+ finalizeLiveCatalog(+ providerId = provider.id,+ liveSyncResult = liveSyncResult,+ hiddenLiveCategoryIds = hiddenLiveCategoryIds,+ onProgress = onProgress,+ partialCompletionWarning = "Live TV sync completed partially.",+ afterCatalogApply = afterCatalogApply+ ).also {+ warnings += it.warnings+ activatedLiveMutations = it.acceptedCount+ catalogActivated = true+ }.acceptedCount+ }+ is CatalogStrategyResult.EmptyValid -> {+ preservedActiveCatalog = true+ val existingChannelCount = channelDao.getCount(provider.id).first()+ warnings += liveSyncResult.warnings + liveResult.warnings + if (existingChannelCount == 0) {+ "Live TV provider exposed no live channels; continuing with VOD and series only."+ } else {+ "Live TV refresh returned an empty valid catalog; keeping previous channel library."+ }+ existingChannelCount+ }+ is CatalogStrategyResult.Failure -> {+ preservedActiveCatalog = true+ val existingChannelCount = channelDao.getCount(provider.id).first()+ warnings += liveSyncResult.warnings + liveResult.warnings + if (existingChannelCount == 0) {+ "Live TV could not be fetched; continuing with VOD and series only."+ } else {+ "Live TV sync degraded; keeping previous channel library."+ }+ existingChannelCount+ }+ }++ metadata = metadata.copy(+ lastLiveSync = now,+ lastLiveSuccess = now,+ liveCount = acceptedCount,+ liveAvoidFullUntil = liveAvoidFullUntil,+ liveSequentialFailuresRemembered = liveProviderAdaptation.rememberSequential,+ liveHealthySyncStreak = liveProviderAdaptation.healthyStreak+ )+ syncMetadataRepository.updateMetadata(metadata)+ acceptedCount+ }+ val liveCount = liveOutcome.getOrElse { error ->+ if (trackInitialLiveOnboarding) {+ recordOnboardingState(+ provider = provider,+ phase = XTREAM_ONBOARDING_PHASE_FAILED,+ lastError = sanitizeThrowableMessage(error),+ runtimeProfile = runtimeProfile+ )+ }+ updateIndexJob(+ XtreamIndexJobUpdate(+ providerId = provider.id,+ section = ContentType.LIVE.name,+ state = indexFailureState(error),+ now = now,+ lastAttemptAt = now,+ lastError = sanitizeThrowableMessage(error)+ )+ )+ throw error+ }+ updateIndexJob(+ XtreamIndexJobUpdate(+ providerId = provider.id,+ section = ContentType.LIVE.name,+ state = "QUEUED",+ now = now,+ totalCategories = 1,+ completedCategories = 0,+ indexedRows = liveCount,+ lastAttemptAt = now,+ lastError = null+ )+ )+ continuationWork += SyncContinuation(+ operation = SyncContinuationOperation.INDEX_CATALOG,+ section = ContentType.LIVE,+ reason = "activated live catalog requires durable search-index backfill"+ )+ emitProgress(+ provider.id,+ SyncProgress(+ section = Section.VOD,+ current = 0,+ total = 0,+ currentLabel = "",+ itemsIndexed = liveCount+ )+ )+ val movieCategoryCount = sectionExecutor.syncCategoryShell(+ provider = provider,+ api = api,+ contentType = ContentType.MOVIE,+ label = "Movies",+ now = now,+ onProgress = onProgress+ ).getOrElse { error ->+ warnings += "Movies categories could not be loaded; movie indexing will retry later."+ updateIndexJob(+ XtreamIndexJobUpdate(+ providerId = provider.id,+ section = ContentType.MOVIE.name,+ state = indexFailureState(error),+ now = now,+ lastAttemptAt = now,+ lastError = sanitizeThrowableMessage(error)+ )+ )+ 0+ }+ if (movieCategoryCount > 0) {+ catalogActivated = true+ continuationWork += SyncContinuation(+ operation = SyncContinuationOperation.INDEX_CATALOG,+ section = ContentType.MOVIE,+ reason = "movie category shell is committed; durable item indexing is queued"+ )+ }+ emitProgress(+ provider.id,+ SyncProgress(+ section = Section.SERIES,+ current = 0,+ total = 0,+ currentLabel = "",+ itemsIndexed = liveCount+ )+ )+ val seriesCategoryCount = sectionExecutor.syncCategoryShell(+ provider = provider,+ api = api,+ contentType = ContentType.SERIES,+ label = "Series",+ now = now,+ onProgress = onProgress+ ).getOrElse { error ->+ warnings += "Series categories could not be loaded; series indexing will retry later."+ updateIndexJob(+ XtreamIndexJobUpdate(+ providerId = provider.id,+ section = ContentType.SERIES.name,+ state = indexFailureState(error),+ now = now,+ lastAttemptAt = now,+ lastError = sanitizeThrowableMessage(error)+ )+ )+ 0+ }+ if (seriesCategoryCount > 0) {+ catalogActivated = true+ continuationWork += SyncContinuation(+ operation = SyncContinuationOperation.INDEX_CATALOG,+ section = ContentType.SERIES,+ reason = "series category shell is committed; durable item indexing is queued"+ )+ }++ if (trackInitialLiveOnboarding) {+ val completedAt = System.currentTimeMillis()+ if (liveCount > 0 || movieCategoryCount > 0 || seriesCategoryCount > 0) {+ recordOnboardingState(+ provider = provider,+ phase = XTREAM_ONBOARDING_PHASE_COMPLETED,+ now = completedAt,+ acceptedRowCount = liveCount,+ stagedFlushCount = stagedFlushCountFor(liveCount),+ clearError = true,+ completedAt = completedAt,+ clearStagedSession = true,+ runtimeProfile = runtimeProfile+ )+ } else {+ recordOnboardingState(+ 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,+ movieSyncMode = VodSyncMode.UNKNOWN+ )+ syncMetadataRepository.updateMetadata(metadata)+ val epgState = if (provider.epgSyncMode == ProviderEpgSyncMode.SKIP) "IDLE" else "QUEUED"+ updateIndexJob(+ XtreamIndexJobUpdate(+ providerId = provider.id,+ section = "EPG",+ state = epgState,+ now = now,+ lastAttemptAt = if (epgState == "QUEUED") now else 0L+ )+ )+ if (provider.epgSyncMode != ProviderEpgSyncMode.SKIP) {+ continuationWork += SyncContinuation(+ operation = SyncContinuationOperation.REFRESH_GUIDE,+ reason = "guide refresh must be handed off to background work",+ force = force+ )+ }+ if (force) {+ Log.i(TAG, "Xtream index-first sync completed for provider ${provider.id}; VOD and series index jobs are queued.")+ }+ return SyncOutcome(+ partial = warnings.isNotEmpty(),+ warnings = warnings.distinct(),+ stagedMutations = activatedLiveMutations,+ continuationWork = continuationWork,+ activation = if (catalogActivated) {+ SyncActivation.ACTIVATED_CATALOG+ } else if (preservedActiveCatalog) {+ SyncActivation.PRESERVED_ACTIVE_CATALOG+ } else {+ SyncActivation.NO_CATALOG_CHANGE+ }+ )+ }++ suspend fun markInitialOnboardingFailure(provider: Provider, error: Throwable) {+ recordOnboardingState(+ provider = provider,+ phase = XTREAM_ONBOARDING_PHASE_FAILED,+ lastError = sanitizeThrowableMessage(error)+ )+ }++ suspend fun syncLive(+ provider: Provider,+ syncReason: XtreamLiveSyncReason,+ onProgress: ((String) -> Unit)?+ ): SyncOutcome {+ val now = System.currentTimeMillis()+ val sectionWarnings = mutableListOf<String>()+ progress(provider.id, onProgress, "Retrying Live TV...")+ val useTextClassification = preferencesRepository.useXtreamTextClassification.first()+ val enableBase64TextCompatibility = preferencesRepository.xtreamBase64TextCompatibility.first()+ val hiddenLiveCategoryIds = preferencesRepository.getHiddenCategoryIds(provider.id, ContentType.LIVE).first()+ val api = createProvider(provider, useTextClassification, enableBase64TextCompatibility)+ val currentMetadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)+ val runtimeProfile = CatalogSyncRuntimeProfile.from(applicationContext)+ var activatedMutations = 0+ val liveSyncResult = syncLiveCatalog(+ provider,+ api,+ currentMetadata,+ hiddenLiveCategoryIds,+ onProgress,+ runtimeProfile,+ trackInitialLiveOnboarding = false,+ syncReason = syncReason+ )+ val liveSequentialStress = liveSyncResult.strategyFeedback.segmentedStressDetected+ val liveProviderAdaptation = updateSequentialProviderAdaptation(+ previousRemembered = currentMetadata.liveSequentialFailuresRemembered,+ previousHealthyStreak = currentMetadata.liveHealthySyncStreak,+ sawSequentialStress = liveSequentialStress+ )+ val liveAvoidFullUntil = catalogStrategySupport.updateAvoidFullUntil(+ previousAvoidFullUntil = currentMetadata.liveAvoidFullUntil,+ now = now,+ feedback = liveSyncResult.strategyFeedback+ )+ when (val liveResult = liveSyncResult.catalogResult) {+ is CatalogStrategyResult.Success -> {+ val acceptedCount = finalizeLiveCatalog(+ provider.id,+ liveSyncResult,+ hiddenLiveCategoryIds,+ onProgress+ ).acceptedCount+ activatedMutations = acceptedCount+ syncMetadataRepository.updateMetadata(+ currentMetadata.copy(+ lastLiveSync = now,+ lastLiveSuccess = now,+ liveCount = acceptedCount,+ liveAvoidFullUntil = liveAvoidFullUntil,+ liveSequentialFailuresRemembered = liveProviderAdaptation.rememberSequential,+ liveHealthySyncStreak = liveProviderAdaptation.healthyStreak+ )+ )+ }+ is CatalogStrategyResult.Partial -> {+ val commitResult = finalizeLiveCatalog(+ provider.id,+ liveSyncResult,+ hiddenLiveCategoryIds,+ onProgress,+ partialCompletionWarning = "Live TV retry completed partially."+ )+ activatedMutations = commitResult.acceptedCount+ syncMetadataRepository.updateMetadata(+ currentMetadata.copy(+ lastLiveSync = now,+ liveCount = commitResult.acceptedCount,+ liveAvoidFullUntil = liveAvoidFullUntil,+ liveSequentialFailuresRemembered = currentMetadata.liveSequentialFailuresRemembered || liveSequentialStress,+ liveHealthySyncStreak = 0+ )+ )+ sectionWarnings += commitResult.warnings+ }+ is CatalogStrategyResult.EmptyValid -> {+ val existingLiveCount = channelDao.getCount(provider.id).first()+ syncMetadataRepository.updateMetadata(+ currentMetadata.copy(+ liveAvoidFullUntil = liveAvoidFullUntil,+ liveSequentialFailuresRemembered = currentMetadata.liveSequentialFailuresRemembered || liveSequentialStress,+ liveHealthySyncStreak = 0+ )+ )+ throw IllegalStateException(+ if (existingLiveCount > 0) {+ "Live TV refresh returned an empty catalog; existing library was preserved."+ } else {+ "Live TV catalog was empty."+ }+ )+ }+ is CatalogStrategyResult.Failure -> {+ syncMetadataRepository.updateMetadata(+ currentMetadata.copy(+ liveAvoidFullUntil = liveAvoidFullUntil,+ liveSequentialFailuresRemembered = currentMetadata.liveSequentialFailuresRemembered ||+ liveSequentialStress || shouldRememberSequentialPreference(liveResult.error),+ liveHealthySyncStreak = 0+ )+ )+ throw IllegalStateException(+ userMessage(liveResult.error, "Failed to fetch live channels"),+ liveResult.error+ )+ }+ }+ updateIndexJob(+ XtreamIndexJobUpdate(+ providerId = provider.id,+ section = ContentType.LIVE.name,+ state = "QUEUED",+ now = now,+ totalCategories = 1,+ completedCategories = 0,+ indexedRows = activatedMutations,+ lastAttemptAt = now,+ lastError = null+ )+ )+ return SyncOutcome(+ partial = sectionWarnings.isNotEmpty(),+ warnings = sectionWarnings,+ stagedMutations = activatedMutations,+ continuationWork = listOf(+ SyncContinuation(+ operation = SyncContinuationOperation.INDEX_CATALOG,+ section = ContentType.LIVE,+ reason = "activated live repair requires durable search-index backfill"+ )+ ),+ activation = SyncActivation.ACTIVATED_CATALOG+ )+ }++ private suspend fun syncLiveCatalog(+ provider: Provider,+ api: XtreamProvider,+ existingMetadata: SyncMetadata,+ hiddenLiveCategoryIds: Set<Long>,+ onProgress: ((String) -> Unit)?,+ runtimeProfile: CatalogSyncRuntimeProfile,+ trackInitialLiveOnboarding: Boolean,+ syncReason: XtreamLiveSyncReason+ ): CatalogSyncPayload<Channel> {+ emitProgress(+ provider.id,+ SyncProgress(Section.LIVE, current = 0, total = 0, currentLabel = "", itemsIndexed = 0)+ )+ val effectiveMethod = XtreamLiveSyncPolicy.resolve(+ userMode = provider.xtreamLiveSyncMode,+ runtimeProfile = runtimeProfile,+ syncReason = syncReason,+ metadata = existingMetadata,+ now = System.currentTimeMillis(),+ hiddenLiveCategoryIds = hiddenLiveCategoryIds+ )+ Log.i(+ TAG,+ "Xtream live sync method for provider ${provider.id}: user=${provider.xtreamLiveSyncMode} " ++ "effective=$effectiveMethod reason=$syncReason profile=${runtimeProfile.diagnosticsLabel}."+ )+ return liveStrategy.syncXtreamLiveCatalog(+ provider,+ api,+ existingMetadata,+ hiddenLiveCategoryIds,+ onProgress,+ runtimeProfile,+ trackInitialLiveOnboarding,+ effectiveMethod+ )+ }++ private suspend fun recordCommitPhaseIfNeeded(+ provider: Provider,+ payload: CatalogSyncPayload<Channel>,+ strategyName: String,+ runtimeProfile: CatalogSyncRuntimeProfile,+ trackInitialLiveOnboarding: Boolean+ ) {+ if (!trackInitialLiveOnboarding) return+ recordOnboardingState(+ provider = provider,+ phase = XTREAM_ONBOARDING_PHASE_COMMITTING,+ now = System.currentTimeMillis(),+ stagedSessionId = payload.stagedSessionId,+ importStrategy = strategyName,+ acceptedRowCount = payload.stagedAcceptedCount,+ stagedFlushCount = stagedFlushCountFor(payload.stagedAcceptedCount),+ clearError = true,+ runtimeProfile = runtimeProfile,+ syncProfileStrategy = payload.profileStrategyName(runtimeProfile, trackInitialLiveOnboarding)+ )+ }++ private suspend fun recoverOnboardingSession(+ provider: Provider,+ hiddenLiveCategoryIds: Set<Long>,+ afterCatalogApply: suspend () -> Unit+ ): XtreamLiveCommitResult? {+ val state = xtreamLiveOnboardingDao.getIncompleteByProvider(provider.id) ?: return null+ val sessionId = state.stagedSessionId ?: return null+ if (state.providerType != ProviderType.XTREAM_CODES.name || state.contentType != ContentType.LIVE.name) {+ discardOnboardingSession(provider, sessionId, "Saved Live TV import did not match this provider.")+ return null+ }+ if (state.importStrategy != null && state.importStrategy != "full") {+ discardOnboardingSession(provider, sessionId, "Saved Live TV import strategy could not be resumed.")+ return null+ }+ val stagedState = syncCatalogStore.stagedLiveImportState(provider.id, sessionId)+ val discardReason = when {+ stagedState.channelCount <= 0 -> "Saved Live TV import was missing staged channels."+ stagedState.movieCount > 0 || stagedState.seriesCount > 0 -> "Saved Live TV import contained rows for another catalog type."+ else -> null+ }+ if (discardReason != null) {+ discardOnboardingSession(provider, sessionId, discardReason)+ return null+ }+ recordOnboardingState(+ provider,+ XTREAM_ONBOARDING_PHASE_RECOVERING,+ stagedSessionId = sessionId,+ importStrategy = state.importStrategy ?: "full",+ acceptedRowCount = stagedState.channelCount,+ stagedFlushCount = stagedFlushCountFor(stagedState.channelCount),+ clearError = true+ )+ if (hiddenLiveCategoryIds.isNotEmpty()) {+ mergeHiddenChannelsIntoStaging(provider.id, sessionId, hiddenLiveCategoryIds)+ }+ val commitState = if (hiddenLiveCategoryIds.isNotEmpty()) {+ syncCatalogStore.stagedLiveImportState(provider.id, sessionId)+ } else {+ stagedState+ }+ recordOnboardingState(+ provider,+ XTREAM_ONBOARDING_PHASE_COMMITTING,+ stagedSessionId = sessionId,+ importStrategy = state.importStrategy ?: "full",+ acceptedRowCount = stagedState.channelCount,+ stagedFlushCount = stagedFlushCountFor(stagedState.channelCount),+ clearError = true+ )+ syncCatalogStore.applyStagedLiveCatalog(+ providerId = provider.id,+ sessionId = sessionId,+ categories = commitState.categories.takeIf { it.isNotEmpty() },+ afterCatalogApply = afterCatalogApply+ )+ return XtreamLiveCommitResult(stagedState.channelCount, listOf("Live TV import resumed from saved staged session."))+ }++ private suspend fun discardOnboardingSession(provider: Provider, sessionId: Long, reason: String) {+ Log.w(TAG, "Discarding saved Xtream Live onboarding session for provider ${provider.id}: $reason")+ syncCatalogStore.discardStagedImport(provider.id, sessionId)+ recordOnboardingState(+ provider = provider,+ phase = XTREAM_ONBOARDING_PHASE_STARTING,+ lastError = reason,+ clearStagedSession = true+ )+ }++ private suspend fun recordOnboardingState(+ provider: Provider,+ phase: String,+ now: Long = System.currentTimeMillis(),+ stagedSessionId: Long? = null,+ importStrategy: String? = null,+ nextCategoryIndex: Int? = null,+ acceptedRowCount: Int? = null,+ stagedFlushCount: Int? = null,+ lastError: String? = null,+ clearError: Boolean = false,+ completedAt: Long? = null,+ clearStagedSession: Boolean = false,+ runtimeProfile: CatalogSyncRuntimeProfile? = null,+ syncProfileStrategy: String? = null+ ) {+ val existing = xtreamLiveOnboardingDao.getByProvider(provider.id)+ xtreamLiveOnboardingDao.upsert(+ XtreamLiveOnboardingStateEntity(+ providerId = provider.id,+ providerType = provider.type.name,+ contentType = ContentType.LIVE.name,+ phase = phase,+ stagedSessionId = if (clearStagedSession) null else stagedSessionId ?: existing?.stagedSessionId,+ importStrategy = importStrategy ?: existing?.importStrategy,+ nextCategoryIndex = nextCategoryIndex ?: existing?.nextCategoryIndex ?: 0,+ acceptedRowCount = acceptedRowCount ?: existing?.acceptedRowCount ?: 0,+ stagedFlushCount = stagedFlushCount ?: existing?.stagedFlushCount ?: 0,+ syncProfileTier = runtimeProfile?.tier?.name ?: existing?.syncProfileTier,+ syncProfileBatchSize = runtimeProfile?.stageBatchSize ?: existing?.syncProfileBatchSize ?: 0,+ syncProfileStrategy = syncProfileStrategy ?: existing?.syncProfileStrategy,+ syncProfileLowMemory = runtimeProfile?.snapshot?.isCurrentlyLowOnMemory ?: existing?.syncProfileLowMemory ?: false,+ syncProfileMemoryClassMb = runtimeProfile?.snapshot?.memoryClassMb ?: existing?.syncProfileMemoryClassMb ?: 0,+ syncProfileAvailableMemMb = runtimeProfile?.snapshot?.availableMemMb ?: existing?.syncProfileAvailableMemMb ?: 0L,+ lastError = when {+ clearError -> null+ lastError != null -> lastError+ else -> existing?.lastError+ },+ createdAt = existing?.createdAt?.takeIf { it > 0L } ?: now,+ updatedAt = now,+ completedAt = completedAt+ )+ )+ }++ private suspend fun finalizeLiveCatalog(+ providerId: Long,+ liveSyncResult: CatalogSyncPayload<Channel>,+ hiddenLiveCategoryIds: Set<Long>,+ onProgress: ((String) -> Unit)?,+ partialCompletionWarning: String? = null,+ afterCatalogApply: suspend () -> Unit = {}+ ): XtreamLiveCommitResult {+ progress(providerId, onProgress, "Saving Live TV channels...")+ val warnings = buildList {+ addAll(liveSyncResult.warnings)+ addAll(catalogStrategySupport.strategyWarnings(liveSyncResult.catalogResult))+ partialCompletionWarning?.let(::add)+ }+ val acceptedCount = when (val liveResult = liveSyncResult.catalogResult) {+ is CatalogStrategyResult.Success -> {+ liveSyncResult.stagedSessionId?.let { sessionId ->+ val mergedCategories = mergeVisibleLiveCategoriesWithHiddenStoredContent(+ providerId,+ liveSyncResult.categories,+ hiddenLiveCategoryIds+ )+ if (hiddenLiveCategoryIds.isNotEmpty()) mergeHiddenChannelsIntoStaging(providerId, sessionId, hiddenLiveCategoryIds)+ syncCatalogStore.applyStagedLiveCatalog(providerId, sessionId, mergedCategories, afterCatalogApply)+ liveSyncResult.stagedAcceptedCount+ } ?: run {+ val liveCatalog = mergeVisibleLiveSyncWithHiddenStoredContent(+ providerId,+ liveSyncResult.categories,+ liveResult.items.map { it.toEntity() },+ hiddenLiveCategoryIds+ )+ syncCatalogStore.replaceLiveCatalog(providerId, liveCatalog.categories, liveCatalog.channels, afterCatalogApply)+ }+ }+ is CatalogStrategyResult.Partial -> {+ liveSyncResult.stagedSessionId?.let { sessionId ->+ val mergedCategories = mergeVisibleLiveCategoriesWithHiddenStoredContent(+ providerId,+ liveSyncResult.categories,+ hiddenLiveCategoryIds+ )+ if (hiddenLiveCategoryIds.isNotEmpty()) mergeHiddenChannelsIntoStaging(providerId, sessionId, hiddenLiveCategoryIds)+ syncCatalogStore.applyStagedLiveCatalogUpsertOnly(providerId, sessionId, mergedCategories, afterCatalogApply)+ liveSyncResult.stagedAcceptedCount+ } ?: run {+ val liveCatalog = mergeVisibleLiveSyncWithHiddenStoredContent(+ providerId,+ liveSyncResult.categories,+ liveResult.items.map { it.toEntity() },+ hiddenLiveCategoryIds+ )+ syncCatalogStore.upsertLiveCatalog(providerId, liveCatalog.categories, liveCatalog.channels, afterCatalogApply)+ }+ }+ is CatalogStrategyResult.EmptyValid,+ is CatalogStrategyResult.Failure -> throw IllegalArgumentException(+ "finalizeLiveCatalog only supports success or partial results"+ )+ }+ return XtreamLiveCommitResult(acceptedCount, warnings)+ }++ private suspend fun mergeHiddenChannelsIntoStaging(+ providerId: Long,+ sessionId: Long,+ hiddenLiveCategoryIds: Set<Long>+ ) {+ val hiddenChannels = channelDao.getByProviderSync(providerId)+ .filter { channel -> channel.categoryId != null && channel.categoryId in hiddenLiveCategoryIds }+ if (hiddenChannels.isNotEmpty()) syncCatalogStore.stageChannelBatch(providerId, sessionId, hiddenChannels)+ }++ private suspend fun mergeVisibleLiveCategoriesWithHiddenStoredContent(+ providerId: Long,+ visibleCategories: List<CategoryEntity>?,+ hiddenLiveCategoryIds: Set<Long>+ ): List<CategoryEntity>? {+ if (hiddenLiveCategoryIds.isEmpty()) return visibleCategories+ return ((visibleCategories ?: emptyList()) + categoryDao.getByProviderAndTypeSync(providerId, ContentType.LIVE.name)+ .filter { it.categoryId in hiddenLiveCategoryIds })+ .distinctBy { it.categoryId to it.type }+ .sortedBy { it.categoryId }+ .takeIf { it.isNotEmpty() }+ }++ private suspend fun mergeVisibleLiveSyncWithHiddenStoredContent(+ providerId: Long,+ visibleCategories: List<CategoryEntity>?,+ visibleChannels: List<ChannelEntity>,+ hiddenLiveCategoryIds: Set<Long>+ ): LiveCatalogSnapshot {+ if (hiddenLiveCategoryIds.isEmpty()) return LiveCatalogSnapshot(visibleCategories, visibleChannels)+ val hiddenCategories = categoryDao.getByProviderAndTypeSync(providerId, ContentType.LIVE.name)+ .filter { it.categoryId in hiddenLiveCategoryIds }+ val hiddenChannels = channelDao.getByProviderSync(providerId)+ .filter { it.categoryId != null && it.categoryId in hiddenLiveCategoryIds }+ return LiveCatalogSnapshot(+ categories = ((visibleCategories ?: emptyList()) + hiddenCategories)+ .distinctBy { it.categoryId to it.type }+ .sortedBy { it.categoryId }+ .takeIf { it.isNotEmpty() },+ channels = (visibleChannels + hiddenChannels).distinctBy { it.streamId }.sortedBy { it.number }+ )+ }++ private fun updateSequentialProviderAdaptation(+ previousRemembered: Boolean,+ previousHealthyStreak: Int,+ sawSequentialStress: Boolean+ ): SequentialProviderAdaptation {+ if (sawSequentialStress) return SequentialProviderAdaptation(true, 0)+ if (!previousRemembered) return SequentialProviderAdaptation(false, 0)+ val nextHealthyStreak = (previousHealthyStreak + 1).coerceAtMost(2)+ return if (nextHealthyStreak >= 2) SequentialProviderAdaptation(false, 0)+ else SequentialProviderAdaptation(true, nextHealthyStreak)+ }++ private fun stagedFlushCountFor(acceptedCount: Int): Int =+ if (acceptedCount <= 0) 0 else (acceptedCount + XTREAM_FALLBACK_STAGE_BATCH_SIZE - 1) / XTREAM_FALLBACK_STAGE_BATCH_SIZE++ private fun CatalogStrategyResult<*>.strategyNameOrNull(): String? = strategyName++ private fun CatalogSyncPayload<Channel>.profileStrategyName(+ runtimeProfile: CatalogSyncRuntimeProfile,+ trackInitialLiveOnboarding: Boolean+ ): String {+ val fullPolicy = if (strategyFeedback.preferredSegmentedFirst) "segmented_first"+ else if (runtimeProfile.shouldAttemptFullLiveCatalog(trackInitialLiveOnboarding)) "full_allowed"+ else "full_blocked"+ return "${catalogResult.strategyNameOrNull() ?: "unknown"};$fullPolicy"+ }++ private data class XtreamLiveCommitResult(+ val acceptedCount: Int,+ val warnings: List<String>+ )++ private companion object {+ const val TAG = "XtreamCatalogSync"+ const val XTREAM_FALLBACK_STAGE_BATCH_SIZE = 500+ const val XTREAM_ONBOARDING_PHASE_STARTING = "STARTING"+ const val XTREAM_ONBOARDING_PHASE_FETCHING = "FETCHING"+ const val XTREAM_ONBOARDING_PHASE_RECOVERING = "RECOVERING"+ const val XTREAM_ONBOARDING_PHASE_STAGED = "STAGED"+ const val XTREAM_ONBOARDING_PHASE_COMMITTING = "COMMITTING"+ const val XTREAM_ONBOARDING_PHASE_COMPLETED = "COMPLETED"+ const val XTREAM_ONBOARDING_PHASE_FAILED = "FAILED"+ }+}diff --git a/data/src/main/java/com/streamvault/data/sync/XtreamIncrementalIndexExecutor.kt b/data/src/main/java/com/streamvault/data/sync/XtreamIncrementalIndexExecutor.ktnew file mode 100644index 00000000..575bad4a--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/XtreamIncrementalIndexExecutor.kt@@ -0,0 +1,523 @@+package com.streamvault.data.sync++import com.streamvault.data.local.entity.CategoryEntity+import com.streamvault.data.local.entity.XtreamIndexJobEntity+import com.streamvault.data.remote.xtream.XtreamProvider+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.LegacyProvider as Provider+import com.streamvault.domain.model.Movie+import com.streamvault.domain.model.Result+import com.streamvault.domain.model.Series++/**+ * Owns incremental Xtream movie/series index orchestration.+ *+ * The executor controls cursor progression, priority-category ordering, full-stream fallback,+ * durable state publication, and continuation scheduling. Network, DAO, and metadata details are+ * supplied through one narrow operations port so the coordinator does not regain those seams.+ */+internal interface XtreamIncrementalIndexOperations {+ suspend fun getCategories(providerId: Long, contentType: ContentType): List<CategoryEntity>++ suspend fun ensureCategoryShell(+ provider: Provider,+ api: XtreamProvider,+ contentType: ContentType,+ now: Long,+ onProgress: ((String) -> Unit)?+ )++ suspend fun getJob(providerId: Long, contentType: ContentType): XtreamIndexJobEntity?++ fun shouldRunSummary(job: XtreamIndexJobEntity?): Boolean++ suspend fun fetchMovieCategory(+ provider: Provider,+ api: XtreamProvider,+ category: CategoryEntity+ ): TimedCategoryOutcome<Movie>++ suspend fun fetchSeriesCategory(+ provider: Provider,+ api: XtreamProvider,+ category: CategoryEntity+ ): TimedCategoryOutcome<Series>++ suspend fun upsertMovieSummaryBatch(+ providerId: Long,+ movies: List<Movie>,+ indexedAt: Long+ ): Int++ suspend fun upsertSeriesSummaryBatch(+ providerId: Long,+ series: List<Series>,+ indexedAt: Long+ ): Int++ suspend fun streamMovies(+ provider: Provider,+ api: XtreamProvider,+ adultCategoryIds: Set<Long>,+ onBatch: suspend (List<Movie>) -> Unit+ ): Result<Int>++ suspend fun streamSeries(+ provider: Provider,+ api: XtreamProvider,+ adultCategoryIds: Set<Long>,+ onBatch: suspend (List<Series>) -> Unit+ ): Result<Int>++ suspend fun upsertJob(update: CatalogIndexJobUpdate)++ suspend fun updateSummaryMetadata(+ providerId: Long,+ contentType: ContentType,+ indexedRows: Int,+ state: String,+ now: Long+ )++ fun scheduleIndex(providerId: Long, contentType: ContentType)++ fun progress(providerId: Long, callback: ((String) -> Unit)?, message: String)++ suspend fun restoreMovieWatchProgress(providerId: Long)++ fun sanitize(error: Throwable?): String++ fun log(message: String)+}++internal class XtreamIncrementalIndexExecutor(+ private val operations: XtreamIncrementalIndexOperations+) {+ suspend fun processSummary(+ provider: Provider,+ api: XtreamProvider,+ contentType: ContentType,+ maxCategories: Int?,+ onProgress: ((String) -> Unit)?+ ) {+ require(contentType == ContentType.MOVIE || contentType == ContentType.SERIES) {+ "Unsupported Xtream summary index section: $contentType"+ }+ val now = System.currentTimeMillis()+ val categories = operations.getCategories(provider.id, contentType)+ if (categories.isEmpty()) {+ operations.ensureCategoryShell(provider, api, contentType, now, onProgress)+ }+ val initialJob = operations.getJob(provider.id, contentType)+ val priorityCategoryId = initialJob?.priorityCategoryId+ val indexedCategories = operations.getCategories(provider.id, contentType)+ val resumeJob = initialJob?.takeIf { it.state in setOf("QUEUED", "RUNNING", "PARTIAL") }+ val categoryLimit = maxCategories?.coerceAtLeast(1) ?: Int.MAX_VALUE+ val restartIncompleteFailedSweep = resumeJob?.let { job ->+ job.state == "PARTIAL" &&+ job.failedCategories > 0 &&+ job.nextCategoryIndex >= indexedCategories.size+ } == true+ var nextCategoryIndex = if (restartIncompleteFailedSweep) {+ 0+ } else {+ resumeJob?.nextCategoryIndex?.coerceIn(0, indexedCategories.size) ?: 0+ }+ var restoreMovieWatchProgressPending = false+ try {+ if (shouldAttemptFullStream(resumeJob, priorityCategoryId)) {+ when (val streamed = streamFullSummary(+ provider = provider,+ api = api,+ contentType = contentType,+ categories = indexedCategories,+ totalCategories = indexedCategories.size,+ now = now,+ onProgress = onProgress+ )) {+ is Result.Success -> return+ is Result.Error -> {+ operations.log(+ "Full ${contentType.name} stream index failed for provider ${provider.id}; falling back to category slices: ${streamed.message}"+ )+ upsertJob(+ providerId = provider.id,+ section = contentType.name,+ state = "QUEUED",+ now = System.currentTimeMillis(),+ totalCategories = indexedCategories.size,+ completedCategories = 0,+ nextCategoryIndex = 0,+ failedCategories = 0,+ lastAttemptAt = now,+ lastError = streamed.message+ )+ nextCategoryIndex = 0+ }+ Result.Loading -> Unit+ }+ }++ upsertJob(+ providerId = provider.id,+ section = contentType.name,+ state = "RUNNING",+ now = now,+ totalCategories = indexedCategories.size,+ completedCategories = if (restartIncompleteFailedSweep) 0 else resumeJob?.completedCategories ?: 0,+ nextCategoryIndex = nextCategoryIndex,+ failedCategories = 0,+ indexedRows = if (restartIncompleteFailedSweep) 0 else resumeJob?.indexedRows ?: 0,+ skippedMalformedRows = if (restartIncompleteFailedSweep) 0 else resumeJob?.skippedMalformedRows ?: 0,+ lastAttemptAt = now,+ lastError = null+ )++ var completedCategories = if (restartIncompleteFailedSweep) 0 else resumeJob?.completedCategories ?: 0+ var failedCategories = 0+ var indexedRows = if (restartIncompleteFailedSweep) 0 else resumeJob?.indexedRows ?: 0+ var skippedMalformedRows = if (restartIncompleteFailedSweep) 0 else resumeJob?.skippedMalformedRows ?: 0+ var lastError: Throwable? = null+ var priorityHandled = false++ data class CategoryIndexWork(+ val category: CategoryEntity,+ val advancesCursor: Boolean,+ val cursorAfterSuccess: Int? = null+ )++ val workItems = buildList {+ var selectionCursor = nextCategoryIndex+ val priorityIndex = priorityCategoryId?.let { id ->+ indexedCategories.indexOfFirst { it.categoryId == id }+ .takeIf { index -> index >= 0 }+ }+ if (priorityIndex != null && priorityIndex != nextCategoryIndex && size < categoryLimit) {+ add(CategoryIndexWork(indexedCategories[priorityIndex], advancesCursor = false))+ }+ while (selectionCursor < indexedCategories.size && size < categoryLimit) {+ val category = indexedCategories[selectionCursor]+ selectionCursor+++ if (+ priorityCategoryId != null &&+ category.categoryId == priorityCategoryId &&+ any { it.category.categoryId == priorityCategoryId }+ ) {+ continue+ }+ add(+ CategoryIndexWork(+ category = category,+ advancesCursor = true,+ cursorAfterSuccess = selectionCursor+ )+ )+ }+ }++ workLoop@ for (workItem in workItems) {+ val category = workItem.category+ operations.progress(+ provider.id,+ onProgress,+ "Indexing ${sectionLabel(contentType)}: ${category.name}"+ )+ val outcome = when (contentType) {+ ContentType.MOVIE -> operations.fetchMovieCategory(provider, api, category)+ ContentType.SERIES -> operations.fetchSeriesCategory(provider, api, category)+ else -> error("Unsupported section")+ }+ when (val categoryOutcome = outcome.outcome) {+ is CategoryFetchOutcome.Success -> {+ val accepted = when (contentType) {+ ContentType.MOVIE -> operations.upsertMovieSummaryBatch(+ providerId = provider.id,+ movies = categoryOutcome.items.filterIsInstance<Movie>(),+ indexedAt = System.currentTimeMillis()+ )+ ContentType.SERIES -> operations.upsertSeriesSummaryBatch(+ providerId = provider.id,+ series = categoryOutcome.items.filterIsInstance<Series>(),+ indexedAt = System.currentTimeMillis()+ )+ else -> 0+ }+ if (workItem.advancesCursor) {+ nextCategoryIndex = requireNotNull(workItem.cursorAfterSuccess)+ indexedRows += accepted+ skippedMalformedRows +=+ (categoryOutcome.rawCount - categoryOutcome.items.size).coerceAtLeast(0)+ completedCategories+++ }+ if (contentType == ContentType.MOVIE && accepted > 0) {+ restoreMovieWatchProgressPending = true+ }+ if (category.categoryId == priorityCategoryId) {+ priorityHandled = true+ upsertJob(+ providerId = provider.id,+ section = contentType.name,+ state = "RUNNING",+ now = System.currentTimeMillis(),+ clearPriority = true+ )+ }+ }+ is CategoryFetchOutcome.Empty -> {+ if (workItem.advancesCursor) {+ nextCategoryIndex = requireNotNull(workItem.cursorAfterSuccess)+ completedCategories+++ }+ if (category.categoryId == priorityCategoryId) {+ priorityHandled = true+ upsertJob(+ providerId = provider.id,+ section = contentType.name,+ state = "RUNNING",+ now = System.currentTimeMillis(),+ clearPriority = true+ )+ }+ }+ is CategoryFetchOutcome.Failure -> {+ failedCategories+++ lastError = categoryOutcome.error+ }+ }+ upsertJob(+ providerId = provider.id,+ section = contentType.name,+ state = if (failedCategories > 0) "PARTIAL" else "RUNNING",+ now = System.currentTimeMillis(),+ totalCategories = indexedCategories.size,+ completedCategories = completedCategories,+ nextCategoryIndex = nextCategoryIndex,+ failedCategories = failedCategories,+ indexedRows = indexedRows,+ skippedMalformedRows = skippedMalformedRows,+ lastAttemptAt = now,+ lastError = lastError?.let(operations::sanitize)+ )+ if (outcome.outcome is CategoryFetchOutcome.Failure) {+ break@workLoop+ }+ }++ val finishedAt = System.currentTimeMillis()+ val hasMoreCategories = nextCategoryIndex < indexedCategories.size+ val finalState = when {+ hasMoreCategories -> "QUEUED"+ failedCategories > 0 -> "PARTIAL"+ else -> "SUCCESS"+ }+ val priorityWasNotPresent = priorityCategoryId != null &&+ indexedCategories.none { it.categoryId == priorityCategoryId }+ upsertJob(+ providerId = provider.id,+ section = contentType.name,+ state = finalState,+ now = finishedAt,+ totalCategories = indexedCategories.size,+ completedCategories = completedCategories,+ nextCategoryIndex = nextCategoryIndex,+ failedCategories = failedCategories,+ indexedRows = indexedRows,+ skippedMalformedRows = skippedMalformedRows,+ clearPriority = finalState == "SUCCESS" || priorityWasNotPresent || priorityHandled,+ lastAttemptAt = now,+ lastSuccessAt = finishedAt.takeIf { finalState == "SUCCESS" },+ lastError = lastError?.let(operations::sanitize)+ )+ operations.updateSummaryMetadata(provider.id, contentType, indexedRows, finalState, finishedAt)+ if (hasMoreCategories) {+ operations.scheduleIndex(provider.id, contentType)+ }+ if (!hasMoreCategories && failedCategories > 0) {+ throw IllegalStateException(+ "${sectionLabel(contentType)} indexing completed partially.",+ lastError+ )+ }+ } finally {+ if (contentType == ContentType.MOVIE && restoreMovieWatchProgressPending) {+ operations.restoreMovieWatchProgress(provider.id)+ }+ }+ }++ private suspend fun streamFullSummary(+ provider: Provider,+ api: XtreamProvider,+ contentType: ContentType,+ categories: List<CategoryEntity>,+ totalCategories: Int,+ now: Long,+ onProgress: ((String) -> Unit)?+ ): Result<Int> {+ operations.progress(provider.id, onProgress, "Indexing ${sectionLabel(contentType)}...")+ upsertJob(+ providerId = provider.id,+ section = contentType.name,+ state = "RUNNING",+ now = now,+ totalCategories = totalCategories,+ completedCategories = 0,+ nextCategoryIndex = 0,+ failedCategories = 0,+ indexedRows = 0,+ skippedMalformedRows = 0,+ lastAttemptAt = now,+ lastError = null+ )++ var indexedRows = 0+ var restoreMovieWatchProgressPending = false+ val categoryNamesById = categories.associate { it.categoryId to it.name }+ val adultCategoryIds = categories.filter { it.isAdult }.mapTo(mutableSetOf()) { it.categoryId }+ try {+ val streamResult = when (contentType) {+ ContentType.MOVIE -> operations.streamMovies(provider, api, adultCategoryIds) { batch ->+ val namedBatch = batch.withMovieCategoryNames(categoryNamesById)+ val accepted = operations.upsertMovieSummaryBatch(provider.id, namedBatch, System.currentTimeMillis())+ indexedRows += accepted+ if (accepted > 0) restoreMovieWatchProgressPending = true+ upsertJob(+ providerId = provider.id,+ section = contentType.name,+ state = "RUNNING",+ now = System.currentTimeMillis(),+ totalCategories = totalCategories,+ completedCategories = 0,+ nextCategoryIndex = 0,+ indexedRows = indexedRows,+ lastAttemptAt = now,+ lastError = null+ )+ }+ ContentType.SERIES -> operations.streamSeries(provider, api, adultCategoryIds) { batch ->+ val namedBatch = batch.withSeriesCategoryNames(categoryNamesById)+ val accepted = operations.upsertSeriesSummaryBatch(provider.id, namedBatch, System.currentTimeMillis())+ indexedRows += accepted+ upsertJob(+ providerId = provider.id,+ section = contentType.name,+ state = "RUNNING",+ now = System.currentTimeMillis(),+ totalCategories = totalCategories,+ completedCategories = 0,+ nextCategoryIndex = 0,+ indexedRows = indexedRows,+ lastAttemptAt = now,+ lastError = null+ )+ }+ else -> Result.error("Unsupported Xtream summary stream section: $contentType")+ }++ return when (streamResult) {+ is Result.Success -> {+ val finishedAt = System.currentTimeMillis()+ val acceptedCount = indexedRows.coerceAtLeast(streamResult.data)+ upsertJob(+ providerId = provider.id,+ section = contentType.name,+ state = "SUCCESS",+ now = finishedAt,+ totalCategories = totalCategories,+ completedCategories = totalCategories,+ nextCategoryIndex = totalCategories,+ failedCategories = 0,+ indexedRows = acceptedCount,+ skippedMalformedRows = 0,+ clearPriority = true,+ lastAttemptAt = now,+ lastSuccessAt = finishedAt,+ lastError = null+ )+ operations.updateSummaryMetadata(provider.id, contentType, acceptedCount, "SUCCESS", finishedAt)+ Result.success(acceptedCount)+ }+ is Result.Error -> streamResult+ Result.Loading -> Result.error("Xtream summary stream did not complete")+ }+ } finally {+ if (contentType == ContentType.MOVIE && restoreMovieWatchProgressPending) {+ operations.restoreMovieWatchProgress(provider.id)+ }+ }+ }++ private fun shouldAttemptFullStream(+ resumeJob: XtreamIndexJobEntity?,+ priorityCategoryId: Long?+ ): Boolean {+ if (priorityCategoryId != null && resumeJob?.nextCategoryIndex != 0) return false+ if (resumeJob == null) return true+ return resumeJob.nextCategoryIndex == 0 &&+ resumeJob.completedCategories == 0 &&+ resumeJob.failedCategories == 0 &&+ resumeJob.indexedRows == 0+ }++ private fun List<Movie>.withMovieCategoryNames(categoryNamesById: Map<Long, String>): List<Movie> = map { movie ->+ val categoryName = movie.categoryId?.let(categoryNamesById::get)+ if (categoryName == null || categoryName == movie.categoryName) movie+ else movie.copy(categoryName = categoryName)+ }++ private fun List<Series>.withSeriesCategoryNames(categoryNamesById: Map<Long, String>): List<Series> = map { series ->+ val categoryName = series.categoryId?.let(categoryNamesById::get)+ if (categoryName == null || categoryName == series.categoryName) series+ else series.copy(categoryName = categoryName)+ }++ private suspend fun upsertJob(+ providerId: Long,+ section: String,+ state: String,+ now: Long,+ totalCategories: Int? = null,+ completedCategories: Int? = null,+ nextCategoryIndex: Int? = null,+ failedCategories: Int? = null,+ indexedRows: Int? = null,+ skippedMalformedRows: Int? = null,+ deletedPrunedRows: Int? = null,+ priorityCategoryId: Long? = null,+ priorityRequestedAt: Long? = null,+ clearPriority: Boolean = false,+ lastAttemptAt: Long? = null,+ lastSuccessAt: Long? = null,+ lastError: String? = null+ ) {+ operations.upsertJob(+ CatalogIndexJobUpdate(+ providerId = providerId,+ section = section,+ state = state,+ now = now,+ totalCategories = totalCategories,+ completedCategories = completedCategories,+ nextCategoryIndex = nextCategoryIndex,+ failedCategories = failedCategories,+ indexedRows = indexedRows,+ skippedMalformedRows = skippedMalformedRows,+ deletedPrunedRows = deletedPrunedRows,+ priorityCategoryId = priorityCategoryId,+ priorityRequestedAt = priorityRequestedAt,+ clearPriority = clearPriority,+ lastAttemptAt = lastAttemptAt,+ lastSuccessAt = lastSuccessAt,+ lastError = lastError+ )+ )+ }++ private fun sectionLabel(contentType: ContentType): String = when (contentType) {+ ContentType.MOVIE -> "Movies"+ ContentType.SERIES -> "Series"+ ContentType.LIVE -> "Live TV"+ ContentType.VOD -> "VOD"+ ContentType.SERIES_EPISODE -> "Episodes"+ }+}diff --git a/data/src/main/java/com/streamvault/data/sync/XtreamIncrementalIndexOperationsAdapter.kt b/data/src/main/java/com/streamvault/data/sync/XtreamIncrementalIndexOperationsAdapter.ktnew file mode 100644index 00000000..df92ea50--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/XtreamIncrementalIndexOperationsAdapter.kt@@ -0,0 +1,111 @@+package com.streamvault.data.sync++import com.streamvault.data.local.entity.CategoryEntity+import com.streamvault.data.local.entity.XtreamIndexJobEntity+import com.streamvault.data.remote.xtream.XtreamProvider+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.LegacyProvider as Provider+import com.streamvault.domain.model.Movie+import com.streamvault.domain.model.Result+import com.streamvault.domain.model.Series++internal data class XtreamIncrementalIndexCallbacks(+ val getCategories: suspend (Long, ContentType) -> List<CategoryEntity>,+ val ensureCategoryShell: suspend (Provider, XtreamProvider, ContentType, Long, ((String) -> Unit)?) -> Unit,+ val getJob: suspend (Long, ContentType) -> XtreamIndexJobEntity?,+ val shouldRunSummary: (XtreamIndexJobEntity?) -> Boolean,+ val fetchMovieCategory: suspend (Provider, XtreamProvider, CategoryEntity) -> TimedCategoryOutcome<Movie>,+ val fetchSeriesCategory: suspend (Provider, XtreamProvider, CategoryEntity) -> TimedCategoryOutcome<Series>,+ val upsertMovieSummaryBatch: suspend (Long, List<Movie>, Long) -> Int,+ val upsertSeriesSummaryBatch: suspend (Long, List<Series>, Long) -> Int,+ val streamMovies: suspend (Provider, XtreamProvider, Set<Long>, suspend (List<Movie>) -> Unit) -> Result<Int>,+ val streamSeries: suspend (Provider, XtreamProvider, Set<Long>, suspend (List<Series>) -> Unit) -> Result<Int>,+ val upsertJob: suspend (CatalogIndexJobUpdate) -> Unit,+ val updateSummaryMetadata: suspend (Long, ContentType, Int, String, Long) -> Unit,+ val scheduleIndex: (Long, ContentType) -> Unit,+ val progress: (Long, ((String) -> Unit)?, String) -> Unit,+ val restoreMovieWatchProgress: suspend (Long) -> Unit,+ val sanitize: (Throwable?) -> String,+ val log: (String) -> Unit+)++internal class CallbackXtreamIncrementalIndexOperations(+ private val callbacks: XtreamIncrementalIndexCallbacks+) : XtreamIncrementalIndexOperations {+ override suspend fun getCategories(providerId: Long, contentType: ContentType): List<CategoryEntity> =+ callbacks.getCategories(providerId, contentType)++ override suspend fun ensureCategoryShell(+ provider: Provider,+ api: XtreamProvider,+ contentType: ContentType,+ now: Long,+ onProgress: ((String) -> Unit)?+ ) = callbacks.ensureCategoryShell(provider, api, contentType, now, onProgress)++ override suspend fun getJob(providerId: Long, contentType: ContentType): XtreamIndexJobEntity? =+ callbacks.getJob(providerId, contentType)++ override fun shouldRunSummary(job: XtreamIndexJobEntity?): Boolean = callbacks.shouldRunSummary(job)++ override suspend fun fetchMovieCategory(+ provider: Provider,+ api: XtreamProvider,+ category: CategoryEntity+ ): TimedCategoryOutcome<Movie> = callbacks.fetchMovieCategory(provider, api, category)++ override suspend fun fetchSeriesCategory(+ provider: Provider,+ api: XtreamProvider,+ category: CategoryEntity+ ): TimedCategoryOutcome<Series> = callbacks.fetchSeriesCategory(provider, api, category)++ override suspend fun upsertMovieSummaryBatch(+ providerId: Long,+ movies: List<Movie>,+ indexedAt: Long+ ): Int = callbacks.upsertMovieSummaryBatch(providerId, movies, indexedAt)++ override suspend fun upsertSeriesSummaryBatch(+ providerId: Long,+ series: List<Series>,+ indexedAt: Long+ ): Int = callbacks.upsertSeriesSummaryBatch(providerId, series, indexedAt)++ override suspend fun streamMovies(+ provider: Provider,+ api: XtreamProvider,+ adultCategoryIds: Set<Long>,+ onBatch: suspend (List<Movie>) -> Unit+ ): Result<Int> = callbacks.streamMovies(provider, api, adultCategoryIds, onBatch)++ override suspend fun streamSeries(+ provider: Provider,+ api: XtreamProvider,+ adultCategoryIds: Set<Long>,+ onBatch: suspend (List<Series>) -> Unit+ ): Result<Int> = callbacks.streamSeries(provider, api, adultCategoryIds, onBatch)++ override suspend fun upsertJob(update: CatalogIndexJobUpdate) = callbacks.upsertJob(update)++ override suspend fun updateSummaryMetadata(+ providerId: Long,+ contentType: ContentType,+ indexedRows: Int,+ state: String,+ now: Long+ ) = callbacks.updateSummaryMetadata(providerId, contentType, indexedRows, state, now)++ override fun scheduleIndex(providerId: Long, contentType: ContentType) =+ callbacks.scheduleIndex(providerId, contentType)++ override fun progress(providerId: Long, callback: ((String) -> Unit)?, message: String) =+ callbacks.progress(providerId, callback, message)++ override suspend fun restoreMovieWatchProgress(providerId: Long) =+ callbacks.restoreMovieWatchProgress(providerId)++ override fun sanitize(error: Throwable?): String = callbacks.sanitize(error)++ override fun log(message: String) = callbacks.log(message)+}diff --git a/data/src/main/java/com/streamvault/data/sync/XtreamIndexRecoveryPolicy.kt b/data/src/main/java/com/streamvault/data/sync/XtreamIndexRecoveryPolicy.ktnew file mode 100644index 00000000..387dd895--- /dev/null+++ b/data/src/main/java/com/streamvault/data/sync/XtreamIndexRecoveryPolicy.kt@@ -0,0 +1,20 @@+package com.streamvault.data.sync++import com.streamvault.data.remote.xtream.XtreamAuthenticationException+import com.streamvault.data.remote.xtream.XtreamRequestException++/** Classifies durable Xtream index failures for process-death and WorkManager recovery. */+internal object XtreamIndexRecoveryPolicy {+ fun failureState(error: Throwable): String {+ val chain = generateSequence(error as Throwable?) { it.cause }.toList()+ if (chain.any { it is XtreamAuthenticationException }) {+ return "FAILED_PERMANENT"+ }+ val requestFailure = chain.filterIsInstance<XtreamRequestException>().firstOrNull()+ return if (requestFailure?.statusCode == 401 || requestFailure?.statusCode == 403) {+ "FAILED_PERMANENT"+ } else {+ "FAILED_RETRYABLE"+ }+ }+}diff --git a/data/src/main/java/com/streamvault/data/sync/XtreamIndexWorker.kt b/data/src/main/java/com/streamvault/data/sync/XtreamIndexWorker.ktindex ce244f4d..1aac57b5 100644--- a/data/src/main/java/com/streamvault/data/sync/XtreamIndexWorker.kt+++ b/data/src/main/java/com/streamvault/data/sync/XtreamIndexWorker.kt@@ -36,7 +36,7 @@ class XtreamIndexWorker(@InstallIn(SingletonComponent::class)interface XtreamIndexWorkerEntryPoint {fun providerDao(): ProviderDao- fun syncManager(): SyncManager+ fun syncCommands(): ProviderSyncCommandsfun providerWorkflowRunner(): ProviderWorkflowRunner}@@ -73,7 +73,7 @@ class XtreamIndexWorker(reason = ProviderWorkflowReason.PERIODIC,force = force) {- when (val result = entryPoint.syncManager().processQueuedXtreamIndexJobs(+ when (val result = entryPoint.syncCommands().processQueuedXtreamIndexJobs(providerId = provider.id,section = requestedSection,force = force,diff --git a/data/src/test/java/com/streamvault/data/local/StreamVaultDatabaseMigrationRegistryTest.kt b/data/src/test/java/com/streamvault/data/local/StreamVaultDatabaseMigrationRegistryTest.ktnew file mode 100644index 00000000..71f11b73--- /dev/null+++ b/data/src/test/java/com/streamvault/data/local/StreamVaultDatabaseMigrationRegistryTest.kt@@ -0,0 +1,26 @@+package com.streamvault.data.local++import com.google.common.truth.Truth.assertThat+import org.junit.Test++class StreamVaultDatabaseMigrationRegistryTest {+ @Test+ fun `production registry covers every adjacent version through current schema`() {+ val migrations = StreamVaultDatabaseMigrationRegistry.all++ assertThat(migrations).hasSize(StreamVaultDatabaseMigrationRegistry.CURRENT_VERSION - 1)+ assertThat(migrations.map { it.startVersion })+ .containsExactlyElementsIn(1 until STREAM_VAULT_DATABASE_VERSION)+ assertThat(migrations.map { it.endVersion })+ .containsExactlyElementsIn(2..STREAM_VAULT_DATABASE_VERSION)+ }++ @Test+ fun `version groups preserve order`() {+ assertThat(StreamVaultDatabaseMigrationRegistry.v1To24.last().endVersion).isEqualTo(24)+ assertThat(StreamVaultDatabaseMigrationRegistry.v24To49.first().startVersion).isEqualTo(24)+ assertThat(StreamVaultDatabaseMigrationRegistry.v24To49.last().endVersion).isEqualTo(49)+ assertThat(StreamVaultDatabaseMigrationRegistry.v49To75.first().startVersion).isEqualTo(49)+ assertThat(StreamVaultDatabaseMigrationRegistry.v49To75.last().endVersion).isEqualTo(75)+ }+}diff --git a/data/src/test/java/com/streamvault/data/provider/ProviderExecutionArchitectureTest.kt b/data/src/test/java/com/streamvault/data/provider/ProviderExecutionArchitectureTest.ktindex 2f9b3362..be46dcaf 100644--- a/data/src/test/java/com/streamvault/data/provider/ProviderExecutionArchitectureTest.kt+++ b/data/src/test/java/com/streamvault/data/provider/ProviderExecutionArchitectureTest.kt@@ -58,10 +58,265 @@ class ProviderExecutionArchitectureTest {)assertThat(providerTypeDispatch.containsMatchIn(source)).isFalse()- assertThat(source).contains("providerSyncRegistry.resolve(snapshot)")- assertThat(source).contains("syncAdapter.syncFull(")- assertThat(source).contains("syncAdapter.syncSection(")- assertThat(source).contains("syncAdapter.syncGuide(")+ assertThat(source).contains("syncCoordinator.syncFull(")+ assertThat(source).contains("syncCoordinator.syncSection(")+ assertThat(source).contains("syncCoordinator.syncGuide(")+ assertThat(source).contains("continuationScheduler = ProviderContinuationScheduler(providerSyncWorkScheduler)")+ assertThat(repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/SyncManagerPlanDelegate.kt"+ ).readText()).contains("providerEpgExecutor.syncXtreamProviderEpg")+ val continuationScheduler = repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/ProviderContinuationScheduler.kt"+ ).readText()+ assertThat(continuationScheduler).contains("workScheduler.scheduleBackgroundEpg(providerId)")+ assertThat(continuationScheduler).contains("workScheduler.scheduleXtreamIndex(")+ assertThat(continuationScheduler).contains("workScheduler.scheduleStalkerIndex(")+ assertThat(source).contains("private val catalogIndexJobStore = CatalogIndexJobStore(")+ assertThat(source).contains("catalogIndexJobStore.upsert(")+ assertThat(source).doesNotContain("val providerType = providerDao.getById(providerId)?.type")+ assertThat(source).doesNotContain("val existing = xtreamIndexJobDao.get(providerId, section)")+ assertThat(source).contains("return providerWorkLocks.withProviderLock(providerId, block)")+ assertThat(+ Regex(+ """private suspend fun <T> withStalkerSummaryLock[\s\S]{0,300}withProviderLock\(providerId\)"""+ ).containsMatchIn(source)+ ).isTrue()+ assertThat(source).contains("vodCategoryHydrationCoordinator")+ assertThat(repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/VodCategoryHydrationCoordinator.kt"+ ).readText()).contains("providerSyncLocks.withVodCategoryLock(")+ assertThat(source).doesNotContain("providerSyncMutexes")+ assertThat(source).doesNotContain("providerEpgMutexes")+ assertThat(source).doesNotContain("syncAdmissionMutex")+ assertThat(source).doesNotContain("scheduleBackgroundEpg = ::scheduleBackgroundEpgSync")+ assertThat(source).doesNotContain("CatalogSyncPlanFactory.create(")+ assertThat(source).doesNotContain("providerSyncRegistry.resolve(snapshot)")+ assertThat(source).doesNotContain("syncAdapter.syncFull(")+ assertThat(source).doesNotContain("syncAdapter.syncSection(")+ assertThat(source).doesNotContain("syncAdapter.syncGuide(")+ }++ @Test+ fun `sync manager does not perform compatibility model projection`() {+ val manager = repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/SyncManager.kt"+ ).readText()++ assertThat(manager).contains("SyncProviderSnapshotAdapter")+ assertThat(manager).contains("SyncManagerPlanDelegate")+ assertThat(manager).doesNotContain("toLegacyProvider")+ assertThat(manager).doesNotContain("toProviderSnapshot")+ assertThat(manager).doesNotContain("toSyncCompatibilityProvider")+ }++ @Test+ fun `index checkpoint and recovery helpers live outside sync manager`() {+ val manager = repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/SyncManager.kt"+ ).readText()++ assertThat(manager).doesNotContain("getStalkerHydrationSnapshot")+ assertThat(manager).doesNotContain("markStalkerAttemptStarted")+ assertThat(manager).doesNotContain("markStalkerAttemptSucceeded")+ assertThat(manager).doesNotContain("markStalkerAttemptFailed")+ assertThat(manager).doesNotContain("stalkerIndexFailureState")+ assertThat(manager).doesNotContain("shouldRunXtreamSummaryIndex")+ assertThat(manager).doesNotContain("xtreamIndexFailureState")+ assertThat(repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/StalkerIndexCheckpointStore.kt"+ ).readText()).contains("class StalkerIndexCheckpointStore")+ assertThat(repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/StalkerIndexRecoveryPolicy.kt"+ ).readText()).contains("object StalkerIndexRecoveryPolicy")+ assertThat(repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/XtreamIndexRecoveryPolicy.kt"+ ).readText()).contains("object XtreamIndexRecoveryPolicy")+ }++ @Test+ fun `workers and repositories consume narrow sync ports`() {+ val consumerPaths = listOf(+ "data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt",+ "data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt",+ "data/src/main/java/com/streamvault/data/repository/VodRepositoryImpl.kt",+ "data/src/main/java/com/streamvault/data/repository/ProviderRepositoryImpl.kt",+ "data/src/main/java/com/streamvault/data/repository/ProviderDeletionCleanupWorker.kt",+ "data/src/main/java/com/streamvault/data/sync/ProviderSyncWorker.kt",+ "data/src/main/java/com/streamvault/data/sync/BackgroundEpgSyncWorker.kt",+ "data/src/main/java/com/streamvault/data/sync/XtreamIndexWorker.kt",+ "data/src/main/java/com/streamvault/data/sync/StalkerIndexWorker.kt",+ "data/src/main/java/com/streamvault/data/sync/ProviderSyncStateReaderImpl.kt"+ )++ consumerPaths.forEach { relative ->+ val source = repositoryRoot.resolve(relative).readText()+ assertThat(source).doesNotContain(": SyncManager")+ assertThat(source).doesNotContain("fun syncManager(): SyncManager")+ }++ assertThat(repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/ProviderSyncPorts.kt"+ ).toFile().isFile).isTrue()+ }++ @Test+ fun `small provider execution lives outside the sync manager`() {+ val manager = repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/SyncManager.kt"+ ).readText()++ assertThat(manager).doesNotContain("private suspend fun syncM3u(")+ assertThat(manager).doesNotContain("private suspend fun syncM3uLiveOnly(")+ assertThat(manager).doesNotContain("private suspend fun syncM3uMoviesOnly(")+ assertThat(manager).doesNotContain("private suspend fun syncJellyfin(")+ assertThat(manager).doesNotContain("private suspend fun syncJellyfinMoviesOnly(")+ assertThat(manager).doesNotContain("private suspend fun syncJellyfinSeriesOnly(")+ assertThat(manager).doesNotContain("private suspend fun syncXtreamMoviesOnly(")+ assertThat(manager).doesNotContain("private suspend fun syncXtreamSeriesOnly(")+ assertThat(manager).doesNotContain("private suspend fun syncXtreamIndexFirst(")+ assertThat(manager).doesNotContain("private suspend fun syncXtreamLiveOnly(")+ assertThat(manager).doesNotContain("private suspend fun syncXtreamCategoryShell(")+ assertThat(manager).doesNotContain("private suspend fun syncStalker(")+ assertThat(manager).doesNotContain("private suspend fun syncStalkerLiveOnly(")+ assertThat(manager).doesNotContain("private suspend fun syncProviderEpg(")+ assertThat(manager).doesNotContain("private suspend fun syncXtreamProviderEpg(")+ assertThat(manager).doesNotContain("private suspend fun syncM3uProviderEpg(")+ assertThat(manager).doesNotContain("private suspend fun syncStalkerProviderEpg(")+ assertThat(manager).doesNotContain("private suspend fun syncXmlTvEpgOnly(")+ assertThat(manager).doesNotContain("private suspend fun syncStalkerMoviesOnly(")+ assertThat(manager).doesNotContain("private suspend fun syncStalkerSeriesOnly(")+ assertThat(manager).doesNotContain("private suspend fun queueStalkerIndexSection(")+ assertThat(manager).doesNotContain("StalkerBrokenPerChannelEpgException")+ assertThat(manager).contains("private val stalkerIndexJobStore: StalkerIndexJobStore")+ assertThat(manager).doesNotContain("stalkerIndexJobDao.")+ assertThat(manager).doesNotContain("shouldRunStalkerSummaryIndex")+ assertThat(manager).doesNotContain("toLegacyJobState")++ val stalkerIndexJobStore = repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/StalkerIndexJobStore.kt"+ ).readText()+ assertThat(stalkerIndexJobStore).contains("class StalkerIndexJobStore")+ assertThat(stalkerIndexJobStore).contains("StalkerIndexJobUpdate")+ assertThat(stalkerIndexJobStore).contains("fun shouldRunSummary")+ assertThat(stalkerIndexJobStore).contains("fun upsertLegacy")++ val epgExecutor = repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/ProviderEpgSyncExecutor.kt"+ ).readText()+ assertThat(epgExecutor).contains("private suspend fun syncStalkerPreferredEpg(")+ assertThat(epgExecutor).contains("private suspend fun syncStalkerPortalEpg(")+ assertThat(epgExecutor).contains("stalkerRequestCoordinator.execute(")++ assertThat(repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/M3uCatalogSyncExecutor.kt"+ ).toFile().isFile).isTrue()+ assertThat(repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/JellyfinCatalogSyncExecutor.kt"+ ).toFile().isFile).isTrue()+ assertThat(repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/XtreamCatalogSectionExecutor.kt"+ ).toFile().isFile).isTrue()+ assertThat(repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/XtreamCatalogSyncExecutor.kt"+ ).toFile().isFile).isTrue()+ assertThat(repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/StalkerCatalogSectionExecutor.kt"+ ).toFile().isFile).isTrue()+ assertThat(repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/StalkerCatalogSyncExecutor.kt"+ ).toFile().isFile).isTrue()+ assertThat(repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/ProviderEpgSyncExecutor.kt"+ ).toFile().isFile).isTrue()+ }++ @Test+ fun `major sync coordinators stay within explicit dependency budgets`() {+ val budgets = listOf(+ DependencyBudget(+ path = "data/src/main/java/com/streamvault/data/sync/SyncManager.kt",+ className = "SyncManager",+ maxConstructorDependencies = 40+ ),+ DependencyBudget(+ path = "data/src/main/java/com/streamvault/data/sync/SyncCoordinator.kt",+ className = "SyncCoordinator",+ maxConstructorDependencies = 2+ ),+ DependencyBudget(+ path = "data/src/main/java/com/streamvault/data/sync/VodCategoryHydrationCoordinator.kt",+ className = "VodCategoryHydrationCoordinator",+ maxConstructorDependencies = 11+ ),+ DependencyBudget(+ path = "data/src/main/java/com/streamvault/data/sync/StalkerIndexContinuationCoordinator.kt",+ className = "StalkerIndexContinuationCoordinator",+ maxConstructorDependencies = 11+ ),+ DependencyBudget(+ path = "data/src/main/java/com/streamvault/data/sync/StalkerIncrementalIndexExecutor.kt",+ className = "StalkerIncrementalIndexExecutor",+ maxConstructorDependencies = 1+ ),+ DependencyBudget(+ path = "data/src/main/java/com/streamvault/data/sync/XtreamIncrementalIndexExecutor.kt",+ className = "XtreamIncrementalIndexExecutor",+ maxConstructorDependencies = 1+ ),+ DependencyBudget(+ path = "data/src/main/java/com/streamvault/data/sync/SyncStatusPublicationCoordinator.kt",+ className = "SyncStatusPublicationCoordinator",+ maxConstructorDependencies = 3+ )+ )++ budgets.forEach { budget ->+ val source = repositoryRoot.resolve(budget.path).readText()+ val actual = constructorDependencyCount(source, budget.className)+ assertThat(actual).isAtMost(budget.maxConstructorDependencies)+ }++ val manager = repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/SyncManager.kt"+ ).readText()+ val continuation = repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/StalkerIndexContinuationCoordinator.kt"+ ).readText()+ assertThat(manager).contains("stalkerIndexContinuationCoordinator")+ assertThat(manager).contains("stalkerIncrementalIndexExecutor")+ assertThat(manager).doesNotContain("private suspend fun processStalkerSummaryIndexSection(")+ assertThat(manager).contains("xtreamIncrementalIndexExecutor.processSummary(")+ assertThat(manager).doesNotContain("private suspend fun processXtreamSummaryIndexSection(")+ assertThat(manager).contains("syncStatusPublicationCoordinator")+ assertThat(manager).doesNotContain("private val stateSessions")+ assertThat(manager).doesNotContain("private val progressSessions")+ assertThat(manager).doesNotContain("private suspend fun stalkerCatalogSectionState(")+ assertThat(manager).doesNotContain("private suspend fun scheduleNextStalkerCatalogStep(")+ assertThat(continuation).contains("suspend fun reconcileAtStartup()")+ assertThat(continuation).contains("scheduleNextSection")+ assertThat(continuation).contains("StalkerIndexPolicy.nextRetryDelaySeconds")++ val incremental = repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/StalkerIncrementalIndexExecutor.kt"+ ).readText()+ assertThat(incremental).contains("suspend fun processSummary(")+ assertThat(incremental).contains("private suspend fun processWildcard(")+ assertThat(incremental).contains("StalkerIndexPolicy.detectPageAnomaly")++ val xtreamIncremental = repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/XtreamIncrementalIndexExecutor.kt"+ ).readText()+ assertThat(xtreamIncremental).contains("suspend fun processSummary(")+ assertThat(xtreamIncremental).contains("private suspend fun streamFullSummary(")+ assertThat(xtreamIncremental).contains("shouldAttemptFullStream")++ val publication = repositoryRoot.resolve(+ "data/src/main/java/com/streamvault/data/sync/SyncStatusPublicationCoordinator.kt"+ ).readText()+ assertThat(publication).contains("suspend fun updateSummaryMetadata(")+ assertThat(publication).contains("suspend fun markMovieIndexRebuildAttempt(")+ assertThat(publication).contains("fun beginStateSession(")+ assertThat(publication).contains("fun finishProgressSession(")}@Test@@ -85,4 +340,58 @@ class ProviderExecutionArchitectureTest {repositoryRoot.relativize(this).invariantSeparatorsPathStringprivate fun Path.readText(): String = String(Files.readAllBytes(this), Charsets.UTF_8)++ private data class DependencyBudget(+ val path: String,+ val className: String,+ val maxConstructorDependencies: Int+ )++ private fun constructorDependencyCount(source: String, className: String): Int {+ val classStart = source.indexOf("class $className")+ require(classStart >= 0) { "Class $className not found" }+ val openParen = source.indexOf("constructor(", classStart)+ .takeIf { it >= 0 }+ ?.plus("constructor".length)+ ?: source.indexOf('(', classStart)+ var depth = 0+ var closeParen = -1+ for (index in openParen until source.length) {+ when (source[index]) {+ '(' -> depth += 1+ ')' -> {+ depth -= 1+ if (depth == 0) {+ closeParen = index+ break+ }+ }+ }+ }+ require(closeParen > openParen) { "Constructor for $className is not balanced" }+ return source.substring(openParen + 1, closeParen)+ .splitTopLevel(',')+ .count { it.isNotBlank() }+ }++ private fun String.splitTopLevel(delimiter: Char): List<String> {+ val parts = mutableListOf<String>()+ var start = 0+ var parenDepth = 0+ var angleDepth = 0+ for (index in indices) {+ when (this[index]) {+ '(' -> parenDepth += 1+ ')' -> parenDepth -= 1+ '<' -> angleDepth += 1+ '>' -> angleDepth = (angleDepth - 1).coerceAtLeast(0)+ delimiter -> if (parenDepth == 0 && angleDepth == 0) {+ parts += substring(start, index)+ start = index + 1+ }+ }+ }+ parts += substring(start)+ return parts+ }}diff --git a/data/src/test/java/com/streamvault/data/sync/CatalogIndexJobStoreTest.kt b/data/src/test/java/com/streamvault/data/sync/CatalogIndexJobStoreTest.ktnew file mode 100644index 00000000..89f3bb3b--- /dev/null+++ b/data/src/test/java/com/streamvault/data/sync/CatalogIndexJobStoreTest.kt@@ -0,0 +1,200 @@+package com.streamvault.data.sync++import com.google.common.truth.Truth.assertThat+import com.streamvault.data.local.dao.ProviderDao+import com.streamvault.data.local.dao.StalkerIndexJobDao+import com.streamvault.data.local.dao.XtreamIndexJobDao+import com.streamvault.data.local.entity.ProviderEntity+import com.streamvault.data.local.entity.StalkerIndexJobEntity+import com.streamvault.data.local.entity.XtreamIndexJobEntity+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.ProviderType+import com.streamvault.domain.model.StalkerIndexState+import kotlinx.coroutines.test.runTest+import org.junit.Test+import org.mockito.kotlin.any+import org.mockito.kotlin.argumentCaptor+import org.mockito.kotlin.eq+import org.mockito.kotlin.mock+import org.mockito.kotlin.never+import org.mockito.kotlin.verify+import org.mockito.kotlin.whenever++class CatalogIndexJobStoreTest {+ private val providerDao = mock<ProviderDao>()+ private val xtreamDao = mock<XtreamIndexJobDao>()+ private val stalkerDao = mock<StalkerIndexJobDao>()+ private val store = CatalogIndexJobStore(+ providerDao = providerDao,+ xtreamIndexJobDao = xtreamDao,+ stalkerIndexJobStore = StalkerIndexJobStore(stalkerDao)+ )++ @Test+ fun `xtream upsert patches existing durable job and clears priority when requested`() = runTest {+ whenever(providerDao.getById(7L)).thenReturn(ProviderEntity(7L, "Xtream", ProviderType.XTREAM_CODES))+ whenever(xtreamDao.get(7L, ContentType.MOVIE.name)).thenReturn(+ XtreamIndexJobEntity(+ providerId = 7L,+ section = ContentType.MOVIE.name,+ state = "RUNNING",+ totalCategories = 12,+ completedCategories = 4,+ priorityCategoryId = 44L,+ priorityRequestedAt = 91L,+ lastSuccessAt = 82L+ )+ )++ store.upsert(+ CatalogIndexJobUpdate(+ providerId = 7L,+ section = ContentType.MOVIE.name,+ state = "SUCCESS",+ now = 100L,+ completedCategories = 12,+ clearPriority = true,+ lastSuccessAt = 100L+ )+ )++ val captured = argumentCaptor<XtreamIndexJobEntity>()+ verify(xtreamDao).upsert(captured.capture())+ assertThat(captured.firstValue.state).isEqualTo("SUCCESS")+ assertThat(captured.firstValue.totalCategories).isEqualTo(12)+ assertThat(captured.firstValue.completedCategories).isEqualTo(12)+ assertThat(captured.firstValue.priorityCategoryId).isNull()+ assertThat(captured.firstValue.priorityRequestedAt).isEqualTo(0L)+ assertThat(captured.firstValue.lastSuccessAt).isEqualTo(100L)+ }++ @Test+ fun `stalker movie updates route to the typed stalker job store`() = runTest {+ whenever(providerDao.getById(8L)).thenReturn(ProviderEntity(8L, "Portal", ProviderType.STALKER_PORTAL))+ whenever(stalkerDao.get(8L, ContentType.MOVIE.name)).thenReturn(null)++ store.upsert(+ CatalogIndexJobUpdate(+ providerId = 8L,+ section = ContentType.MOVIE.name,+ state = "FAILED_RETRYABLE",+ now = 200L,+ totalCategories = 3,+ failedCategories = 1,+ lastError = "temporary"+ )+ )++ verify(xtreamDao, never()).get(any(), any())+ verify(xtreamDao, never()).upsert(any())+ val captured = argumentCaptor<StalkerIndexJobEntity>()+ verify(stalkerDao).upsert(captured.capture())+ assertThat(captured.firstValue.section).isEqualTo(ContentType.MOVIE)+ assertThat(captured.firstValue.state).isEqualTo(StalkerIndexState.RETRY_WAIT)+ assertThat(captured.firstValue.totalCategories).isEqualTo(3)+ assertThat(captured.firstValue.failedCategories).isEqualTo(1)+ }++ @Test+ fun `summary refresh policy runs missing and pending jobs but not fresh success`() {+ assertThat(store.shouldRunSummary(null)).isTrue()+ assertThat(store.shouldRunSummary(XtreamIndexJobEntity(1L, "MOVIE", state = "QUEUED"))).isTrue()+ assertThat(+ store.shouldRunSummary(+ XtreamIndexJobEntity(+ 1L,+ "MOVIE",+ state = "SUCCESS",+ lastSuccessAt = System.currentTimeMillis() - 1L+ )+ )+ ).isFalse()+ }++ @Test+ fun `every persisted xtream index state has an explicit process death policy`() {+ val recoverableAfterProcessDeath = setOf(+ "QUEUED",+ "RUNNING",+ "PARTIAL",+ "STALE",+ "FAILED_RETRYABLE"+ )+ val terminalStates = setOf(+ "SUCCESS",+ "FAILED_PERMANENT",+ "TRUNCATED",+ "DISABLED",+ "IDLE"+ )++ recoverableAfterProcessDeath.forEach { state ->+ assertThat(+ store.shouldRunSummary(+ XtreamIndexJobEntity(1L, "MOVIE", state = state, lastSuccessAt = Long.MAX_VALUE)+ )+ ).isTrue()+ }+ terminalStates.forEach { state ->+ assertThat(+ store.shouldRunSummary(+ XtreamIndexJobEntity(+ 1L,+ "MOVIE",+ state = state,+ lastSuccessAt = System.currentTimeMillis()+ )+ )+ ).isFalse()+ }+ }++ @Test+ fun `every persisted stalker index state round trips and keeps recovery semantics`() = runTest {+ val stalkerStore = StalkerIndexJobStore(stalkerDao)+ val expectedLegacyStates = mapOf(+ StalkerIndexState.DISABLED to "DISABLED",+ StalkerIndexState.QUEUED to "QUEUED",+ StalkerIndexState.RUNNING to "RUNNING",+ StalkerIndexState.RETRY_WAIT to "FAILED_RETRYABLE",+ StalkerIndexState.PARTIAL to "PARTIAL",+ StalkerIndexState.COMPLETE to "SUCCESS",+ StalkerIndexState.TRUNCATED to "TRUNCATED",+ StalkerIndexState.FAILED to "FAILED_PERMANENT"+ )++ expectedLegacyStates.forEach { (state, legacy) ->+ whenever(stalkerDao.get(8L, ContentType.MOVIE.name)).thenReturn(null)+ stalkerStore.upsertLegacy(+ providerId = 8L,+ section = ContentType.MOVIE,+ state = legacy,+ now = 200L,+ lastSuccessAt = if (state in setOf(+ StalkerIndexState.COMPLETE,+ StalkerIndexState.TRUNCATED,+ StalkerIndexState.FAILED,+ StalkerIndexState.DISABLED+ )+ ) System.currentTimeMillis() else 0L+ )++ val captured = argumentCaptor<StalkerIndexJobEntity>()+ verify(stalkerDao, org.mockito.kotlin.atLeastOnce()).upsert(captured.capture())+ assertThat(captured.allValues.last().state).isEqualTo(state)+ assertThat(stalkerStore.toLegacyState(state)).isEqualTo(legacy)+ assertThat(+ stalkerStore.shouldRunSummary(+ captured.allValues.last().copy(lastSuccessAt = System.currentTimeMillis())+ )+ ).isEqualTo(+ state in setOf(+ StalkerIndexState.QUEUED,+ StalkerIndexState.RUNNING,+ StalkerIndexState.RETRY_WAIT,+ StalkerIndexState.PARTIAL+ )+ )+ }+ }+}diff --git a/data/src/test/java/com/streamvault/data/sync/ProviderSyncLockRegistryTest.kt b/data/src/test/java/com/streamvault/data/sync/ProviderSyncLockRegistryTest.ktnew file mode 100644index 00000000..96b58893--- /dev/null+++ b/data/src/test/java/com/streamvault/data/sync/ProviderSyncLockRegistryTest.kt@@ -0,0 +1,65 @@+package com.streamvault.data.sync++import com.google.common.truth.Truth.assertThat+import com.streamvault.domain.model.ContentType+import kotlinx.coroutines.CompletableDeferred+import kotlinx.coroutines.ExperimentalCoroutinesApi+import kotlinx.coroutines.async+import kotlinx.coroutines.test.runCurrent+import kotlinx.coroutines.test.runTest+import org.junit.Test++@OptIn(ExperimentalCoroutinesApi::class)+class ProviderSyncLockRegistryTest {+ @Test+ fun `same category hydration is serialized`() = runTest {+ val registry = ProviderSyncLockRegistry()+ val firstEntered = CompletableDeferred<Unit>()+ val releaseFirst = CompletableDeferred<Unit>()+ val secondEntered = CompletableDeferred<Unit>()++ val first = async {+ registry.withVodCategoryLock(7L, 11L, splitCatalog = false) {+ firstEntered.complete(Unit)+ releaseFirst.await()+ }+ }+ firstEntered.await()++ val second = async {+ registry.withVodCategoryLock(7L, 11L, splitCatalog = false) {+ secondEntered.complete(Unit)+ }+ }+ runCurrent()++ assertThat(secondEntered.isCompleted).isFalse()+ releaseFirst.complete(Unit)+ first.await()+ second.await()+ assertThat(secondEntered.isCompleted).isTrue()+ }++ @Test+ fun `different category and section keys do not block each other`() = runTest {+ val registry = ProviderSyncLockRegistry()+ val categoryEntered = CompletableDeferred<Unit>()+ val sectionEntered = CompletableDeferred<Unit>()++ val category = async {+ registry.withVodCategoryLock(7L, 11L, splitCatalog = false) {+ categoryEntered.complete(Unit)+ }+ }+ val section = async {+ registry.withStalkerIndexSectionLock(7L, ContentType.MOVIE) {+ sectionEntered.complete(Unit)+ }+ }++ category.await()+ section.await()+ assertThat(categoryEntered.isCompleted).isTrue()+ assertThat(sectionEntered.isCompleted).isTrue()+ }+}diff --git a/data/src/test/java/com/streamvault/data/sync/ProviderWorkLockRegistryTest.kt b/data/src/test/java/com/streamvault/data/sync/ProviderWorkLockRegistryTest.ktindex 2272da0f..3c2e97de 100644--- a/data/src/test/java/com/streamvault/data/sync/ProviderWorkLockRegistryTest.kt+++ b/data/src/test/java/com/streamvault/data/sync/ProviderWorkLockRegistryTest.kt@@ -6,6 +6,7 @@ import kotlinx.coroutines.ExperimentalCoroutinesApiimport kotlinx.coroutines.asyncimport kotlinx.coroutines.test.runCurrentimport kotlinx.coroutines.test.runTest+import java.util.concurrent.atomic.AtomicIntegerimport org.junit.Test@OptIn(ExperimentalCoroutinesApi::class)@@ -43,6 +44,39 @@ class ProviderWorkLockRegistryTest {assertThat(registry.isAnyWorkActiveOrWaiting()).isFalse()}+ @Test+ fun `manual and background sync for one provider never overlap`() = runTest {+ val registry = ProviderWorkLockRegistry()+ val releaseManual = CompletableDeferred<Unit>()+ val backgroundEntered = CompletableDeferred<Unit>()+ val manualEntered = CompletableDeferred<Unit>()+ val active = AtomicInteger(0)+ var maximumActive = 0++ suspend fun run(entered: CompletableDeferred<Unit>, wait: Boolean) {+ registry.withProviderLock(7L) {+ val current = active.incrementAndGet()+ maximumActive = maxOf(maximumActive, current)+ entered.complete(Unit)+ if (wait) releaseManual.await()+ active.decrementAndGet()+ }+ }++ val manual = async { run(manualEntered, wait = true) }+ manualEntered.await()+ val background = async { run(backgroundEntered, wait = false) }+ runCurrent()++ assertThat(backgroundEntered.isCompleted).isFalse()+ releaseManual.complete(Unit)+ manual.await()+ background.await()++ assertThat(maximumActive).isEqualTo(1)+ assertThat(registry.isAnyWorkActiveOrWaiting()).isFalse()+ }+@Testfun `different providers retain independent execution lanes`() = runTest {val registry = ProviderWorkLockRegistry()diff --git a/data/src/test/java/com/streamvault/data/sync/ProviderWorkflowCommitFenceTest.kt b/data/src/test/java/com/streamvault/data/sync/ProviderWorkflowCommitFenceTest.ktindex 40f91e07..dff6336f 100644--- a/data/src/test/java/com/streamvault/data/sync/ProviderWorkflowCommitFenceTest.kt+++ b/data/src/test/java/com/streamvault/data/sync/ProviderWorkflowCommitFenceTest.kt@@ -2,6 +2,7 @@ package com.streamvault.data.syncimport androidx.room.Roomimport com.google.common.truth.Truth.assertThat+import com.streamvault.data.local.DatabaseTransactionRunnerimport com.streamvault.data.local.RoomDatabaseTransactionRunnerimport com.streamvault.data.local.StreamVaultDatabaseimport com.streamvault.data.local.entity.ChannelEntity@@ -137,17 +138,78 @@ class ProviderWorkflowCommitFenceTest {assertThat(retained.streamUrl).isEqualTo("old")}- private fun store() = SyncCatalogStore(+ @Test+ fun `cancellation before catalog commit retains committed catalog and clears staging`() = runTest {+ insertProvider()+ database.channelDao().insertAll(listOf(channel(name = "Committed", streamUrl = "old")))++ val error = runCatching {+ store(transactionRunner = transactionRunner(failBeforeCommit = true)).replaceLiveCatalog(+ providerId = PROVIDER_ID,+ categories = null,+ channels = listOf(channel(name = "Candidate", streamUrl = "new"))+ )+ }.exceptionOrNull()++ assertThat(error).isInstanceOf(CancellationException::class.java)+ val retained = database.channelDao().getByProviderSync(PROVIDER_ID).single()+ assertThat(retained.name).isEqualTo("Committed")+ assertThat(database.catalogSyncDao().countChannelStages(PROVIDER_ID, Long.MAX_VALUE)).isEqualTo(0)+ }++ @Test+ fun `cancellation after catalog transaction commits leaves the committed catalog durable`() = runTest {+ insertProvider()+ database.channelDao().insertAll(listOf(channel(name = "Committed", streamUrl = "old")))++ val error = runCatching {+ store(transactionRunner = transactionRunner(failAfterCommit = true)).replaceLiveCatalog(+ providerId = PROVIDER_ID,+ categories = null,+ channels = listOf(channel(name = "Candidate", streamUrl = "new"))+ )+ }.exceptionOrNull()++ assertThat(error).isInstanceOf(CancellationException::class.java)+ val retained = database.channelDao().getByProviderSync(PROVIDER_ID).single()+ assertThat(retained.name).isEqualTo("Candidate")+ assertThat(retained.streamUrl).isEqualTo("new")+ }++ private fun store(+ transactionRunner: DatabaseTransactionRunner = RoomDatabaseTransactionRunner(database)+ ) = SyncCatalogStore(channelDao = database.channelDao(),movieDao = database.movieDao(),seriesDao = database.seriesDao(),categoryDao = database.categoryDao(),catalogSyncDao = database.catalogSyncDao(),tmdbIdentityDao = database.tmdbIdentityDao(),- transactionRunner = RoomDatabaseTransactionRunner(database),+ transactionRunner = transactionRunner,workflowCommitFence = ProviderWorkflowCommitFence(database.providerWorkflowDao()))+ private fun transactionRunner(+ failBeforeCommit: Boolean = false,+ failAfterCommit: Boolean = false+ ): DatabaseTransactionRunner {+ val delegate = RoomDatabaseTransactionRunner(database)+ var calls = 0+ return object : DatabaseTransactionRunner {+ override suspend fun <T> inTransaction(block: suspend () -> T): T {+ calls += 1+ if (failBeforeCommit && calls == 2) {+ throw CancellationException("cancelled before catalog commit")+ }+ val result = delegate.inTransaction(block)+ if (failAfterCommit && calls == 2) {+ throw CancellationException("cancelled after catalog commit")+ }+ return result+ }+ }+ }+private suspend fun insertProvider() {database.providerDao().insert(ProviderEntity(diff --git a/data/src/test/java/com/streamvault/data/sync/StalkerIndexPolicyTest.kt b/data/src/test/java/com/streamvault/data/sync/StalkerIndexPolicyTest.ktnew file mode 100644index 00000000..3621d5b0--- /dev/null+++ b/data/src/test/java/com/streamvault/data/sync/StalkerIndexPolicyTest.kt@@ -0,0 +1,147 @@+package com.streamvault.data.sync++import com.google.common.truth.Truth.assertThat+import com.streamvault.data.remote.stalker.StalkerPagedResult+import com.streamvault.domain.model.CatalogLayout+import com.streamvault.domain.model.ContentType+import org.junit.Test++class StalkerIndexPolicyTest {+ @Test+ fun `split catalogs finish series before derived movie supplementation`() {+ val decision = StalkerIndexPolicy.chooseNextSection(+ layout = CatalogLayout.SPLIT,+ requestedSection = null,+ movie = section(ContentType.MOVIE, updatedAt = 1L),+ series = section(ContentType.SERIES, updatedAt = 100L)+ )++ assertThat(decision.contentType).isEqualTo(ContentType.SERIES)+ }++ @Test+ fun `unified catalogs choose the oldest runnable section`() {+ val decision = StalkerIndexPolicy.chooseNextSection(+ layout = CatalogLayout.UNIFIED_VOD,+ requestedSection = null,+ movie = section(ContentType.MOVIE, updatedAt = 200L),+ series = section(ContentType.SERIES, updatedAt = 100L)+ )++ assertThat(decision.contentType).isEqualTo(ContentType.SERIES)+ }++ @Test+ fun `retry delay uses the earliest eligible hydration deadline`() {+ val now = 10_000L+ val delay = StalkerIndexPolicy.nextRetryDelaySeconds(+ hydrations = listOf(+ snapshot(retryAfterMs = now + 4_001L),+ snapshot(retryAfterMs = now + 1_001L)+ ),+ now = now+ )++ assertThat(delay).isEqualTo(2L)+ }++ @Test+ fun `continuation retries the failed page and advances after success`() {+ assertThat(+ StalkerIndexPolicy.nextAttemptPage(+ snapshot(lastAttemptedPage = 7, lastSuccessfulPage = 6, lastStatus = "FAILED_RETRYABLE")+ )+ ).isEqualTo(7)+ assertThat(+ StalkerIndexPolicy.nextAttemptPage(+ snapshot(lastAttemptedPage = 7, lastSuccessfulPage = 7, lastStatus = "SUCCESS")+ )+ ).isEqualTo(8)+ }++ @Test+ fun `anomaly detection rejects wrong page and repeated payload`() {+ val wrongPage = StalkerIndexPolicy.detectPageAnomaly(+ hydration = null,+ requestedPage = 3,+ pagedResult = page(page = 2),+ pageFingerprint = null+ )+ val repeatedPage = StalkerIndexPolicy.detectPageAnomaly(+ hydration = snapshot(+ lastAttemptedPage = 3,+ lastSuccessfulPage = 2,+ totalPages = 5,+ lastStatus = "FAILED_RETRYABLE",+ lastPageFingerprint = "same"+ ),+ requestedPage = 3,+ pagedResult = page(page = 3, totalPages = 5),+ pageFingerprint = "same"+ )++ assertThat(wrongPage).contains("while page 3 was requested")+ assertThat(repeatedPage).contains("repeated the same page payload")+ }++ @Test+ fun `completed, truncated, and exhausted categories are not attemptable`() {+ val now = 100L+ assertThat(StalkerIndexPolicy.canAttempt(snapshot(isComplete = true), now)).isFalse()+ assertThat(StalkerIndexPolicy.canAttempt(snapshot(lastStatus = "TRUNCATED"), now)).isFalse()+ assertThat(StalkerIndexPolicy.canAttempt(snapshot(retryBudgetRemaining = 0), now)).isFalse()+ assertThat(StalkerIndexPolicy.canAttempt(snapshot(retryAfterMs = now + 1), now)).isFalse()+ assertThat(StalkerIndexPolicy.canAttempt(snapshot(retryAfterMs = now), now)).isTrue()+ assertThat(StalkerIndexPolicy.canAttempt(null, now)).isTrue()+ }++ private fun section(+ contentType: ContentType,+ updatedAt: Long,+ runnable: Boolean = true,+ pending: Boolean = true,+ retryDelaySeconds: Long = 0L+ ) = StalkerCatalogSectionState(+ contentType = contentType,+ runnable = runnable,+ retryDelaySeconds = retryDelaySeconds,+ pending = pending,+ jobState = "QUEUED",+ updatedAt = updatedAt+ )++ private fun snapshot(+ lastStatus: String = "SUCCESS",+ lastAttemptedPage: Int = 1,+ lastSuccessfulPage: Int = 1,+ totalPages: Int = 1,+ retryAfterMs: Long = 0L,+ retryBudgetRemaining: Int = 3,+ isComplete: Boolean = false,+ lastPageFingerprint: String? = null+ ) = StalkerHydrationSnapshot(+ lastHydratedAt = 0L,+ itemCount = 0,+ lastStatus = lastStatus,+ lastError = null,+ lastLoadedPage = lastSuccessfulPage,+ lastAttemptedPage = lastAttemptedPage,+ lastSuccessfulPage = lastSuccessfulPage,+ totalPages = totalPages,+ advertisedTotalItems = null,+ advertisedTotalPages = null,+ isComplete = isComplete,+ pageSize = 100,+ retryAfterMs = retryAfterMs,+ failureCount = 0,+ retryBudgetRemaining = retryBudgetRemaining,+ lastPageFingerprint = lastPageFingerprint+ )++ private fun page(page: Int, totalPages: Int = 1) = StalkerPagedResult(+ items = emptyList<String>(),+ page = page,+ totalPages = totalPages,+ pageSize = 100+ )+}diff --git a/data/src/test/java/com/streamvault/data/sync/SyncCoordinatorTest.kt b/data/src/test/java/com/streamvault/data/sync/SyncCoordinatorTest.ktnew file mode 100644index 00000000..c367e4ce--- /dev/null+++ b/data/src/test/java/com/streamvault/data/sync/SyncCoordinatorTest.kt@@ -0,0 +1,282 @@+package com.streamvault.data.sync++import com.google.common.truth.Truth.assertThat+import com.streamvault.domain.model.JellyfinConfig+import com.streamvault.domain.model.M3uConfig+import com.streamvault.domain.model.Provider+import com.streamvault.domain.model.ProviderConfiguration+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 com.streamvault.domain.model.SyncState+import com.streamvault.domain.model.XtreamConfig+import com.streamvault.domain.provider.CapabilityResolution+import kotlinx.coroutines.test.runTest+import org.junit.Assert.assertThrows+import org.junit.Test++class SyncCoordinatorTest {+ @Test+ fun `full sync is routed to the provider catalog plan`() = runTest {+ val expected = SyncOutcome(+ partial = true,+ warnings = listOf("catalog resumed"),+ stagedMutations = 42,+ continuationWork = listOf(+ SyncContinuation(+ operation = SyncContinuationOperation.INDEX_CATALOG,+ section = com.streamvault.domain.model.ContentType.MOVIE,+ reason = "catalog is intentionally paged"+ )+ ),+ activation = SyncActivation.ACTIVATED_CATALOG+ )+ val coordinator = coordinatorFor(expected)++ val result = coordinator.syncFull(+ FullProviderSyncRequest(+ snapshot = snapshot(ProviderType.M3U),+ force = false,+ onProgress = null,+ trackInitialLiveOnboarding = false,+ deferProviderStateUntilCatalogCommit = false,+ afterCatalogApply = {}+ )+ )++ assertThat(result).isEqualTo(CapabilityResolution.Available(expected))+ }++ @Test+ fun `registry requires one plan for every provider type`() {+ assertThrows(IllegalArgumentException::class.java) {+ CatalogSyncPlanRegistry(+ ProviderType.entries.drop(1).map { planFor(it, SyncOutcome()) }+ )+ }+ }++ @Test+ fun `activation follow-up must declare durable continuation work`() {+ val coordinator = coordinatorFor(+ SyncOutcome(activation = SyncActivation.DEFERRED_TO_FOLLOW_UP)+ )++ assertThrows(IllegalArgumentException::class.java) {+ kotlinx.coroutines.runBlocking {+ coordinator.syncFull(+ FullProviderSyncRequest(+ snapshot = snapshot(ProviderType.M3U),+ force = false,+ onProgress = null,+ trackInitialLiveOnboarding = false,+ deferProviderStateUntilCatalogCommit = false,+ afterCatalogApply = {}+ )+ )+ }+ }+ }++ @Test+ fun `accepted mutations require an activated catalog receipt`() {+ val coordinator = coordinatorFor(+ SyncOutcome(stagedMutations = 1, activation = SyncActivation.NO_CATALOG_CHANGE)+ )++ assertThrows(IllegalArgumentException::class.java) {+ kotlinx.coroutines.runBlocking { coordinator.syncFull(fullRequest(snapshot(ProviderType.M3U))) }+ }+ }++ @Test+ fun `coordinator hands typed continuation work to the durable scheduler`() = runTest {+ val continuation = SyncContinuation(+ operation = SyncContinuationOperation.INDEX_CATALOG,+ section = com.streamvault.domain.model.ContentType.MOVIE,+ reason = "index accepted movie categories"+ )+ val scheduled = mutableListOf<SyncContinuation>()+ val outcome = SyncOutcome(+ continuationWork = listOf(continuation),+ activation = SyncActivation.DEFERRED_TO_FOLLOW_UP+ )+ val coordinator = SyncCoordinator(+ CatalogSyncPlanRegistry(ProviderType.entries.map { planFor(it, outcome) }),+ SyncContinuationScheduler { _, work -> scheduled += work }+ )++ assertThat(coordinator.syncFull(fullRequest(snapshot(ProviderType.XTREAM_CODES))))+ .isEqualTo(CapabilityResolution.Available(outcome))+ assertThat(scheduled).containsExactly(continuation)+ }++ @Test+ fun `preserving active catalog is surfaced as partial activation`() {+ assertThat(+ SyncOutcome(activation = SyncActivation.PRESERVED_ACTIVE_CATALOG)+ .requiresPartialActivation+ ).isTrue()+ assertThat(+ SyncOutcome(+ continuationWork = listOf(+ SyncContinuation(+ SyncContinuationOperation.INDEX_CATALOG,+ section = com.streamvault.domain.model.ContentType.MOVIE,+ reason = "resume persisted job"+ )+ )+ ).requiresPartialActivation+ ).isFalse()+ }++ @Test+ fun `full and every catalog repair path share the typed activation contract for every provider`() = runTest {+ val expected = SyncOutcome(+ partial = true,+ warnings = listOf("staged page retained"),+ stagedMutations = 7,+ activation = SyncActivation.ACTIVATED_CATALOG+ )++ ProviderType.entries.forEach { type ->+ val plan = concretePlanFor(type, expected)+ assertThat(plan.syncFull(fullRequest(snapshot(type)))).isEqualTo(expected)+ catalogSections(type).forEach { section ->+ assertThat(+ plan.syncSection(sectionRequest(snapshot(type), section))+ ).isEqualTo(CapabilityResolution.Available(expected))+ }+ }+ }++ @Test+ fun `unsupported repair sections remain explicit for every provider`() = runTest {+ val expected = SyncOutcome(partial = true, activation = SyncActivation.PRESERVED_ACTIVE_CATALOG)+ ProviderType.entries.forEach { type ->+ val plan = concretePlanFor(type, expected)+ val supported = repairSections(type).toSet()+ listOf(SyncRepairSection.LIVE, SyncRepairSection.MOVIES, SyncRepairSection.SERIES, SyncRepairSection.EPG)+ .filterNot { it in supported }+ .forEach { section ->+ assertThat(plan.syncSection(sectionRequest(snapshot(type), section)))+ .isInstanceOf(CapabilityResolution.Unsupported::class.java)+ }+ }+ }++ private fun coordinatorFor(fullResult: SyncOutcome): SyncCoordinator =+ SyncCoordinator(+ CatalogSyncPlanRegistry(+ ProviderType.entries.map { planFor(it, fullResult) }+ )+ )++ private fun concretePlanFor(type: ProviderType, outcome: SyncOutcome): CatalogSyncPlan = when (type) {+ ProviderType.XTREAM_CODES -> XtreamCatalogSyncPlan(+ XtreamCatalogSyncOperations(+ full = { outcome },+ live = { outcome },+ epg = { },+ movies = { outcome },+ series = { outcome },+ guide = { ProviderGuideSyncResult(emptyList(), false) }+ )+ )+ ProviderType.M3U -> M3uCatalogSyncPlan(+ M3uCatalogSyncOperations(+ full = { outcome },+ live = { outcome },+ epg = { },+ movies = { outcome },+ guide = { ProviderGuideSyncResult(emptyList(), false) }+ )+ )+ ProviderType.STALKER_PORTAL -> StalkerCatalogSyncPlan(+ StalkerCatalogSyncOperations(+ full = { outcome },+ live = { outcome },+ epg = { },+ movies = { outcome },+ series = { outcome },+ guide = { ProviderGuideSyncResult(emptyList(), false) }+ )+ )+ ProviderType.JELLYFIN -> JellyfinCatalogSyncPlan(+ JellyfinCatalogSyncOperations(+ full = { outcome },+ movies = { outcome },+ series = { outcome },+ guide = { ProviderGuideSyncResult(emptyList(), false) }+ )+ )+ }++ private fun fullRequest(snapshot: ProviderSnapshot) = FullProviderSyncRequest(+ snapshot = snapshot,+ force = false,+ onProgress = null,+ trackInitialLiveOnboarding = false,+ deferProviderStateUntilCatalogCommit = false,+ afterCatalogApply = {}+ )++ private fun sectionRequest(+ snapshot: ProviderSnapshot,+ section: SyncRepairSection = SyncRepairSection.MOVIES+ ) = SectionProviderSyncRequest(+ snapshot = snapshot,+ section = section,+ syncReason = XtreamLiveSyncReason.MANUAL_SETTINGS,+ onProgress = null+ )++ private fun catalogSections(type: ProviderType): List<SyncRepairSection> = when (type) {+ ProviderType.XTREAM_CODES -> listOf(SyncRepairSection.LIVE, SyncRepairSection.MOVIES, SyncRepairSection.SERIES)+ ProviderType.M3U -> listOf(SyncRepairSection.LIVE, SyncRepairSection.MOVIES)+ ProviderType.STALKER_PORTAL -> listOf(SyncRepairSection.LIVE, SyncRepairSection.MOVIES, SyncRepairSection.SERIES)+ ProviderType.JELLYFIN -> listOf(SyncRepairSection.MOVIES, SyncRepairSection.SERIES)+ }++ private fun repairSections(type: ProviderType): List<SyncRepairSection> = when (type) {+ ProviderType.XTREAM_CODES -> listOf(+ SyncRepairSection.LIVE,+ SyncRepairSection.MOVIES,+ SyncRepairSection.SERIES,+ SyncRepairSection.EPG+ )+ ProviderType.M3U -> listOf(SyncRepairSection.LIVE, SyncRepairSection.MOVIES, SyncRepairSection.EPG)+ ProviderType.STALKER_PORTAL -> listOf(+ SyncRepairSection.LIVE,+ SyncRepairSection.MOVIES,+ SyncRepairSection.SERIES,+ SyncRepairSection.EPG+ )+ ProviderType.JELLYFIN -> listOf(SyncRepairSection.MOVIES, SyncRepairSection.SERIES)+ }++ private fun planFor(type: ProviderType, fullResult: SyncOutcome) = LambdaCatalogSyncPlan(+ providerType = type,+ full = { fullResult },+ section = { CapabilityResolution.Available(SyncOutcome()) },+ guide = { CapabilityResolution.Available(ProviderGuideSyncResult(emptyList(), false)) }+ )++ private fun snapshot(type: ProviderType): ProviderSnapshot {+ val configuration: ProviderConfiguration = when (type) {+ ProviderType.XTREAM_CODES -> XtreamConfig("https://example.com", "user", "pass")+ ProviderType.M3U -> M3uConfig("https://example.com/list.m3u")+ ProviderType.STALKER_PORTAL -> StalkerConfig(+ portalUrl = "https://example.com",+ device = StalkerDeviceIdentity("00:11:22:33:44:55")+ )+ ProviderType.JELLYFIN -> JellyfinConfig("https://example.com", "user", "token")+ }+ return ProviderSnapshot(+ provider = Provider(id = 1L, name = "Test", type = type),+ configuration = configuration,+ configurationGeneration = 1L+ )+ }+}diff --git a/data/src/test/java/com/streamvault/data/sync/SyncManagerTest.kt b/data/src/test/java/com/streamvault/data/sync/SyncManagerTest.ktindex 726bc635..db31d60b 100644--- a/data/src/test/java/com/streamvault/data/sync/SyncManagerTest.kt+++ b/data/src/test/java/com/streamvault/data/sync/SyncManagerTest.kt@@ -435,7 +435,7 @@ class SyncManagerTest {tmdbIdentityDao = tmdbIdentityDao,xtreamContentIndexDao = xtreamContentIndexDao,xtreamIndexJobDao = xtreamIndexJobDao,- stalkerIndexJobDao = object : StalkerIndexJobDao {+ stalkerIndexJobStore = StalkerIndexJobStore(object : StalkerIndexJobDao {override fun observeForProvider(providerId: Long): Flow<List<StalkerIndexJobEntity>> = flowOf(emptyList())override suspend fun get(providerId: Long, section: String): StalkerIndexJobEntity? =@@ -509,7 +509,7 @@ class SyncManagerTest {override suspend fun disableForProvider(providerId: Long, updatedAt: Long): Int = 0override suspend fun deleteByProvider(providerId: Long): Int = 0- },+ }),xtreamLiveOnboardingDao = xtreamLiveOnboardingDao,episodeDao = episodeDao,jellyfinProvider = jellyfinProvider,@@ -538,7 +538,11 @@ class SyncManagerTest {): Boolean = configuredProvider?.id == providerIdoverride suspend fun updateCatalogLayout(providerId: Long, layout: CatalogLayout, detectionVersion: Int) = Unit- }+ },+ providerWorkLocks = ProviderWorkLockRegistry(),+ providerSyncLocks = ProviderSyncLockRegistry(),+ stalkerPlaybackCapabilityCache = com.streamvault.data.provider.StalkerPlaybackCapabilityCache(typedProviderClientFactory),+ providerSyncWorkScheduler = mock())}@@ -960,6 +964,18 @@ class SyncManagerTest {assertThat(mgr.currentSyncState(1L)).isInstanceOf(SyncState.Success::class.java)}+ @Test+ fun `unsupported section retry publishes terminal error instead of remaining syncing`() = runTest {+ val mgr = buildManager(providerType = ProviderType.M3U)++ val result = mgr.retrySection(providerId = 1L, section = SyncRepairSection.SERIES)+ advanceUntilIdle()++ assertThat(result.isError).isTrue()+ assertThat(mgr.currentSyncState(1L)).isInstanceOf(SyncState.Error::class.java)+ assertThat(syncMetadataRepo.getMetadata(1L)?.lastSyncStatus).isEqualTo("FAILED_PERMANENT")+ }+@Testfun `retrySection_live_xtream_reports_saving_progress_after_category_download`() = runTest {val mgr = buildManager(providerType = ProviderType.XTREAM_CODES)diff --git a/data/src/test/java/com/streamvault/data/sync/SyncStateMachineTest.kt b/data/src/test/java/com/streamvault/data/sync/SyncStateMachineTest.ktnew file mode 100644index 00000000..684daa6a--- /dev/null+++ b/data/src/test/java/com/streamvault/data/sync/SyncStateMachineTest.kt@@ -0,0 +1,38 @@+package com.streamvault.data.sync++import com.google.common.truth.Truth.assertThat+import com.streamvault.domain.model.SyncState+import org.junit.Assert.assertThrows+import org.junit.Test++class SyncStateMachineTest {+ private val machine = SyncStateMachine()++ @Test+ fun `new run may move from any terminal state to syncing`() {+ assertThat(machine.transition(SyncState.Success(1L), SyncState.Syncing("retry")))+ .isEqualTo(SyncState.Syncing("retry"))+ assertThat(machine.transition(SyncState.Partial("partial"), SyncState.Syncing("retry")))+ .isEqualTo(SyncState.Syncing("retry"))+ assertThat(machine.transition(SyncState.Error("failed"), SyncState.Syncing("retry")))+ .isEqualTo(SyncState.Syncing("retry"))+ }++ @Test+ fun `terminal result cannot be replaced by a different terminal result`() {+ assertThrows(IllegalArgumentException::class.java) {+ machine.transition(SyncState.Success(1L), SyncState.Error("stale callback"))+ }+ assertThrows(IllegalArgumentException::class.java) {+ machine.transition(SyncState.Partial("partial"), SyncState.Success(2L))+ }+ }++ @Test+ fun `reset and same-kind updates remain valid`() {+ val partial = SyncState.Partial("partial", warnings = listOf("warning"))+ assertThat(machine.transition(partial, SyncState.Partial("new partial")))+ .isEqualTo(SyncState.Partial("new partial"))+ assertThat(machine.transition(partial, SyncState.Idle)).isEqualTo(SyncState.Idle)+ }+}diff --git a/data/src/test/java/com/streamvault/data/sync/SyncStateTrackerTest.kt b/data/src/test/java/com/streamvault/data/sync/SyncStateTrackerTest.ktnew file mode 100644index 00000000..fb712330--- /dev/null+++ b/data/src/test/java/com/streamvault/data/sync/SyncStateTrackerTest.kt@@ -0,0 +1,32 @@+package com.streamvault.data.sync++import com.google.common.truth.Truth.assertThat+import com.streamvault.domain.model.SyncState+import org.junit.Test++class SyncStateTrackerTest {+ @Test+ fun `stale session cannot publish over replacement run`() {+ val tracker = SyncStateTracker()+ val first = tracker.begin(7L)+ tracker.publish(first, SyncState.Syncing("first"))++ val replacement = tracker.begin(7L)+ tracker.publish(replacement, SyncState.Syncing("replacement"))++ assertThat(tracker.publish(first, SyncState.Error("stale completion"))).isFalse()+ assertThat(tracker.current(7L)).isEqualTo(SyncState.Syncing("replacement"))+ }++ @Test+ fun `terminal error can be replaced only by a new run`() {+ val tracker = SyncStateTracker()+ val first = tracker.begin(11L)+ tracker.publish(first, SyncState.Syncing("running"))+ tracker.publish(first, SyncState.Error("failed"))++ val replacement = tracker.begin(11L)+ assertThat(tracker.publish(replacement, SyncState.Syncing("retry"))).isTrue()+ assertThat(tracker.current(11L)).isEqualTo(SyncState.Syncing("retry"))+ }+}diff --git a/data/src/test/java/com/streamvault/data/sync/SyncStatusPublicationCoordinatorTest.kt b/data/src/test/java/com/streamvault/data/sync/SyncStatusPublicationCoordinatorTest.ktnew file mode 100644index 00000000..204044c2--- /dev/null+++ b/data/src/test/java/com/streamvault/data/sync/SyncStatusPublicationCoordinatorTest.kt@@ -0,0 +1,131 @@+package com.streamvault.data.sync++import com.google.common.truth.Truth.assertThat+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.SyncMetadata+import com.streamvault.domain.model.SyncState+import com.streamvault.domain.model.VodSyncMode+import com.streamvault.domain.repository.SyncMetadataRepository+import kotlinx.coroutines.flow.Flow+import kotlinx.coroutines.flow.flowOf+import kotlinx.coroutines.test.runTest+import org.junit.Test++class SyncStatusPublicationCoordinatorTest {+ @Test+ fun `partial movie publication preserves the known catalog count and marks it stale`() = runTest {+ val repository = FakeSyncMetadataRepository(+ SyncMetadata(+ providerId = 7L,+ movieCount = 10,+ lastMovieSuccess = 90L+ )+ )+ val coordinator = SyncStatusPublicationCoordinator(repository, SyncProgressBus())++ coordinator.updateSummaryMetadata(+ providerId = 7L,+ contentType = ContentType.MOVIE,+ indexedRows = 3,+ finalState = "PARTIAL",+ now = 100L,+ movieSyncMode = VodSyncMode.PAGED+ )++ val metadata = requireNotNull(repository.getMetadata(7L))+ assertThat(metadata.movieCount).isEqualTo(10)+ assertThat(metadata.lastMovieSuccess).isEqualTo(90L)+ assertThat(metadata.lastMoviePartial).isEqualTo(100L)+ assertThat(metadata.movieCatalogStale).isTrue()+ assertThat(metadata.movieSyncMode).isEqualTo(VodSyncMode.PAGED)+ }++ @Test+ fun `successful series publication replaces the indexed count and records success`() = runTest {+ val repository = FakeSyncMetadataRepository(SyncMetadata(providerId = 8L, seriesCount = 2))+ val coordinator = SyncStatusPublicationCoordinator(repository, SyncProgressBus())++ coordinator.updateSummaryMetadata(+ providerId = 8L,+ contentType = ContentType.SERIES,+ indexedRows = 12,+ finalState = "SUCCESS",+ now = 200L,+ movieSyncMode = VodSyncMode.UNKNOWN+ )++ val metadata = requireNotNull(repository.getMetadata(8L))+ assertThat(metadata.seriesCount).isEqualTo(12)+ assertThat(metadata.lastSeriesSync).isEqualTo(200L)+ assertThat(metadata.lastSeriesSuccess).isEqualTo(200L)+ }++ @Test+ fun `movie index rebuild attempt preserves the existing count while marking stale`() = runTest {+ val repository = FakeSyncMetadataRepository(SyncMetadata(providerId = 10L, movieCount = 15))+ val coordinator = SyncStatusPublicationCoordinator(repository, SyncProgressBus())++ coordinator.markMovieIndexRebuildAttempt(providerId = 10L, now = 300L)++ val metadata = requireNotNull(repository.getMetadata(10L))+ assertThat(metadata.movieCount).isEqualTo(15)+ assertThat(metadata.lastMovieAttempt).isEqualTo(300L)+ assertThat(metadata.movieCatalogStale).isTrue()+ assertThat(metadata.movieSyncMode).isEqualTo(VodSyncMode.UNKNOWN)+ }++ @Test+ fun `stale state session cannot publish after a replacement`() {+ val coordinator = SyncStatusPublicationCoordinator(+ FakeSyncMetadataRepository(),+ SyncProgressBus()+ )+ val first = coordinator.beginStateSession(9L)+ coordinator.publish(9L, SyncState.Syncing("first"))+ val replacement = coordinator.beginStateSession(9L)+ coordinator.publish(9L, SyncState.Syncing("replacement"))++ coordinator.finishStateSession(first)+ assertThat(coordinator.currentSyncState(9L)).isEqualTo(SyncState.Syncing("replacement"))++ coordinator.finishStateSession(replacement)+ }++ @Test+ fun `finishing stale progress session does not finish replacement state session`() {+ val coordinator = SyncStatusPublicationCoordinator(+ FakeSyncMetadataRepository(),+ SyncProgressBus()+ )+ val first = coordinator.beginProgressSession(9L)+ coordinator.publish(9L, SyncState.Syncing("first"))+ val replacement = coordinator.beginProgressSession(9L)+ coordinator.publish(9L, SyncState.Syncing("replacement"))++ coordinator.finishProgressSession(first)+ coordinator.publish(9L, SyncState.Success())++ assertThat(coordinator.currentSyncState(9L)).isInstanceOf(SyncState.Success::class.java)+ coordinator.finishProgressSession(replacement)+ }++ private class FakeSyncMetadataRepository(initial: SyncMetadata? = null) : SyncMetadataRepository {+ private val values = mutableMapOf<Long, SyncMetadata>()++ init {+ initial?.let { values[it.providerId] = it }+ }++ override fun observeMetadata(providerId: Long): Flow<SyncMetadata?> = flowOf(values[providerId])++ override suspend fun getMetadata(providerId: Long): SyncMetadata? = values[providerId]++ override suspend fun updateMetadata(metadata: SyncMetadata) {+ values[metadata.providerId] = metadata+ }++ override suspend fun clearMetadata(providerId: Long) {+ values.remove(providerId)+ }+ }+}diff --git a/data/src/test/java/com/streamvault/data/sync/VodCategoryHydrationCoordinatorTest.kt b/data/src/test/java/com/streamvault/data/sync/VodCategoryHydrationCoordinatorTest.ktnew file mode 100644index 00000000..0265c117--- /dev/null+++ b/data/src/test/java/com/streamvault/data/sync/VodCategoryHydrationCoordinatorTest.kt@@ -0,0 +1,128 @@+package com.streamvault.data.sync++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.MovieCategoryHydrationDao+import com.streamvault.data.local.dao.MovieDao+import com.streamvault.data.local.dao.SeriesCategoryHydrationDao+import com.streamvault.data.local.dao.SeriesDao+import com.streamvault.data.local.dao.VodCategoryHydrationDao+import com.streamvault.data.local.dao.VodCatalogEntryDao+import com.streamvault.data.remote.stalker.StalkerPagedResult+import com.streamvault.data.remote.stalker.StalkerProvider+import com.streamvault.domain.model.LegacyProvider+import com.streamvault.domain.model.ProviderType+import com.streamvault.domain.model.Result+import com.streamvault.domain.model.VodCategoryHydrationRequest+import kotlinx.coroutines.CancellationException+import kotlinx.coroutines.test.runTest+import org.junit.Test+import org.mockito.kotlin.mock+import org.mockito.kotlin.whenever++class VodCategoryHydrationCoordinatorTest {+ @Test+ fun `cancellation before catalog transaction does not commit`() = runTest {+ val transactionCalls = mutableListOf<Unit>()+ val api = mock<StalkerProvider>()+ whenever(api.getUnifiedVodPage(11L, 1)).thenThrow(CancellationException("before commit"))+ val coordinator = coordinator(api) { block ->+ transactionCalls += Unit+ block()+ }++ val cancelled = runCatching {+ coordinator.hydrateUnifiedVodCategory(7L, 11L, VodCategoryHydrationRequest.OPEN)+ }.exceptionOrNull()++ assertThat(cancelled).isInstanceOf(CancellationException::class.java)+ assertThat(transactionCalls).isEmpty()+ }++ @Test+ fun `cancellation while entering catalog transaction does not publish a completed page`() = runTest {+ var transactionEntered = false+ val api = successfulEmptyPageApi()+ val coordinator = coordinator(api) {+ transactionEntered = true+ throw CancellationException("during commit")+ }++ val cancelled = runCatching {+ coordinator.hydrateUnifiedVodCategory(7L, 11L, VodCategoryHydrationRequest.OPEN)+ }.exceptionOrNull()++ assertThat(cancelled).isInstanceOf(CancellationException::class.java)+ assertThat(transactionEntered).isTrue()+ }++ @Test+ fun `cancellation after transaction body preserves the completed transaction boundary`() = runTest {+ var catalogBodyCompleted = false+ val api = successfulEmptyPageApi()+ val coordinator = coordinator(api) { block ->+ block()+ catalogBodyCompleted = true+ throw CancellationException("after commit")+ }++ val cancelled = runCatching {+ coordinator.hydrateUnifiedVodCategory(7L, 11L, VodCategoryHydrationRequest.OPEN)+ }.exceptionOrNull()++ assertThat(cancelled).isInstanceOf(CancellationException::class.java)+ assertThat(catalogBodyCompleted).isTrue()+ }++ private suspend fun successfulEmptyPageApi(): StalkerProvider = mock<StalkerProvider>().also { api ->+ whenever(api.getUnifiedVodPage(11L, 1)).thenReturn(+ Result.success(+ StalkerPagedResult(+ items = emptyList(),+ page = 1,+ totalPages = 1,+ pageSize = 100+ )+ )+ )+ }++ private suspend fun coordinator(+ api: StalkerProvider,+ transaction: suspend (suspend () -> Unit) -> Unit+ ): VodCategoryHydrationCoordinator {+ val provider = LegacyProvider(+ id = 7L,+ name = "test",+ type = ProviderType.STALKER_PORTAL,+ serverUrl = "http://portal.test"+ )+ return VodCategoryHydrationCoordinator(+ providerSyncLocks = ProviderSyncLockRegistry(),+ categoryDao = mock<CategoryDao>().also {+ whenever(it.getByProviderAndTypeSync(7L, "VOD")).thenReturn(emptyList())+ },+ movieCategoryHydrationDao = mock<MovieCategoryHydrationDao>(),+ seriesCategoryHydrationDao = mock<SeriesCategoryHydrationDao>(),+ vodCategoryHydrationDao = mock<VodCategoryHydrationDao>(),+ movieDao = mock<MovieDao>(),+ seriesDao = mock<SeriesDao>(),+ vodCatalogEntryDao = mock<VodCatalogEntryDao>().also {+ whenever(it.countByCategory(7L, 11L)).thenReturn(0)+ },+ transactionRunner = object : DatabaseTransactionRunner {+ override suspend fun <T> inTransaction(block: suspend () -> T): T {+ var result: T? = null+ transaction({ result = block() })+ @Suppress("UNCHECKED_CAST")+ return result as T+ }+ },+ loadProvider = { provider },+ createProvider = { api }+ ).also {+ // The transaction callback above is supplied by each test through the wrapper.+ }+ }+}diff --git a/data/src/test/java/com/streamvault/data/sync/XtreamIncrementalIndexExecutorTest.kt b/data/src/test/java/com/streamvault/data/sync/XtreamIncrementalIndexExecutorTest.ktnew file mode 100644index 00000000..eb89ee39--- /dev/null+++ b/data/src/test/java/com/streamvault/data/sync/XtreamIncrementalIndexExecutorTest.kt@@ -0,0 +1,291 @@+package com.streamvault.data.sync++import com.google.common.truth.Truth.assertThat+import com.streamvault.data.local.entity.CategoryEntity+import com.streamvault.data.local.entity.XtreamIndexJobEntity+import com.streamvault.data.remote.dto.XtreamCategory+import com.streamvault.data.remote.xtream.XtreamProvider+import com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.LegacyProvider as Provider+import com.streamvault.domain.model.Movie+import com.streamvault.domain.model.Result+import com.streamvault.domain.model.Series+import java.io.IOException+import kotlinx.coroutines.CancellationException+import kotlinx.coroutines.test.runTest+import org.junit.Test+import org.mockito.kotlin.mock++class XtreamIncrementalIndexExecutorTest {+ @Test+ fun `successful full stream completes section and publishes metadata`() = runTest {+ val operations = FakeOperations(+ categories = listOf(category(1L)),+ streamMovieResult = Result.success(7)+ )+ val executor = XtreamIncrementalIndexExecutor(operations)++ executor.processSummary(+ provider = provider(),+ api = mock(),+ contentType = ContentType.MOVIE,+ maxCategories = null,+ onProgress = null+ )++ assertThat(operations.updates.last().state).isEqualTo("SUCCESS")+ assertThat(operations.updates.last().indexedRows).isEqualTo(7)+ assertThat(operations.metadataUpdates).containsExactly(ContentType.MOVIE, 7, "SUCCESS")+ assertThat(operations.scheduled).isEmpty()+ }++ @Test+ fun `failed full stream falls back to priority and cursor category slices`() = runTest {+ val operations = FakeOperations(+ categories = listOf(category(1L), category(2L)),+ job = XtreamIndexJobEntity(+ providerId = 1L,+ section = ContentType.MOVIE.name,+ state = "QUEUED",+ priorityCategoryId = 2L+ ),+ streamMovieResult = Result.error("stream unavailable")+ )+ val executor = XtreamIncrementalIndexExecutor(operations)++ executor.processSummary(+ provider = provider(),+ api = mock(),+ contentType = ContentType.MOVIE,+ maxCategories = 2,+ onProgress = null+ )++ val finalUpdate = operations.updates.last()+ assertThat(finalUpdate.state).isEqualTo("QUEUED")+ assertThat(finalUpdate.completedCategories).isEqualTo(1)+ assertThat(finalUpdate.nextCategoryIndex).isEqualTo(1)+ assertThat(operations.fetchedCategoryIds).containsExactly(2L, 1L).inOrder()+ assertThat(operations.scheduled).containsExactly(ContentType.MOVIE)+ }++ @Test+ fun `failed category keeps cursor on failed work and does not skip later categories`() = runTest {+ val operations = FakeOperations(+ categories = listOf(category(1L), category(2L), category(3L)),+ job = XtreamIndexJobEntity(+ providerId = 1L,+ section = ContentType.MOVIE.name,+ state = "QUEUED"+ ),+ streamMovieResult = Result.error("stream unavailable"),+ failureCategoryId = 2L+ )++ XtreamIncrementalIndexExecutor(operations).processSummary(+ provider = provider(),+ api = mock(),+ contentType = ContentType.MOVIE,+ maxCategories = 3,+ onProgress = null+ )++ assertThat(operations.fetchedCategoryIds).containsExactly(1L, 2L).inOrder()+ assertThat(operations.updates.last().nextCategoryIndex).isEqualTo(1)+ assertThat(operations.updates.last().state).isEqualTo("QUEUED")+ assertThat(operations.scheduled).containsExactly(ContentType.MOVIE)+ }++ @Test+ fun `cancellation after first category persists only completed cursor`() = runTest {+ val operations = FakeOperations(+ categories = listOf(category(1L), category(2L), category(3L)),+ job = XtreamIndexJobEntity(+ providerId = 1L,+ section = ContentType.MOVIE.name,+ state = "QUEUED"+ ),+ streamMovieResult = Result.error("stream unavailable"),+ cancelCategoryId = 2L+ )++ var cancelled = false+ try {+ XtreamIncrementalIndexExecutor(operations).processSummary(+ provider = provider(),+ api = mock(),+ contentType = ContentType.MOVIE,+ maxCategories = 3,+ onProgress = null+ )+ } catch (_: CancellationException) {+ cancelled = true+ }++ assertThat(cancelled).isTrue()+ assertThat(operations.updates.last().nextCategoryIndex).isEqualTo(1)+ }++ @Test+ fun `legacy partial job whose cursor passed failures restarts repair sweep`() = runTest {+ val operations = FakeOperations(+ categories = listOf(category(1L), category(2L), category(3L)),+ job = XtreamIndexJobEntity(+ providerId = 1L,+ section = ContentType.MOVIE.name,+ state = "PARTIAL",+ completedCategories = 2,+ nextCategoryIndex = 3,+ failedCategories = 1,+ indexedRows = 20+ ),+ streamMovieResult = Result.error("stream unavailable")+ )++ XtreamIncrementalIndexExecutor(operations).processSummary(+ provider = provider(),+ api = mock(),+ contentType = ContentType.MOVIE,+ maxCategories = 1,+ onProgress = null+ )++ assertThat(operations.fetchedCategoryIds).containsExactly(1L)+ assertThat(operations.updates.last().nextCategoryIndex).isEqualTo(1)+ assertThat(operations.updates.last().completedCategories).isEqualTo(1)+ assertThat(operations.updates.last().failedCategories).isEqualTo(0)+ }++ private class FakeOperations(+ private val categories: List<CategoryEntity>,+ private val job: XtreamIndexJobEntity? = null,+ private val streamMovieResult: Result<Int> = Result.success(0),+ private val failureCategoryId: Long? = null,+ private val cancelCategoryId: Long? = null+ ) : XtreamIncrementalIndexOperations {+ val updates = mutableListOf<CatalogIndexJobUpdate>()+ val fetchedCategoryIds = mutableListOf<Long>()+ val metadataUpdates = mutableListOf<Any>()+ val scheduled = mutableListOf<ContentType>()++ override suspend fun getCategories(providerId: Long, contentType: ContentType) = categories++ override suspend fun ensureCategoryShell(+ provider: Provider,+ api: XtreamProvider,+ contentType: ContentType,+ now: Long,+ onProgress: ((String) -> Unit)?+ ) = Unit++ override suspend fun getJob(providerId: Long, contentType: ContentType) = job++ override fun shouldRunSummary(job: XtreamIndexJobEntity?) = true++ override suspend fun fetchMovieCategory(+ provider: Provider,+ api: XtreamProvider,+ category: CategoryEntity+ ): TimedCategoryOutcome<Movie> {+ fetchedCategoryIds += category.categoryId+ if (category.categoryId == cancelCategoryId) {+ throw CancellationException("cancelled while fetching category")+ }+ if (category.categoryId == failureCategoryId) {+ return TimedCategoryOutcome(+ category = category.asXtreamCategory(),+ outcome = CategoryFetchOutcome.Failure(category.name, IOException("category failed")),+ elapsedMs = 1L+ )+ }+ return TimedCategoryOutcome(+ category = category.asXtreamCategory(),+ outcome = CategoryFetchOutcome.Empty(category.name),+ elapsedMs = 1L+ )+ }++ override suspend fun fetchSeriesCategory(+ provider: Provider,+ api: XtreamProvider,+ category: CategoryEntity+ ): TimedCategoryOutcome<Series> = error("series not used")++ override suspend fun upsertMovieSummaryBatch(+ providerId: Long,+ movies: List<Movie>,+ indexedAt: Long+ ) = movies.size++ override suspend fun upsertSeriesSummaryBatch(+ providerId: Long,+ series: List<Series>,+ indexedAt: Long+ ) = series.size++ override suspend fun streamMovies(+ provider: Provider,+ api: XtreamProvider,+ adultCategoryIds: Set<Long>,+ onBatch: suspend (List<Movie>) -> Unit+ ) = streamMovieResult++ override suspend fun streamSeries(+ provider: Provider,+ api: XtreamProvider,+ adultCategoryIds: Set<Long>,+ onBatch: suspend (List<Series>) -> Unit+ ): Result<Int> = Result.error("series not used")++ override suspend fun upsertJob(update: CatalogIndexJobUpdate) {+ updates += update+ }++ override suspend fun updateSummaryMetadata(+ providerId: Long,+ contentType: ContentType,+ indexedRows: Int,+ state: String,+ now: Long+ ) {+ metadataUpdates += contentType+ metadataUpdates += indexedRows+ metadataUpdates += state+ }++ override fun scheduleIndex(providerId: Long, contentType: ContentType) {+ scheduled += contentType+ }++ override fun progress(providerId: Long, callback: ((String) -> Unit)?, message: String) = Unit++ override suspend fun restoreMovieWatchProgress(providerId: Long) = Unit++ override fun sanitize(error: Throwable?) = error?.message.orEmpty()++ override fun log(message: String) = Unit++ private fun CategoryEntity.asXtreamCategory() = XtreamCategory(+ categoryId = categoryId.toString(),+ categoryName = name,+ parentId = parentId?.toInt() ?: 0,+ isAdult = isAdult+ )+ }++ private fun category(id: Long) = CategoryEntity(+ providerId = 1L,+ categoryId = id,+ name = "Category $id",+ type = ContentType.MOVIE+ )++ private fun provider() = Provider(+ id = 1L,+ name = "Xtream",+ type = com.streamvault.domain.model.ProviderType.XTREAM_CODES,+ serverUrl = "https://example.com",+ username = "user",+ password = "password"+ )+}diff --git a/docs/IPTV_CODE_REVIEW.md b/docs/IPTV_CODE_REVIEW.mdindex c6d30098..d09a2c5a 100644--- a/docs/IPTV_CODE_REVIEW.md+++ b/docs/IPTV_CODE_REVIEW.md@@ -39,7 +39,7 @@ Phase 1 used the repository's existing graphify graph and wiki, then verified thFocused verification performed in this phase:- `./gradlew.bat :data:compileDebugKotlin --rerun-tasks --no-daemon` — passed on 2026-07-11. This confirms the inspected data-module source compiles, while also producing a large warning set that will be triaged in Phase 2/4.-- Static size/coupling measurements: `SyncManager` is 6,048 lines/169 functions; `OkHttpStalkerApiService` 2,767/124; `Media3PlayerEngine` 2,482/122; `PreferencesRepository` 2,324/169; `PlayerViewModel` 1,776 lines; `StalkerProvider` 1,611/88; `ProviderRepositoryImpl` 1,308 lines.+- Static size/coupling measurements at the original review baseline: `SyncManager` was 6,048 lines/169 functions; `OkHttpStalkerApiService` 2,767/124; `Media3PlayerEngine` 2,482/122; `PreferencesRepository` 2,324/169; `PlayerViewModel` 1,776 lines; `StalkerProvider` 1,611/88; `ProviderRepositoryImpl` 1,308 lines. After the current ARCH-003 slices, `SyncManager` is approximately 2,451 lines; implementation is substantially complete, with device-backed validation and further compatibility cleanup remaining.# Phase 1 — Architecture and flow mapping@@ -173,7 +173,7 @@ App update checking starts from `StreamVaultApp` and stores cached release metad|---|---|---:|---|---|| ARCH-001 | Implemented in code; API 25 migration evidence pending (2026-08-11) | High | Explicit provider capabilities and complete typed registries now drive synchronization and runtime provider execution. | Architectural || ARCH-002 | Implemented in code; API 25 migration evidence pending (2026-08-11) | High | Stable provider identity, typed encrypted configuration/runtime storage, and generation-bound Stalker learning replace the authoritative union row. | Architectural |-| ARCH-003 | Architectural concern | High | `SyncManager` is a 6,048-line policy, networking, persistence, recovery, and scheduling god object. | Architectural |+| ARCH-003 | Implemented in code; device validation pending (2026-08-12) | High | Provider plans, activation receipts, durable continuation scheduling, state publication, index execution, and workflow admission are separated; the remaining `SyncManager` compatibility façade is approximately 2,451 lines. | Architectural || ARCH-004 | Confirmed defect + architectural concern | Medium | The all-provider playback resolver contains contradictory dispatch and mixes URL resolution with Stalker session construction and persistence. | Local first; architectural follow-up || ARCH-005 | Architectural concern | High | `PlayerViewModel` is a 25+ dependency feature orchestrator that crosses domain/data/player boundaries. | Architectural || ARCH-006 | Highly likely defect | High | Plugin discovery performs multiple blocking IPC calls and maps plugin providers into M3U records. | Local + architectural |@@ -210,15 +210,34 @@ App update checking starts from `StreamVaultApp` and stores cached release metad### ARCH-003 — `SyncManager` is the application's provider-policy and persistence god object-- **Classification:** Architectural concern+- **Classification:** Implemented in code; device/instrumentation execution pending (2026-08-12)- **Severity:** High-- **Where:** `data/.../sync/SyncManager.kt` (6,048 lines, 169 functions, 27 constructor dependencies/created collaborators), plus `ProviderSyncWorker`, `XtreamIndexWorker`, `StalkerIndexWorker`, `ProviderRepositoryImpl`, `MovieRepositoryImpl`, and `SeriesRepositoryImpl`.-- **Current behavior:** The class owns provider locking/state publication, M3U downloading/parsing, Xtream and Stalker authentication/catalog logic, category staging, transaction commits, EPG decisions, retries/timeouts, incremental index job state, worker scheduling, error sanitization, metadata/status updates, and repair flows. It creates additional support objects internally while also exposing provider-specific public methods used by workers and UI/repositories.+- **Where:** `data/.../sync/SyncManager.kt` (approximately 2,451 lines after the current extraction slices), plus `SyncCoordinator`, the provider catalog executors, `ProviderContinuationScheduler`, `ProviderWorkflowRunner`, and the provider workers.+- **Current behavior:** Provider-neutral full/section/guide dispatch goes through `SyncCoordinator` and typed `CatalogSyncPlan` implementations. M3U, Jellyfin, Xtream section/full, Stalker section/full, and provider EPG execution have dedicated executors. Plans return validated activation receipts and the coordinator hands typed continuations to `ProviderContinuationScheduler`; provider executors no longer enqueue WorkManager directly. State transitions are guarded by `SyncStateTracker`/`SyncStateMachine`, and app callers now consume role-specific sync ports rather than `SyncManager` directly. `SyncManager` remains the composition/compatibility façade for lower-level provider helpers.+- **Extraction update (2026-08-12):** `StalkerIncrementalIndexExecutor` now owns the summary-category and wildcard page loops, parallel-fetch downgrade, retry/anomaly handling, page checkpoint progression, partial-result state selection, and catalog commit handoff. `StalkerIncrementalIndexOperationsAdapter` keeps that executor at one dependency while the remaining low-level recovery/checkpoint helpers are still exposed by the compatibility façade.+- **Current behavior correction (2026-08-12):** Xtream and Stalker incremental index orchestration, metadata/status publication, and state/progress session ownership now live in dedicated coordinators. `SyncManager` retains compatibility wrappers and remaining provider admission, compatibility conversion, error policy, and hydration entry-point responsibilities.- **Why this is wrong/fragile:** Correctness depends on many implicit invariants across one class: which lock is held, which staging rows exist, which status is published, whether a worker was queued, and whether provider-specific partial success is safe to commit. Repeated `ProviderType` branches create divergent full-sync and repair behavior. Unit tests must mock a huge dependency graph and cannot isolate protocol policy from transaction policy.- **Concrete failure scenario:** A fix to Stalker full sync commits a new staging invariant but `syncStalkerLiveCatalogStaged` or section repair uses the old invariant. A repair reports success and updates sync time while leaving a stale/partial catalog that the normal path would reject. Similar divergence can occur between Xtream initial onboarding and periodic index workers.- **Recommended correction:** Extract a provider-neutral `SyncCoordinator`, per-provider `CatalogSyncPlan` implementations, section-level transactional importers, and a separate durable job scheduler. Each plan should return a typed result containing staged mutations, warnings, continuation work, and activation criteria. Centralize status transitions in one state machine.- **Fix scope:** Architectural, high risk; refactor by seams and preserve fixtures before behavior changes.+- **Status extraction update (2026-08-12):** `SyncStatusPublicationCoordinator` now owns provider metadata/status writes, aggregate state exposure, and state/progress session fencing. The coordinator preserves partial-summary count/staleness semantics while `SyncManager` keeps only compatibility wrappers for existing callers.+- **Validation update (2026-08-12):** `XtreamIncrementalIndexExecutorTest` covers successful full-stream completion and stream-failure fallback into priority/cursor category slices. The full data suite now has 961 tests with zero failures/errors/skips; Xtream incremental orchestration is extracted, while metadata/status ownership, compatibility conversion, façade reduction, release recovery matrices, concurrency coverage, and device validation remain open.+- **Validation supersession (2026-08-12):** The full `:data:testDebugUnitTest` suite now passes with 964 tests and zero failures/errors/skips. Xtream/Stalker incremental orchestration and metadata/status publication are extracted; compatibility conversion, façade reduction, full-sync-vs-repair equivalence, persisted-state recovery matrices, provider activation coverage, concurrent manual/background scenarios, and device validation remain open.- **Required tests:** State-machine transition tests; full-sync vs repair equivalence tests; cancellation before/during/after commit; process-death recovery from each persisted job state; concurrent manual/background sync serialization; partial-result activation rules for every provider.+- **Latest validation (2026-08-12):** After moving the Xtream index-rebuild metadata write into `SyncStatusPublicationCoordinator`, the complete `:data:testDebugUnitTest` suite passes with 965 tests and zero failures/errors/skips.++**Implementation evidence (2026-08-12, orchestration and lock-ownership slice):**++- `SyncCoordinator` resolves full sync, section repair, and guide work through four typed catalog plans. Production executors populate `SyncOutcome` with accepted staging mutations, warnings, typed continuation work, and a truthful post-execution activation receipt (`ACTIVATED_CATALOG`, `NO_CATALOG_CHANGE`, `PRESERVED_ACTIVE_CATALOG`, or `DEFERRED_TO_FOLLOW_UP`). Validation rejects impossible receipts before continuation handoff.+- `M3uCatalogSyncExecutor`, `JellyfinCatalogSyncExecutor`, `XtreamCatalogSyncExecutor`, `StalkerCatalogSyncExecutor`, the section executors, and `ProviderEpgSyncExecutor` now own provider-specific ingestion seams. `ProviderSyncWorkScheduler` owns WorkManager entry-point construction.+- `ProviderWorkLockRegistry` is the sole provider-wide execution lane. `ProviderSyncLockRegistry` owns only narrower category/summary/index locks; the duplicate `SyncManager` mutex maps and their lock-under-admission path were removed. This removes duplicated lock ownership and keeps cleanup ownership outside the manager.+- `CatalogIndexJobStore` now owns Xtream index-job patch/merge semantics, Stalker legacy-schema routing, priority clearing, and summary refresh eligibility. `SyncManager` keeps only the compatibility façade used by existing executors and workers.+- `VodCategoryHydrationCoordinator` now owns unified and split Stalker VOD paging, hydration checkpoints, page-budget/truncation handling, and the native-Series-vs-derived-Series commit guard. `StalkerIndexPolicy` owns section selection, retry timing, page continuation, anomaly detection, deduplication, and visible-category filtering.+- `StalkerIndexContinuationCoordinator` now owns persisted section-state evaluation, startup reconciliation, successor/retry scheduling, and independent EPG enqueueing. Work is serialized by the durable provider workflow; the coordinator does not itself prove the catalog is idle before enqueueing EPG.+- `SyncStatusPublicationCoordinator` now owns provider metadata/status publication, state/progress session fencing, aggregate state exposure, and partial-summary count/staleness policy. `SyncStatusPublicationCoordinatorTest` covers partial preservation, successful publication, and stale-session fencing.+- `XtreamIncrementalIndexExecutor` now owns full-stream indexing, category-slice fallback, priority-category ordering, cursor continuation, durable job updates, metadata publication, and follow-up scheduling. `XtreamIncrementalIndexOperationsAdapter` keeps that executor at one dependency while existing fetch/DAO helpers remain behind the compatibility façade.+- `StalkerIncrementalIndexExecutor` now owns the summary-category and wildcard page loops, parallel-fetch downgrade, retry/anomaly handling, page checkpoint progression, partial-result state selection, and catalog commit handoff. `StalkerIncrementalIndexOperationsAdapter` keeps the executor at one dependency while the remaining low-level recovery/checkpoint helpers are still exposed by the compatibility façade.+- Focused coordinator, activation-policy, state-machine, lock, cursor, recovery, and architecture tests pass. `CatalogSyncEquivalenceIntegrationTest` runs the production streaming M3U importer and Room DAOs to prove full import converges with separate Live/Movie repair activation. `ProviderWorkManagerSerializationTest` enqueues the real provider, Xtream-index, Stalker-index, and EPG worker APIs and verifies one provider-scoped WorkManager chain. These instrumentation tests compile; execution remains pending because no device or emulator is connected.### ARCH-004 — Playback resolver has contradictory provider dispatch and hidden side effects@@ -1496,3 +1515,23 @@ This batch does not require the large architecture split and creates the safety- Severity totals reconcile to 35 High and 21 Medium.- No code or build configuration changed in Phase 6. Only this Markdown report changed, so `graphify update .`, application builds, and emulator validation were not required for this consolidation step.- **Review status:** all six planned phases are complete. Implementation and remediation remain future work.++### ARCH-003 implementation status addendum (2026-08-12)++Compatibility projection is isolated in `SyncProviderSnapshotAdapter`/`SyncManagerPlanDelegate`; workers and repositories consume role-specific sync ports, with distinct Hilt entry-point names for commands and lifecycle cleanup. Stalker hydration checkpoint reads/writes and Xtream/Stalker index failure classification are outside `SyncManager`. Added coverage exercises cancellation before/during/after Room catalog commits, all persisted Xtream/Stalker index states and Stalker legacy-state round trips, every provider plan's supported/unsupported repair sections and typed partial-activation contract, and same-provider manual/background serialization. The complete `:data:testDebugUnitTest` suite and `:app:assembleDebug :app:testDebugUnitTest` pass.++The former full-sync-vs-repair and WorkManager coverage gaps now have instrumentation fixtures: the real streaming M3U importer converges through production Room DAOs for full versus section repair, and all four provider worker enqueue APIs share one serialized WorkManager chain. The fixtures compile, but real device/emulator execution remains pending because this environment has no connected device or installed emulator/AVD.++### ARCH-003 post-review corrections (2026-08-12)++Review of the complete dirty tree found both inherited defects and extraction regressions. Xtream category slices now advance their durable cursor only after a category succeeds or returns an accepted empty result; a failed category stops the slice at its own cursor, and cancellation coverage verifies that a preselected slice cannot skip unprocessed categories. Legacy `PARTIAL` jobs whose old cursor already passed failed work restart a repair sweep. Stalker summary indexing now enters `ProviderWorkLockRegistry` before its narrower summary lock, so database-maintenance admission observes the work. Progress sessions retain the exact paired state-session token, preventing a stale run from finishing its replacement. Unsupported/restricted/configuration section and guide resolutions now publish terminal failure state and guide-job status instead of leaving `Syncing`/`RUNNING` snapshots behind.++The same review corrected adjacent dirty-tree regressions: plugin discovery sorting again applies to both normal and timeout results; TV-input refresh replacement uses identity-checked, lazily-started job ownership; Stalker authentication mutexes use stable provider-scoped identities and are no longer cache-evicted; and the Room annotation plus migration registry share one compile-time database-version constant. Focused state, cursor/cancellation, legacy-partial repair, lock-architecture, migration, and unsupported-section tests pass. The complete validation run passed 978 data tests, 279 app tests, and 196 player tests with zero failures/errors/skips, and rebuilt the debug APK.++### ARCH-003 activation, scheduling, and equivalence closure slice (2026-08-12)++Production M3U, Jellyfin, Xtream, and Stalker executors now report accepted staging mutations and truthful catalog activation receipts. Movie/series shell repairs report deferred activation with typed durable index continuations; full syncs report committed catalog activation independently from background index/guide work, so queued follow-up no longer falsely marks a healthy active catalog partial. Xtream Live repair now also queues the Live index backfill, closing a stale-search regression discovered while wiring the contract.++`SyncCoordinator` validates receipts and owns continuation handoff to `ProviderContinuationScheduler`; provider executors no longer construct or enqueue durable work. Catalog plans consume request snapshots through one delegate instead of re-projecting compatibility providers or bypassing the delegate for selected providers. App startup, Home, Dashboard, Settings, and Player no longer inject the concrete `SyncManager`; they consume lifecycle, command, or state ports, and the unused Player dependency was removed.++`CatalogSyncEquivalenceIntegrationTest` exercises the real streaming M3U importer, staging tables, activation transactions, and production Room DAOs for a full import versus separate Live/Movie repairs. `ProviderWorkManagerSerializationTest` exercises the real enqueue functions for provider refresh, Xtream index, Stalker index, and background EPG and verifies that they occupy one provider-scoped serial chain. Both Android fixtures compile. The complete JVM validation now passes 981 data tests, 279 app tests, and 196 player tests with zero failures/errors/skips and rebuilds the debug APK. One initial aggregate run saw three `StalkerTransportFactoryTest` MockWebServer timeouts; the class passed immediately in isolation and the complete rerun passed. Device/emulator execution of the Room/WorkManager instrumentation tests is the remaining ARCH-003 closure evidence; `adb` finds no connected device and no emulator/AVD is installed here.diff --git a/domain/src/main/java/com/streamvault/domain/util/BoundedExpiringCache.kt b/domain/src/main/java/com/streamvault/domain/util/BoundedExpiringCache.ktnew file mode 100644index 00000000..6ef7b17d--- /dev/null+++ b/domain/src/main/java/com/streamvault/domain/util/BoundedExpiringCache.kt@@ -0,0 +1,99 @@+package com.streamvault.domain.util++import java.util.LinkedHashMap++/**+ * Small process-local cache with a hard entry bound and lazy time-based expiry.+ *+ * Eviction only drops the cache reference. Callers that cache resources such as HTTP clients+ * must not close them from the eviction callback because an in-flight operation may still own+ * the resource.+ */+class BoundedExpiringCache<K, V>(+ private val maxEntries: Int,+ private val ttlMillis: Long,+ private val clock: () -> Long = System::currentTimeMillis+) {+ private data class Entry<V>(val value: V, val storedAt: Long)++ private val entries = LinkedHashMap<K, Entry<V>>(16, 0.75f, true)+ private var operationsSinceSweep = 0++ init {+ require(maxEntries > 0) { "maxEntries must be positive" }+ require(ttlMillis >= 0L) { "ttlMillis must not be negative" }+ }++ @Synchronized+ fun get(key: K): V? {+ sweepIfDue()+ val entry = entries[key] ?: return null+ if (isExpired(entry)) {+ entries.remove(key)+ return null+ }+ return entry.value+ }++ @Synchronized+ fun put(key: K, value: V): V? {+ sweepIfDue()+ val previous = entries.put(key, Entry(value, clock()))?.value+ trimToBound()+ return previous+ }++ @Synchronized+ fun getOrPut(key: K, factory: () -> V): V {+ get(key)?.let { return it }+ val value = factory()+ put(key, value)+ return value+ }++ @Synchronized+ fun remove(key: K): V? = entries.remove(key)?.value++ @Synchronized+ fun clear() {+ entries.clear()+ }++ @Synchronized+ fun size(): Int {+ sweepAll()+ return entries.size+ }++ private fun isExpired(entry: Entry<V>): Boolean =+ ttlMillis == 0L || clock() - entry.storedAt >= ttlMillis++ private fun sweepIfDue() {+ operationsSinceSweep+++ if (operationsSinceSweep >= SWEEP_INTERVAL) {+ operationsSinceSweep = 0+ sweepAll()+ }+ }++ private fun sweepAll() {+ if (entries.isEmpty()) return+ val now = clock()+ entries.entries.removeIf { (_, entry) -> ttlMillis == 0L || now - entry.storedAt >= ttlMillis }+ }++ private fun trimToBound() {+ while (entries.size > maxEntries) {+ entries.entries.iterator().apply {+ if (hasNext()) {+ next()+ remove()+ }+ }+ }+ }++ private companion object {+ const val SWEEP_INTERVAL = 128+ }+}diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.tomlindex 02521bb1..2436d781 100644--- a/gradle/libs.versions.toml+++ b/gradle/libs.versions.toml@@ -115,6 +115,7 @@ core-ktx = { group = "androidx.core", name = "core-ktx", version = "1.18.0" }documentfile = { group = "androidx.documentfile", name = "documentfile", version = "1.1.0" }activity-compose = { group = "androidx.activity", name = "activity-compose", version = "1.13.0" }work-runtime-ktx = { group = "androidx.work", name = "work-runtime-ktx", version.ref = "work" }+work-testing = { group = "androidx.work", name = "work-testing", version.ref = "work" }appcompat = { group = "androidx.appcompat", name = "appcompat", version.ref = "appcompat" }mediarouter = { group = "androidx.mediarouter", name = "mediarouter", version.ref = "mediarouter" }play-services-cast-framework = { group = "com.google.android.gms", name = "play-services-cast-framework", version.ref = "play-services-cast-framework" }diff --git a/player/src/main/java/com/streamvault/player/playback/PlayerAddressHealthStore.kt b/player/src/main/java/com/streamvault/player/playback/PlayerAddressHealthStore.ktindex f1f2e091..b20380a5 100644--- a/player/src/main/java/com/streamvault/player/playback/PlayerAddressHealthStore.kt+++ b/player/src/main/java/com/streamvault/player/playback/PlayerAddressHealthStore.kt@@ -1,8 +1,8 @@package com.streamvault.player.playback+import com.streamvault.domain.util.BoundedExpiringCacheimport java.net.InetAddressimport java.util.Locale-import java.util.concurrent.ConcurrentHashMapinternal enum class PlayerAddressHealth {HEALTHY,@@ -13,7 +13,8 @@ internal enum class PlayerAddressHealth {internal class PlayerAddressHealthStore(private val healthyTtlMs: Long = DEFAULT_HEALTHY_TTL_MS,val failureTtlMs: Long = DEFAULT_FAILURE_TTL_MS,- private val clock: () -> Long = System::currentTimeMillis+ private val clock: () -> Long = System::currentTimeMillis,+ maxEntries: Int = DEFAULT_MAX_ENTRIES) {private data class AddressKey(val hostname: String,@@ -26,33 +27,39 @@ internal class PlayerAddressHealthStore(val updatedAtMs: Long)- private val entries = ConcurrentHashMap<AddressKey, Entry>()+ private val entries = BoundedExpiringCache<AddressKey, Entry>(+ maxEntries = maxEntries,+ ttlMillis = maxOf(healthyTtlMs, failureTtlMs),+ clock = clock+ )fun markHealthy(hostname: String, port: Int, address: InetAddress?) {if (address == null) return- entries[key(hostname, port, address)] = Entry(PlayerAddressHealth.HEALTHY, clock())+ entries.put(key(hostname, port, address), Entry(PlayerAddressHealth.HEALTHY, clock()))}fun markUnhealthy(hostname: String, port: Int, address: InetAddress?) {if (address == null) return- entries[key(hostname, port, address)] = Entry(PlayerAddressHealth.UNHEALTHY, clock())+ entries.put(key(hostname, port, address), Entry(PlayerAddressHealth.UNHEALTHY, clock()))}fun health(hostname: String, port: Int, address: InetAddress): PlayerAddressHealth {val key = key(hostname, port, address)- val entry = entries[key] ?: return PlayerAddressHealth.UNKNOWN+ val entry = entries.get(key) ?: return PlayerAddressHealth.UNKNOWNval ttlMs = when (entry.health) {PlayerAddressHealth.HEALTHY -> healthyTtlMsPlayerAddressHealth.UNHEALTHY -> failureTtlMsPlayerAddressHealth.UNKNOWN -> 0L}if (clock() - entry.updatedAtMs > ttlMs) {- entries.remove(key, entry)+ entries.remove(key)return PlayerAddressHealth.UNKNOWN}return entry.health}+ internal fun sizeForTests(): Int = entries.size()+private fun key(hostname: String, port: Int, address: InetAddress): AddressKey {return AddressKey(hostname = hostname.lowercase(Locale.US),@@ -64,5 +71,6 @@ internal class PlayerAddressHealthStore(private companion object {const val DEFAULT_HEALTHY_TTL_MS = 10 * 60 * 1_000Lconst val DEFAULT_FAILURE_TTL_MS = 2 * 60 * 1_000L+ const val DEFAULT_MAX_ENTRIES = 2_048}}diff --git a/player/src/main/java/com/streamvault/player/playback/PlayerDataSourceFactoryProvider.kt b/player/src/main/java/com/streamvault/player/playback/PlayerDataSourceFactoryProvider.ktindex 99fa9d0f..c825f998 100644--- a/player/src/main/java/com/streamvault/player/playback/PlayerDataSourceFactoryProvider.kt+++ b/player/src/main/java/com/streamvault/player/playback/PlayerDataSourceFactoryProvider.kt@@ -9,10 +9,10 @@ import androidx.media3.datasource.okhttp.OkHttpDataSourceimport com.streamvault.domain.model.VodHttpProtocolModeimport com.streamvault.domain.model.PlaybackTransportPolicyimport com.streamvault.domain.model.StreamInfo+import com.streamvault.domain.util.BoundedExpiringCacheimport java.net.InetSocketAddressimport java.net.Proxyimport java.net.URI-import java.util.concurrent.ConcurrentHashMapimport java.util.concurrent.TimeUnitimport okhttp3.Interceptorimport okhttp3.OkHttpClient@@ -28,6 +28,8 @@ class PlayerDataSourceFactoryProvider() {private companion object {private const val TAG = "PlayerDataSource"+ private const val MAX_CLIENT_CACHE_ENTRIES = 32+ private const val CLIENT_CACHE_TTL_MILLIS = 30L * 60L * 1_000L}private data class ClientKey(@@ -41,7 +43,10 @@ class PlayerDataSourceFactoryProvider()private val addressHealthStore = PlayerAddressHealthStore()- private val clientsByKey = ConcurrentHashMap<ClientKey, OkHttpClient>()+ private val clientsByKey = BoundedExpiringCache<ClientKey, OkHttpClient>(+ maxEntries = MAX_CLIENT_CACHE_ENTRIES,+ ttlMillis = CLIENT_CACHE_TTL_MILLIS+ )fun createFactory(streamInfo: StreamInfo,@@ -69,7 +74,7 @@ class PlayerDataSourceFactoryProvider(proxyHost = streamInfo.proxyHost.trim(),proxyPort = streamInfo.proxyPort)- val client = clientsByKey.computeIfAbsent(clientKey) {+ val client = clientsByKey.getOrPut(clientKey) {val transportPolicy = streamInfo.playbackTransportPolicyval builder = when {transportPolicy != null ->@@ -115,6 +120,8 @@ class PlayerDataSourceFactoryProvider(return profile to factory}+ internal fun clientCacheSizeForTests(): Int = clientsByKey.size()+private fun logRequestShape(streamInfo: StreamInfo,headers: Map<String, String>,