Skip to content

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

Implement Stalker catalog synchronization and background execution logic

David Nashash51e8d149efb0
diff --git a/app/src/androidTest/java/com/streamvault/app/benchmark/StalkerCatalogRuntimeTest.kt b/app/src/androidTest/java/com/streamvault/app/benchmark/StalkerCatalogRuntimeTest.kt
new file mode 100644
index 00000000..ea952a2e
--- /dev/null
+++ b/app/src/androidTest/java/com/streamvault/app/benchmark/StalkerCatalogRuntimeTest.kt
@@ -0,0 +1,216 @@
+package com.streamvault.app.benchmark
+
+import android.app.Application
+import android.os.SystemClock
+import android.util.Log
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.streamvault.domain.model.CatalogLayout
+import com.streamvault.domain.model.ContentType
+import com.streamvault.domain.model.LibraryBrowseQuery
+import com.streamvault.domain.model.ProviderEpgSyncMode
+import com.streamvault.domain.model.StalkerTransportGrant
+import com.streamvault.domain.model.StalkerTransportMode
+import com.streamvault.domain.model.StalkerTransportOrigin
+import com.streamvault.domain.model.VodCategoryHydrationRequest
+import com.streamvault.domain.usecase.StalkerProviderSetupCommand
+import com.streamvault.domain.usecase.ValidateAndAddProviderResult
+import dagger.hilt.android.EntryPointAccessors
+import dagger.hilt.internal.GeneratedComponentManager
+import javax.inject.Provider
+import com.streamvault.domain.repository.MovieRepository
+import com.streamvault.domain.repository.SeriesRepository
+import com.streamvault.domain.repository.VodRepository
+import java.net.URI
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import kotlinx.coroutines.withTimeoutOrNull
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.Assume.assumeTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/** Opt-in production-graph probe. Portal credentials arrive through instrumentation arguments. */
+@RunWith(AndroidJUnit4::class)
+class StalkerCatalogRuntimeTest {
+ @Test
+ fun setupAndBrowse() = runBlocking {
+ val args = InstrumentationRegistry.getArguments()
+ assumeTrue(args.getString("stalkerCatalogProbe") == "true")
+ val portal = requireNotNull(args.getString("portal"))
+ val mac = requireNotNull(args.getString("mac"))
+ val app = ApplicationProvider.getApplicationContext<Application>()
+ check(app.packageName.endsWith(".debug"))
+ val graph = EntryPointAccessors.fromApplication(app, XtreamSyncBenchmarkEntryPoint::class.java)
+ val component = (app as GeneratedComponentManager<*>).generatedComponent()
+ fun binding(name: String): Any = (component.javaClass.getDeclaredField(name).apply { isAccessible = true }
+ .get(component) as Provider<*>).get()!!
+ val movies = binding("movieRepositoryImplProvider") as MovieRepository
+ val series = binding("seriesRepositoryImplProvider") as SeriesRepository
+ val vod = binding("vodRepositoryImplProvider") as VodRepository
+ val origin = URI(portal)
+ args.getString("cleanupProviderId")?.toLongOrNull()?.let { id ->
+ androidx.work.WorkManager.getInstance(app).cancelAllWork().result.get()
+ graph.sync().cancelStalkerIndexSync(id)
+ graph.providers().deleteProvider(id)
+ }
+ val started = SystemClock.elapsedRealtime()
+ val provider = args.getString("browseOnlyProviderId")?.toLongOrNull()?.let {
+ requireNotNull(graph.providers().getProvider(it))
+ } ?: run {
+ val result = withTimeout(240_000L) {
+ graph.setup().loginStalker(StalkerProviderSetupCommand(
+ portalUrl = portal, macAddress = mac, name = "Stalker catalog validation",
+ existingProviderId = args.getString("existingProviderId")?.toLongOrNull(),
+ stalkerAdvancedOptionsJson = args.getString("catalogOrder")?.let {
+ JSONObject().put("catalogLoadOrder", it).toString()
+ }.orEmpty(),
+ epgSyncMode = args.getString("epgMode")?.let(ProviderEpgSyncMode::valueOf) ?: ProviderEpgSyncMode.SKIP,
+ transportGrant = StalkerTransportGrant(StalkerTransportMode.USER_ACCEPTED_HTTP,
+ StalkerTransportOrigin(origin.scheme, origin.host, origin.port.takeIf { it > 0 } ?: 80),
+ consentedAt = System.currentTimeMillis())
+ ))
+ }
+ when (result) {
+ is ValidateAndAddProviderResult.Success -> result.provider
+ is ValidateAndAddProviderResult.SavedWithWarning -> result.provider
+ else -> error("Setup failed: ${result.javaClass.simpleName}")
+ }
+ }
+ val report = JSONObject().put("setupMs", SystemClock.elapsedRealtime() - started)
+ .put("providerId", provider.id).put("layout", provider.catalogLayout.name)
+ .put("savedLoadOrder", runCatching { JSONObject(provider.stalkerAdvancedOptionsJson)
+ .optString("catalogLoadOrder", "PARALLEL") }.getOrDefault("PARALLEL"))
+ val db = graph.database()
+ if (args.getString("backfill") == "true") {
+ // Observe actual worker progress before any interactive hydration or process restart.
+ fun maxPage(table: String): Int = db.openHelper.readableDatabase.query(
+ "SELECT COALESCE(MAX(last_successful_page), 0) FROM $table WHERE provider_id = ?",
+ arrayOf<Any>(provider.id)
+ ).use { it.moveToFirst(); it.getInt(0) }
+ val initialMovies = db.movieDao().getCount(provider.id).first()
+ val initialSeries = db.seriesDao().getCount(provider.id).first()
+ val requireGuide = args.getString("parallelGuide") == "true"
+ val requireBoth = args.getString("parallelCatalog") == "true"
+ val initialGuide = db.programDao().countByProvider(provider.id)
+ fun guideMetadataCount(): Int = db.openHelper.readableDatabase.query(
+ "SELECT epg_count FROM sync_metadata WHERE provider_id = ?", arrayOf<Any>(provider.id)
+ ).use { if (it.moveToFirst()) it.getInt(0) else 0 }
+ val backfillStarted = SystemClock.elapsedRealtime()
+ var finalMovies = initialMovies
+ var finalSeries = initialSeries
+ withTimeout(180_000L) {
+ while (finalMovies <= initialMovies || maxPage("movie_category_hydration") < 2 ||
+ (requireBoth && (finalSeries <= initialSeries || maxPage("series_category_hydration") < 2)) ||
+ (requireGuide && (db.programDao().countByProvider(provider.id) <= initialGuide || guideMetadataCount() == 0))) {
+ kotlinx.coroutines.delay(2_000)
+ finalMovies = db.movieDao().getCount(provider.id).first()
+ finalSeries = db.seriesDao().getCount(provider.id).first()
+ }
+ }
+ report.put("backfillMs", SystemClock.elapsedRealtime() - backfillStarted)
+ .put("initialMovies", initialMovies).put("initialSeries", initialSeries)
+ .put("backfillMovies", finalMovies).put("backfillSeries", finalSeries)
+ .put("movieMaxPage", maxPage("movie_category_hydration"))
+ .put("seriesMaxPage", maxPage("series_category_hydration"))
+ .put("initialGuide", initialGuide).put("guidePrograms", db.programDao().countByProvider(provider.id))
+ if (requireGuide) {
+ val catalogWork = androidx.work.WorkManager.getInstance(app)
+ .getWorkInfosForUniqueWork("provider-stalker-index-${provider.id}").get()
+ check(catalogWork.any { it.state == androidx.work.WorkInfo.State.RUNNING })
+ report.put("catalogRunningWhenGuidePopulated", true)
+ .put("bothCatalogsAdvanced", finalMovies > initialMovies && finalSeries > initialSeries)
+ val before = finalMovies
+ withTimeout(30_000) {
+ while (db.movieDao().getCount(provider.id).first() <= before) kotlinx.coroutines.delay(1_000)
+ }
+ report.put("moviesAfterGuide", db.movieDao().getCount(provider.id).first())
+ .put("guideMetadataCount", guideMetadataCount())
+ check(guideMetadataCount() > 0)
+ }
+ app.filesDir.resolve("stalker-backfill-report.json").writeText(report.toString(2))
+ }
+ val types = if (provider.catalogLayout == CatalogLayout.UNIFIED_VOD) listOf(ContentType.VOD)
+ else listOf(ContentType.MOVIE, ContentType.SERIES)
+ val samples = JSONArray()
+ for (type in types) {
+ val categories = db.categoryDao().getByProviderAndTypeSync(provider.id, type.name)
+ report.put("${type.name.lowercase()}Categories", categories.size)
+ for (category in categories.filter { it.categoryId > 0 && !it.name.startsWith("All", ignoreCase = true) }.take(3)) {
+ val openStarted = SystemClock.elapsedRealtime()
+ val count = withTimeoutOrNull(15_000L) {
+ when (type) {
+ ContentType.VOD -> vod.requestCategoryHydration(provider.id, category.categoryId, VodCategoryHydrationRequest.OPEN)
+ ContentType.MOVIE -> movies.requestCategoryHydration(provider.id, category.categoryId, VodCategoryHydrationRequest.OPEN)
+ else -> series.requestCategoryHydration(provider.id, category.categoryId, VodCategoryHydrationRequest.OPEN)
+ }
+ when (type) {
+ ContentType.VOD -> vod.getCategoryPreview(provider.id, category.categoryId, 30).first().size
+ ContentType.MOVIE -> movies.browseMovies(LibraryBrowseQuery(provider.id, categoryId = category.categoryId, limit = 30)).first().items.size
+ else -> series.browseSeries(LibraryBrowseQuery(provider.id, categoryId = category.categoryId, limit = 30)).first().items.size
+ }
+ }
+ samples.put(JSONObject().put("type", type.name).put("categoryId", category.categoryId)
+ .put("category", category.name).put("items", count ?: -1).put("timedOut", count == null)
+ .put("openMs", SystemClock.elapsedRealtime() - openStarted))
+ }
+ }
+ report.put("samples", samples)
+ .put("movies", db.movieDao().getCount(provider.id).first())
+ .put("series", db.seriesDao().getCount(provider.id).first())
+ val firstSeries = series.browseSeries(LibraryBrowseQuery(provider.id, limit = 1)).first().items.firstOrNull()
+ if (firstSeries != null) {
+ val detailStarted = SystemClock.elapsedRealtime()
+ val detail = withTimeoutOrNull(30_000L) { series.getSeriesDetails(provider.id, firstSeries.id) }
+ val loaded = (detail as? com.streamvault.domain.model.Result.Success)?.data
+ report.put("seriesDetailMs", SystemClock.elapsedRealtime() - detailStarted)
+ .put("seasons", loaded?.seasons?.size ?: -1)
+ .put("episodes", loaded?.seasons?.sumOf { it.episodes.size } ?: -1)
+ loaded?.seasons?.firstNotNullOfOrNull { it.episodes.firstOrNull() }?.let { episode ->
+ val linkStarted = SystemClock.elapsedRealtime()
+ val link = withTimeoutOrNull(30_000L) { series.getEpisodeStreamInfo(episode) }
+ report.put("episodeLinkMs", SystemClock.elapsedRealtime() - linkStarted)
+ .put("episodeLinkResolved", link is com.streamvault.domain.model.Result.Success)
+ }
+ }
+ app.filesDir.resolve("stalker-catalog-report.json").writeText(report.toString(2))
+ Log.i("StalkerCatalogProbe", report.toString())
+ if (args.getString("cleanup") == "true") {
+ graph.sync().cancelStalkerIndexSync(provider.id)
+ graph.providers().deleteProvider(provider.id)
+ }
+ check(samples.length() > 0)
+ check((0 until samples.length()).all { samples.getJSONObject(it).getInt("items") > 0 })
+ check(report.getInt("movies") + report.getInt("series") > 0)
+ if (firstSeries != null) {
+ check(report.optInt("episodes", -1) > 0)
+ check(report.optBoolean("episodeLinkResolved"))
+ }
+ if (args.getString("screens") == "true") {
+ val device = androidx.test.uiautomator.UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
+ androidx.test.core.app.ActivityScenario.launch<com.streamvault.app.MainActivity>(
+ android.content.Intent(app, com.streamvault.app.MainActivity::class.java)
+ ).use {
+ for ((label, route) in listOf("Movies" to "movies", "Series" to "series")) {
+ val tab = requireNotNull(device.wait(androidx.test.uiautomator.Until.findObject(
+ androidx.test.uiautomator.By.desc(label)), 15_000))
+ val center = tab.visibleCenter
+ device.executeShellCommand("input mouse tap ${center.x} ${center.y}")
+ check(device.wait(androidx.test.uiautomator.Until.hasObject(
+ androidx.test.uiautomator.By.descStartsWith("streamvault.destination:$route")), 15_000))
+ val library = requireNotNull(device.wait(androidx.test.uiautomator.Until.findObject(
+ androidx.test.uiautomator.By.text("Browse Full ${if (route == "movies") "Movie" else "Series"} Library")), 15_000))
+ val button = library.visibleCenter
+ device.executeShellCommand("input mouse tap ${button.x} ${button.y}")
+ SystemClock.sleep(1_000)
+ check(device.currentPackageName == app.packageName)
+ check(device.takeScreenshot(app.filesDir.resolve("stalker-$route-ui.png")))
+ device.dumpWindowHierarchy(app.filesDir.resolve("stalker-$route-ui.xml"))
+ }
+ }
+ }
+ }
+}
diff --git a/data/build.gradle.kts b/data/build.gradle.kts
index 2fc45e82..5d51486f 100644
--- a/data/build.gradle.kts
+++ b/data/build.gradle.kts
@@ -14,8 +14,7 @@ android {
defaultConfig {
minSdk = 25
- // Enable only in validation builds until portal and multi-channel playback evidence exists.
- buildConfigField("boolean", "STALKER_ADAPTIVE_INDEXING", (providers.gradleProperty("stalkerAdaptiveIndexing").orNull == "true").toString())
+ buildConfigField("boolean", "STALKER_ADAPTIVE_INDEXING", "true")
val requestedStalkerPageConcurrency = providers.gradleProperty("stalkerIndexPageConcurrency")
.orNull
?.toIntOrNull()
diff --git a/data/src/androidTest/java/com/streamvault/data/local/ProviderWorkManagerSerializationTest.kt b/data/src/androidTest/java/com/streamvault/data/local/ProviderWorkManagerSerializationTest.kt
index a45b2bde..1463987b 100644
--- a/data/src/androidTest/java/com/streamvault/data/local/ProviderWorkManagerSerializationTest.kt
+++ b/data/src/androidTest/java/com/streamvault/data/local/ProviderWorkManagerSerializationTest.kt
@@ -4,6 +4,10 @@ import android.content.Context
import androidx.test.core.app.ApplicationProvider
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.work.Configuration
+import androidx.work.ExistingWorkPolicy
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.Worker
+import androidx.work.WorkerParameters
import androidx.work.WorkInfo
import androidx.work.WorkManager
import androidx.work.testing.WorkManagerTestInitHelper
@@ -11,8 +15,9 @@ 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 com.streamvault.data.sync.providerEpgWorkUniqueName
+import com.streamvault.data.sync.stalkerIndexWorkUniqueName
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith
@@ -39,28 +44,59 @@ class ProviderWorkManagerSerializationTest {
}
@Test
- fun everyBackgroundPhaseForAProviderIsAppendedToOneSerialChain() {
+ fun catalogContinuationIsNotDroppedBehindProviderSetupAndGuide() {
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)
+ // Duplicate startup recovery must coalesce rather than duplicate the index.
+ StalkerIndexWorker.enqueue(context, providerId, initialDelaySeconds = ONE_HOUR_SECONDS)
- val work = workManager.getWorkInfosForUniqueWork(providerWorkUniqueName(providerId))
+ val setup = workManager.getWorkInfosForUniqueWork(providerWorkUniqueName(providerId))
+ .get(10, TimeUnit.SECONDS)
+ val catalog = workManager.getWorkInfosForUniqueWork(stalkerIndexWorkUniqueName(providerId))
+ .get(10, TimeUnit.SECONDS)
+ val guide = workManager.getWorkInfosForUniqueWork(providerEpgWorkUniqueName(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
- )
+ assertThat(setup).hasSize(1)
+ assertThat(catalog).hasSize(1)
+ assertThat(catalog.single().state).isEqualTo(WorkInfo.State.ENQUEUED)
+ assertThat(guide).hasSize(1)
+ assertThat(guide.single().state).isEqualTo(WorkInfo.State.ENQUEUED)
+
+ // Guide cancellation cannot poison the catalog's prerequisite chain.
+ workManager.cancelUniqueWork(providerEpgWorkUniqueName(providerId)).result.get(10, TimeUnit.SECONDS)
+ assertThat(workManager.getWorkInfoById(catalog.single().id).get(10, TimeUnit.SECONDS)!!.state)
+ .isEqualTo(WorkInfo.State.ENQUEUED)
+
+ // Canceling catalog work must not cancel provider setup.
+ StalkerIndexWorker.cancel(context, providerId)
+ workManager.getWorkInfosForUniqueWork(stalkerIndexWorkUniqueName(providerId)).get(10, TimeUnit.SECONDS)
+ assertThat(workManager.getWorkInfoById(setup.single().id).get(10, TimeUnit.SECONDS)!!.state)
+ .isNotEqualTo(WorkInfo.State.CANCELLED)
}
private companion object {
const val ONE_HOUR_SECONDS = 3_600L
}
+
+ @Test
+ fun failedGuideDoesNotFailOrBlockCatalogContinuation() {
+ val providerId = 72L
+ StalkerIndexWorker.enqueue(context, providerId, initialDelaySeconds = ONE_HOUR_SECONDS)
+ val failedGuide = OneTimeWorkRequestBuilder<FailingGuideWorker>().build()
+ workManager.enqueueUniqueWork(providerEpgWorkUniqueName(providerId), ExistingWorkPolicy.REPLACE, failedGuide)
+ .result.get(10, TimeUnit.SECONDS)
+ val deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(10)
+ while (workManager.getWorkInfoById(failedGuide.id).get()!!.state != WorkInfo.State.FAILED &&
+ System.nanoTime() < deadline) Thread.sleep(20)
+ assertThat(workManager.getWorkInfoById(failedGuide.id).get()!!.state).isEqualTo(WorkInfo.State.FAILED)
+ assertThat(workManager.getWorkInfosForUniqueWork(stalkerIndexWorkUniqueName(providerId)).get().single().state)
+ .isEqualTo(WorkInfo.State.ENQUEUED)
+ }
+}
+
+class FailingGuideWorker(context: Context, parameters: WorkerParameters) : Worker(context, parameters) {
+ override fun doWork(): Result = Result.failure()
}
diff --git a/data/src/main/java/com/streamvault/data/local/dao/XtreamIndexDaos.kt b/data/src/main/java/com/streamvault/data/local/dao/XtreamIndexDaos.kt
index ead7dee6..fdaa63fe 100644
--- a/data/src/main/java/com/streamvault/data/local/dao/XtreamIndexDaos.kt
+++ b/data/src/main/java/com/streamvault/data/local/dao/XtreamIndexDaos.kt
@@ -127,6 +127,17 @@ abstract class XtreamContentIndexDao {
)
abstract suspend fun markRowsStaleForProviderAndType(providerId: Long, contentType: String): Int
+ @Query("""
+ UPDATE xtream_content_index SET stale_state = 'ACTIVE', error_state = NULL
+ WHERE provider_id = :providerId AND content_type = :contentType AND (
+ (:contentType = 'MOVIE' AND local_content_id IN
+ (SELECT id FROM movies WHERE provider_id = :providerId AND category_id = :categoryId)) OR
+ (:contentType = 'SERIES' AND local_content_id IN
+ (SELECT id FROM series WHERE provider_id = :providerId AND category_id = :categoryId))
+ )
+ """)
+ abstract suspend fun markCategoryRowsFresh(providerId: Long, contentType: String, categoryId: Long): Int
+
@Query("DELETE FROM xtream_content_index WHERE provider_id = :providerId")
abstract suspend fun deleteByProvider(providerId: Long): Int
diff --git a/data/src/main/java/com/streamvault/data/provider/StalkerLearningMapper.kt b/data/src/main/java/com/streamvault/data/provider/StalkerLearningMapper.kt
index 3ce5015f..5f4d208a 100644
--- a/data/src/main/java/com/streamvault/data/provider/StalkerLearningMapper.kt
+++ b/data/src/main/java/com/streamvault/data/provider/StalkerLearningMapper.kt
@@ -14,6 +14,20 @@ internal fun StalkerPortalStateEntity.toGenerationValidLearning(
return runCatching { gson.fromJson(learningJson, StalkerPortalLearning::class.java) }
.getOrNull()
?.takeIf { it.configurationGeneration == expectedGeneration }
+ ?.let { learning ->
+ // Older wildcard probes accidentally disabled the entire catalog capability.
+ val capabilities = learning.capabilities.orEmpty().toMutableMap()
+ fun repair(key: String, wildcardSupported: Boolean?) {
+ val observation = capabilities[key]
+ if (wildcardSupported == false && observation?.value == CapabilityState.UNSUPPORTED &&
+ observation.source == StalkerObservationSource.CATALOG) capabilities.remove(key)
+ }
+ repair("vod", movieWildcardSupported)
+ repair("series", seriesWildcardSupported)
+ runCatching {
+ learning.copy(capabilities = capabilities, discoveryEvidence = learning.discoveryEvidence.orEmpty())
+ }.getOrNull()
+ }
}
val source = runCatching { StalkerObservationSource.valueOf(observationSource) }
.getOrDefault(StalkerObservationSource.DISCOVERY)
@@ -21,8 +35,8 @@ internal fun StalkerPortalStateEntity.toGenerationValidLearning(
fun <T> observed(value: T) = StalkerObservation(value, expectedGeneration, source, time)
val capabilities = buildMap {
bulkLiveSupported?.let { put("live", observed(if (it) CapabilityState.SUPPORTED else CapabilityState.UNSUPPORTED)) }
- movieWildcardSupported?.let { put("vod", observed(if (it) CapabilityState.SUPPORTED else CapabilityState.UNSUPPORTED)) }
- seriesWildcardSupported?.let { put("series", observed(if (it) CapabilityState.SUPPORTED else CapabilityState.UNSUPPORTED)) }
+ movieWildcardSupported?.let { put("vod_wildcard", observed(if (it) CapabilityState.SUPPORTED else CapabilityState.UNSUPPORTED)) }
+ seriesWildcardSupported?.let { put("series_wildcard", observed(if (it) CapabilityState.SUPPORTED else CapabilityState.UNSUPPORTED)) }
epgSupported?.let { put("epg", observed(if (it) CapabilityState.SUPPORTED else CapabilityState.UNSUPPORTED)) }
}
return StalkerPortalLearning(
diff --git a/data/src/main/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiService.kt b/data/src/main/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiService.kt
index 4187a724..14a95778 100644
--- a/data/src/main/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiService.kt
+++ b/data/src/main/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiService.kt
@@ -961,68 +961,71 @@ class OkHttpStalkerApiService @Inject constructor(
contentType = "vod"
)
+ override suspend fun getSeriesDetailsInCategory(
+ session: StalkerSession,
+ profile: StalkerDeviceProfile,
+ seriesId: String,
+ categoryId: String
+ ): Result<StalkerSeriesDetails> = getSeriesDetailsForType(session, profile, seriesId, "series", categoryId)
+
private suspend fun getSeriesDetailsForType(
session: StalkerSession,
profile: StalkerDeviceProfile,
seriesId: String,
- contentType: String
+ contentType: String,
+ categoryId: String? = null
): Result<StalkerSeriesDetails> = runApiCall("Failed to load series details") {
+ val seasonQuery = buildMap {
+ put("type", contentType)
+ put("action", "get_ordered_list")
+ put("JsHttpRequest", "1-xml")
+ put("movie_id", seriesId)
+ categoryId?.takeIf { it.isNotBlank() }?.let { put("category", it) }
+ put("p", "1")
+ if (contentType == "vod") {
+ put("season_id", "0")
+ put("episode_id", "0")
+ }
+ }
val seriesPayload = requestJson(
url = session.loadUrl,
profile = profile,
referer = session.portalReferer,
token = session.token,
- query = mapOf(
- "type" to contentType,
- "action" to "get_ordered_list",
- "JsHttpRequest" to "1-xml",
- "movie_id" to seriesId,
- "season_id" to "0",
- "episode_id" to "0"
- )
+ query = seasonQuery
)
val seedEntries = seriesPayload.extractItemEntries().toMutableList()
- if (contentType == "vod") {
- val seedFingerprints = mutableSetOf(
- seedEntries.joinToString("|") { it.findString("id").orEmpty() }
+ val seedFingerprints = mutableSetOf(
+ seedEntries.joinToString("|") { it.findString("id").orEmpty() }
+ )
+ val seedTotalPages = seriesPayload.totalPages()
+ if (seedTotalPages > MAX_PAGE_COUNT) {
+ throw StalkerApiError.CatalogTruncated(
+ advertisedTotalPages = seedTotalPages,
+ pageLimit = MAX_PAGE_COUNT
+ )
+ }
+ for (page in 2..seedTotalPages) {
+ val pagePayload = requestJson(
+ url = session.loadUrl,
+ profile = profile,
+ referer = session.portalReferer,
+ token = session.token,
+ query = seasonQuery + ("p" to page.toString())
)
- val seedTotalPages = seriesPayload.totalPages()
- if (seedTotalPages > MAX_PAGE_COUNT) {
- throw StalkerApiError.CatalogTruncated(
- advertisedTotalPages = seedTotalPages,
- pageLimit = MAX_PAGE_COUNT
+ val pageEntries = pagePayload.extractItemEntries()
+ val fingerprint = pageEntries.joinToString("|") { it.findString("id").orEmpty() }
+ if (fingerprint.isNotEmpty() && !seedFingerprints.add(fingerprint)) {
+ throw StalkerApiError.Malformed(
+ "Portal repeated a series-detail page while loading page $page."
)
}
- for (page in 2..seedTotalPages) {
- val pagePayload = requestJson(
- url = session.loadUrl,
- profile = profile,
- referer = session.portalReferer,
- token = session.token,
- query = mapOf(
- "type" to contentType,
- "action" to "get_ordered_list",
- "JsHttpRequest" to "1-xml",
- "movie_id" to seriesId,
- "season_id" to "0",
- "episode_id" to "0",
- "p" to page.toString()
- )
+ if (pageEntries.isEmpty() && page < seedTotalPages) {
+ throw StalkerApiError.Malformed(
+ "Portal returned an empty series-detail page before its advertised end."
)
- val pageEntries = pagePayload.extractItemEntries()
- val fingerprint = pageEntries.joinToString("|") { it.findString("id").orEmpty() }
- if (fingerprint.isNotEmpty() && !seedFingerprints.add(fingerprint)) {
- throw StalkerApiError.Malformed(
- "Portal repeated a series-detail page while loading page $page."
- )
- }
- if (pageEntries.isEmpty() && page < seedTotalPages) {
- throw StalkerApiError.Malformed(
- "Portal returned an empty series-detail page before its advertised end."
- )
- }
- seedEntries += pageEntries
}
+ seedEntries += pageEntries
}
val seriesItems = seriesPayload.toItemRecords(profile.timezone.toPortalZoneId())
val series = seriesItems.firstOrNull { item -> !item.looksLikeSeasonShell() }
@@ -1048,6 +1051,7 @@ class OkHttpStalkerApiService @Inject constructor(
val paginationEvidence = mutableListOf<StalkerEpisodePaginationEvidence>()
val seasons = if (seasonRows.isNotEmpty()) {
seasonRows.mapIndexed { index, (seasonId, entry) ->
+ entry.toSeasonShellRecord(index + 1)?.let { return@mapIndexed it }
val pages = fetchSeriesEpisodePages(
session = session,
profile = profile,
@@ -1076,24 +1080,7 @@ class OkHttpStalkerApiService @Inject constructor(
}
} else if (shellSeasonRows.isNotEmpty()) {
shellSeasonRows.map { (seasonId, entry) ->
- val episodesPayload = requestJson(
- url = session.loadUrl,
- profile = profile,
- referer = session.portalReferer,
- token = session.token,
- query = mapOf(
- "type" to contentType,
- "action" to "get_ordered_list",
- "JsHttpRequest" to "1-xml",
- "movie_id" to seriesId,
- "season_id" to seasonId,
- "episode_id" to "0"
- )
- )
- entry.toSeasonRecord(
- episodeEntries = episodesPayload.extractItemEntries(),
- fallbackSeasonNumber = seasonId.toIntOrNull()
- )
+ requireNotNull(entry.toSeasonShellRecord(seasonId.toIntOrNull() ?: 1))
}
} else {
listOf(
@@ -3736,6 +3723,7 @@ class OkHttpStalkerApiService @Inject constructor(
title = "$seasonName Episode $episodeNumber",
episodeNumber = episodeNumber,
seasonNumber = fallbackSeasonNumber,
+ playbackSelector = episodeNumber,
cmd = findString("cmd"),
coverUrl = sanitizeUrl(findString("screenshot_uri")) ?: sanitizeUrl(findString("cover")),
plot = findString("description") ?: findString("plot"),
diff --git a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerAdvancedOptions.kt b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerAdvancedOptions.kt
index bc53a531..729b12ff 100644
--- a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerAdvancedOptions.kt
+++ b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerAdvancedOptions.kt
@@ -10,6 +10,7 @@ import kotlinx.serialization.json.booleanOrNull
import kotlinx.serialization.json.intOrNull
import kotlinx.serialization.json.jsonObject
import kotlinx.serialization.json.jsonPrimitive
+import com.streamvault.domain.model.StalkerCatalogLoadOrder
@Serializable
data class StalkerAdvancedOptions(
@@ -21,7 +22,8 @@ data class StalkerAdvancedOptions(
val proxyEnabled: Boolean = false,
val proxyHost: String = "",
val proxyPort: Int? = null,
- val requestRules: List<StalkerRequestRule> = emptyList()
+ val requestRules: List<StalkerRequestRule> = emptyList(),
+ val catalogLoadOrder: StalkerCatalogLoadOrder = StalkerCatalogLoadOrder.PARALLEL
) {
val normalizedLink: String
get() = when {
@@ -79,6 +81,7 @@ object StalkerAdvancedOptionsCodec {
@OptIn(ExperimentalSerializationApi::class)
private val json = Json {
ignoreUnknownKeys = true
+ coerceInputValues = true
encodeDefaults = true
explicitNulls = false
}
diff --git a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerApiService.kt b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerApiService.kt
index 7496cd3d..2897de61 100644
--- a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerApiService.kt
+++ b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerApiService.kt
@@ -446,6 +446,13 @@ interface StalkerApiService {
seriesId: String
): Result<StalkerSeriesDetails> = getSeriesDetails(session, profile, seriesId)
+ suspend fun getSeriesDetailsInCategory(
+ session: StalkerSession,
+ profile: StalkerDeviceProfile,
+ seriesId: String,
+ categoryId: String
+ ): Result<StalkerSeriesDetails> = getSeriesDetails(session, profile, seriesId)
+
suspend fun getShortEpg(
session: StalkerSession,
profile: StalkerDeviceProfile,
diff --git a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerPortalStateStore.kt b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerPortalStateStore.kt
index fc329c9a..6c0e5116 100644
--- a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerPortalStateStore.kt
+++ b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerPortalStateStore.kt
@@ -294,8 +294,8 @@ class StalkerPortalStateStore @Inject constructor(
configurationGeneration: Long? = null
) = update(providerId, configurationGeneration) { state ->
val capability = when (contentType) {
- ContentType.MOVIE -> "vod"
- ContentType.SERIES -> "series"
+ ContentType.MOVIE -> "vod_wildcard"
+ ContentType.SERIES -> "series_wildcard"
else -> null
}
val learned = capability?.let {
diff --git a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerProvider.kt b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerProvider.kt
index 3eebd104..49b783ca 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
@@ -86,16 +86,6 @@ data class StalkerVodCatalogItem(
private object LiveStreamLimitReached : Exception("live stream cap reached")
-private sealed interface VodPageBaseResolution {
- data class Known(val pageBase: Int) : VodPageBaseResolution
- data class Probed(
- val pageBase: Int,
- val pageZero: Result<StalkerPagedItems>,
- val pageOne: Result<StalkerPagedItems>
- ) : VodPageBaseResolution
- data class Failed(val result: Result<StalkerPagedItems>) : VodPageBaseResolution
-}
-
class StalkerProvider(
val providerId: Long,
private val api: StalkerApiService,
@@ -163,8 +153,6 @@ internal companion object {
private val sharedPortalAuthCache = ConcurrentHashMap<String, CachedAuth>()
private val sharedAuthFailureCache = ConcurrentHashMap<String, CachedAuthFailure>()
private val sharedAuthMutexes = KeyedMutexRegistry<String>()
- private val sharedVodPageBaseCache = ConcurrentHashMap<String, Int>()
- private val sharedVodPageBaseMutexes = KeyedMutexRegistry<String>()
private val resolvedStreamUrlCache = ConcurrentHashMap<String, CachedResolvedUrl>()
private val missingVodClassificationLogged = ConcurrentHashMap.newKeySet<Long>()
@@ -173,7 +161,6 @@ internal companion object {
sharedAuthCache.clear()
sharedPortalAuthCache.clear()
sharedAuthFailureCache.clear()
- sharedVodPageBaseCache.clear()
}
fun clearResolvedStreamUrlCacheForTests() {
@@ -189,8 +176,6 @@ internal companion object {
val portalPrefix = "portal:$providerId|"
sharedPortalAuthCache.keys.filter { it.startsWith(portalPrefix) }.forEach(sharedPortalAuthCache::remove)
sharedAuthFailureCache.keys.filter { it.startsWith(authPrefix) }.forEach(sharedAuthFailureCache::remove)
- sharedVodPageBaseCache.keys.filter { it.startsWith("portal:$providerId|") }
- .forEach(sharedVodPageBaseCache::remove)
resolvedStreamUrlCache.keys
.filter { it.startsWith("$providerId|") }
.forEach(resolvedStreamUrlCache::remove)
@@ -276,6 +261,8 @@ internal companion object {
private val categoryLookups = ConcurrentHashMap<ContentType, CategoryLookup>()
private var resolvedCategorySnapshot: StalkerResolvedCategoryHandoff.Snapshot? = null
private val remoteIdentityCache = ConcurrentHashMap<Pair<ContentType, String>, Long>()
+ // Category IDs must survive eviction of the much larger content identity cache.
+ private val categoryIdentityCache = ConcurrentHashMap<Pair<ContentType, String>, Long>()
suspend fun invalidateAuthentication() {
resolvedCategorySnapshot = null
@@ -609,14 +596,14 @@ internal companion object {
getVodStreamsPage(categoryId, page, sortBy = null)
suspend fun getVodStreamsPage(categoryId: Long?, page: Int, sortBy: String?): Result<StalkerPagedResult<Movie>> =
- loadVodPageWithPortalPageBase(ContentType.MOVIE, categoryId, page, sortBy = sortBy).let { result ->
+ loadVodCatalogPage(ContentType.MOVIE, categoryId, page, sortBy = sortBy).let { result ->
mapResolvedPage(ContentType.MOVIE, result) { item ->
toMovie(item, requestedCategoryId = categoryId)
}
}
suspend fun getVodStreamsPageUsingItemCategories(categoryId: Long?, page: Int): Result<StalkerPagedResult<Movie>> =
- loadVodPageWithPortalPageBase(
+ loadVodCatalogPage(
ContentType.MOVIE,
categoryId,
page,
@@ -630,6 +617,9 @@ internal companion object {
suspend fun getUnifiedVodPage(categoryId: Long, page: Int): Result<StalkerPagedResult<StalkerVodCatalogItem>> =
getClassifiedVodPage(ContentType.VOD, categoryId, page)
+ suspend fun getUnifiedVodPageUsingItemCategories(categoryId: Long, page: Int): Result<StalkerPagedResult<StalkerVodCatalogItem>> =
+ getClassifiedVodPage(ContentType.VOD, categoryId, page, sortBy = WILDCARD_INDEX_SORT, preserveItemCategories = true)
+
suspend fun getUnifiedVodPage(
categoryId: Long,
page: Int,
@@ -663,6 +653,13 @@ internal companion object {
)
}
+ suspend fun getSplitVodPage(
+ categoryId: Long,
+ page: Int,
+ sortBy: String?
+ ): Result<StalkerPagedResult<StalkerVodCatalogItem>> =
+ getClassifiedVodPage(ContentType.MOVIE, categoryId, page, seriesCategoryId = null, sortBy = sortBy)
+
suspend fun getSplitVodPage(
categoryId: Long,
seriesCategoryId: Long,
@@ -720,28 +717,31 @@ internal companion object {
page: Int,
seriesCategoryId: Long? = categoryId,
searchQuery: String? = null,
- sortBy: String? = null
+ sortBy: String? = null,
+ preserveItemCategories: Boolean = false
): Result<StalkerPagedResult<StalkerVodCatalogItem>> {
- val rawResult = loadVodPageWithPortalPageBase(categoryType, categoryId, page, searchQuery, sortBy)
+ val rawResult = loadVodCatalogPage(categoryType, categoryId, page, searchQuery, sortBy)
return when (rawResult) {
is Result.Success -> {
val raw = rawResult.data
val movieRecords = raw.items.filterNot(StalkerItemRecord::isSeries)
val seriesRecords = raw.items.filter(StalkerItemRecord::isSeries)
+ val projectedSeriesCategory = if (preserveItemCategories) null else seriesCategoryId ?: categoryId?.takeIf { seriesRecords.isNotEmpty() }
+ ?.let { projectVodCategoryToSeries(it) }
bindRemoteIds(ContentType.MOVIE, movieRecords.map(StalkerItemRecord::id))
bindRemoteIds(ContentType.SERIES, seriesRecords.map(StalkerItemRecord::id))
val items = raw.items.mapNotNull { record ->
if (record.isSeries) {
toSeries(
item = record,
- requestedCategoryId = seriesCategoryId,
+ requestedCategoryId = projectedSeriesCategory,
categoryType = if (categoryType == ContentType.VOD) ContentType.VOD else ContentType.SERIES,
origin = SeriesCatalogOrigin.VOD_DERIVED
)?.let { StalkerVodCatalogItem(record.id, VodCatalogItem.SeriesItem(it)) }
} else {
toMovie(
item = record,
- requestedCategoryId = categoryId,
+ requestedCategoryId = categoryId.takeUnless { preserveItemCategories },
categoryType = categoryType
)?.let { StalkerVodCatalogItem(record.id, VodCatalogItem.MovieItem(it)) }
}
@@ -821,7 +821,7 @@ internal companion object {
}
suspend fun getSeriesListPage(categoryId: Long?, page: Int): Result<StalkerPagedResult<Series>> =
- getSeriesListPage(categoryId, page, sortBy = null)
+ getSeriesListPage(categoryId, page, sortBy = "added")
suspend fun getSeriesListPage(categoryId: Long?, page: Int, sortBy: String?): Result<StalkerPagedResult<Series>> {
val primary = getNativeSeriesListPage(categoryId, page, sortBy)
@@ -829,7 +829,7 @@ internal companion object {
// empty (providers that serve series inside VOD). Only triggers when the primary
// path produces zero items, so portals using type=series are unaffected.
if (primary is Result.Success && primary.data.items.isEmpty()) {
- val vodPage = loadVodPageWithPortalPageBase(ContentType.SERIES, categoryId, page, sortBy = sortBy)
+ val vodPage = loadVodCatalogPage(ContentType.SERIES, categoryId, page, sortBy = sortBy)
.let { result -> mapResolvedPage(ContentType.SERIES, result) { item ->
if (item.isSeries) {
toSeries(
@@ -847,7 +847,12 @@ internal companion object {
}
suspend fun getNativeSeriesListPage(categoryId: Long?, page: Int): Result<StalkerPagedResult<Series>> =
- getNativeSeriesListPage(categoryId, page, sortBy = null)
+ getNativeSeriesListPage(categoryId, page, sortBy = "added")
+
+ suspend fun getNativeSeriesListPageUsingItemCategories(categoryId: Long, page: Int): Result<StalkerPagedResult<Series>> =
+ mapPagedItems(ContentType.SERIES, categoryId) { session, profile, rawCategoryId ->
+ api.getSeriesPage(session, profile, rawCategoryId, page, WILDCARD_INDEX_SORT)
+ }.let { result -> mapResolvedPage(ContentType.SERIES, result) { toSeries(it) } }
suspend fun getNativeSeriesListPage(categoryId: Long?, page: Int, sortBy: String?): Result<StalkerPagedResult<Series>> =
mapPagedItems(ContentType.SERIES, categoryId) { session, profile, rawCategoryId ->
@@ -878,14 +883,16 @@ internal companion object {
?: (reference.streamId ?: current.seriesId).toString(),
catalogOrigin = reference.seriesCatalogOrigin ?: current.catalogOrigin,
episodePlaybackTemplateUrl = reference.episodePlaybackTemplateUrl
- ?: current.episodePlaybackTemplateUrl
+ ?: current.episodePlaybackTemplateUrl,
+ categoryId = current.categoryId
)
suspend fun getSeriesInfo(
providerSeriesId: String,
catalogOrigin: SeriesCatalogOrigin = SeriesCatalogOrigin.NATIVE,
episodePlaybackTemplateUrl: String? = null,
- learnedDialect: StalkerSeriesDetailDialect = StalkerSeriesDetailDialect.UNKNOWN
+ learnedDialect: StalkerSeriesDetailDialect = StalkerSeriesDetailDialect.UNKNOWN,
+ categoryId: Long? = null
): Result<Series> {
return runWithAuthorizedSession { session, _ ->
val profile = currentDeviceProfile()
@@ -896,7 +903,9 @@ internal companion object {
val primary = if (usedVodDialect) {
api.getVodSeriesDetails(session, profile, providerSeriesId)
} else {
- api.getSeriesDetails(session, profile, providerSeriesId)
+ val rawCategory = categoryId?.let { resolveRawCategoryId(ContentType.SERIES, it) }
+ if (rawCategory == null) api.getSeriesDetails(session, profile, providerSeriesId)
+ else api.getSeriesDetailsInCategory(session, profile, providerSeriesId, rawCategory)
}
val detailsResult = if (
primary is Result.Success &&
@@ -1640,166 +1649,20 @@ is Result.Success -> {
}
}
- /**
- * The UI and durable index checkpoints use 1-based pages, but Stalker portals differ on
- * whether `p` starts at zero or one. Probe both values once per provider configuration,
- * then keep translating logical pages to the portal's raw cursor.
- */
- private suspend fun loadVodPageWithPortalPageBase(
+ /** Catalog requests and durable checkpoints both use one-based portal pages. */
+ private suspend fun loadVodCatalogPage(
categoryType: ContentType,
categoryId: Long?,
logicalPage: Int,
searchQuery: String? = null,
sortBy: String? = null
): Result<StalkerPagedItems> = runWithAuthorizedSession { session, _ ->
- val profile = currentDeviceProfile()
- val rawCategoryId = resolveRawCategoryId(categoryType, categoryId)
- val pageNumber = logicalPage.coerceAtLeast(1)
- val cacheKey = vodPageBaseCacheKey()
- if (api !is StalkerRawVodPageApi) {
- // Legacy transports do not expose a raw p=0 cursor. Keep their established
- // 1-based call shape and avoid extra requests that cannot teach an offset.
- val pageResult = when {
- sortBy != null -> api.getVodStreamsPage(
- session,
- profile,
- rawCategoryId,
- pageNumber,
- searchQuery,
- sortBy
- )
- searchQuery == null -> api.getVodStreamsPage(session, profile, rawCategoryId, pageNumber)
- else -> api.getVodStreamsPage(session, profile, rawCategoryId, pageNumber, searchQuery)
- }
- return@runWithAuthorizedSession normalizeVodPage(pageResult, pageNumber)
- }
-
- val resolution = sharedVodPageBaseCache[cacheKey]?.let { VodPageBaseResolution.Known(it) }
- ?: sharedVodPageBaseMutexes.withLock(cacheKey) {
- val learnedBase = sharedVodPageBaseCache[cacheKey]
- ?: portalStateStore?.getVodPageBase(providerId, configurationGeneration)
- ?.also { sharedVodPageBaseCache[cacheKey] = it }
- if (learnedBase != null) {
- return@withLock VodPageBaseResolution.Known(learnedBase)
- }
-
- val pageZero = requestVodPageAtPortalPage(
- session,
- profile,
- rawCategoryId,
- portalPage = 0,
- searchQuery = searchQuery,
- sortBy = sortBy
- )
- if (pageZero is Result.Error && isAuthorizationFailure(pageZero.message, pageZero.exception)) {
- return@withLock VodPageBaseResolution.Failed(pageZero)
- }
- if (pageZero is Result.Loading) {
- return@withLock VodPageBaseResolution.Failed(Result.error("Unexpected loading state"))
- }
-
- val pageOne = requestVodPageAtPortalPage(
- session,
- profile,
- rawCategoryId,
- portalPage = 1,
- searchQuery = searchQuery,
- sortBy = sortBy
- )
- if (pageOne is Result.Error && isAuthorizationFailure(pageOne.message, pageOne.exception)) {
- return@withLock VodPageBaseResolution.Failed(pageOne)
- }
- if (pageOne is Result.Loading) {
- return@withLock VodPageBaseResolution.Failed(Result.error("Unexpected loading state"))
- }
-
- val detectedBase = inferVodPageBase(pageZero, pageOne)
- if (detectedBase != null) {
- sharedVodPageBaseCache[cacheKey] = detectedBase
- portalStateStore?.recordVodPageBase(
- providerId = providerId,
- pageBase = detectedBase,
- configurationGeneration = configurationGeneration
- )
- } else if (pageZero is Result.Error) {
- // A transient failure on p=0 must not silently map page two to page one.
- return@withLock VodPageBaseResolution.Failed(pageZero)
- }
- VodPageBaseResolution.Probed(detectedBase ?: 1, pageZero, pageOne)
- }
-
- when (resolution) {
- is VodPageBaseResolution.Failed -> resolution.result
- is VodPageBaseResolution.Known -> {
- val portalPage = (pageNumber - 1 + resolution.pageBase).coerceAtLeast(0)
- normalizeVodPage(
- requestVodPageAtPortalPage(
- session,
- profile,
- rawCategoryId,
- portalPage,
- searchQuery,
- sortBy
- ),
- pageNumber
- )
- }
- is VodPageBaseResolution.Probed -> {
- val portalPage = (pageNumber - 1 + resolution.pageBase).coerceAtLeast(0)
- val target = when (portalPage) {
- 0 -> resolution.pageZero
- 1 -> resolution.pageOne
- else -> requestVodPageAtPortalPage(
- session,
- profile,
- rawCategoryId,
- portalPage,
- searchQuery,
- sortBy
- )
- }
- normalizeVodPage(target, pageNumber)
- }
- }
- }
-
- private fun inferVodPageBase(
- pageZero: Result<StalkerPagedItems>,
- pageOne: Result<StalkerPagedItems>
- ): Int? = when (pageZero) {
- is Result.Success -> when (pageOne) {
- is Result.Success -> {
- val first = pageZero.data.items
- val second = pageOne.data.items
- when {
- first.isEmpty() && second.isEmpty() -> null
- first.isNotEmpty() && second.isNotEmpty() && sameVodPage(first, second) -> 1
- first.isNotEmpty() -> 0
- else -> 1
- }
- }
- is Result.Error -> if (pageZero.data.items.isNotEmpty()) 0 else null
- is Result.Loading -> null
- }
- is Result.Error -> if (isPortalZeroPageRejection(pageZero) && pageOne is Result.Success) 1 else null
- is Result.Loading -> null
- }
-
- private fun sameVodPage(
- first: List<StalkerItemRecord>,
- second: List<StalkerItemRecord>
- ): Boolean = first.map { it.id.trim() to it.name.trim() } ==
- second.map { it.id.trim() to it.name.trim() }
-
- private fun isPortalZeroPageRejection(result: Result.Error): Boolean {
- val error = result.exception ?: return false
- if (error.isStalkerAuthorizationFailure()) return false
- return when (error) {
- is StalkerApiError.EmptyBody,
- is StalkerApiError.Malformed -> true
- is StalkerApiError -> error.httpStatus?.let { it in 400..499 && it !in setOf(401, 403, 429) } == true
- else -> false
- }
+ val page = logicalPage.coerceAtLeast(1)
+ normalizeVodPage(
+ api.getVodStreamsPage(session, currentDeviceProfile(),
+ resolveRawCategoryId(categoryType, categoryId), page, searchQuery, sortBy ?: "added"),
+ page
+ )
}
private fun normalizeVodPage(
@@ -1812,25 +1675,6 @@ is Result.Success -> {
null -> Result.error("Portal returned no page response")
}
- private fun vodPageBaseCacheKey(): String =
- "${portalIdentityKey()}|generation:$configurationGeneration|vod-page-base"
-
- private suspend fun requestVodPageAtPortalPage(
- session: StalkerSession,
- profile: StalkerDeviceProfile,
- categoryId: String?,
- portalPage: Int,
- searchQuery: String?,
- sortBy: String? = null
- ): Result<StalkerPagedItems> {
- val rawApi = api as StalkerRawVodPageApi
- return if (sortBy == null) {
- rawApi.getVodStreamsPageAtPortalPage(session, profile, categoryId, portalPage, searchQuery)
- } else {
- rawApi.getVodStreamsPageAtPortalPage(session, profile, categoryId, portalPage, searchQuery, sortBy)
- }
- }
-
private suspend fun mapPagedItems(
type: ContentType,
categoryId: Long?,
@@ -1904,10 +1748,10 @@ is Result.Success -> {
if (resolved == null) {
records.forEach { record ->
val rawId = record.id.ifBlank { record.name }.trim()
- putRemoteIdentity(type to rawId, fallbackStableId(type, rawId))
+ categoryIdentityCache[type to rawId] = fallbackStableId(type, rawId)
}
} else {
- resolved.forEach { (rawId, surrogateId) -> putRemoteIdentity(type to rawId, surrogateId) }
+ resolved.forEach { (rawId, surrogateId) -> categoryIdentityCache[type to rawId] = surrogateId }
}
}
@@ -3076,6 +2920,7 @@ private fun playbackTransportChallengeFor(url: String): StalkerTransportChalleng
?: fallbackStableId(type, rawId)
private fun syntheticCategoryId(type: ContentType, seed: String): Long {
+ categoryIdentityCache[type to seed.trim()]?.let { return it }
remoteIdentityCache[type to seed.trim()]?.let { return it }
return fallbackStableId(type, seed)
}
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.kt
index 2ab7f58f..49129f2f 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
@@ -367,11 +367,7 @@ class StalkerRequestCoordinator internal constructor(
(state.interactiveWaiters > 0 || state.interactiveInFlight > 0)
val adaptiveIndex = adaptiveIndexingEnabled && priority == StalkerNetworkPriority.INDEX
val playbackActive = StalkerTrafficCoordinator.isPlaybackActive(providerId)
- val indexWait = if (adaptiveIndex && playbackActive) {
- state.lastIndexRequestAt?.let {
- (it + StalkerAdaptiveIndexPolicy.PLAYBACK_INTERVAL_MILLIS - now).coerceAtLeast(0L)
- } ?: 0L
- } else 0L
+ val indexWait = if (adaptiveIndex && playbackActive) NETWORK_ADMISSION_POLL_MILLIS else 0L
val indexWindowFull = adaptiveIndex && state.indexNetworkInFlight >=
(if (playbackActive) 1 else state.indexLimit())
val backgroundWait = if (lowPriority && !adaptiveIndex) {
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.kt
index 8ee34451..955ae0b8 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
@@ -47,10 +47,7 @@ internal object StalkerTrafficCoordinator {
NORMAL_BACKGROUND_PAGE_DELAY_MILLIS
}
- fun shouldDeferIndexForPlayback(
- providerId: Long,
- adaptiveIndexingEnabled: Boolean = BuildConfig.STALKER_ADAPTIVE_INDEXING
- ): Boolean = !adaptiveIndexingEnabled && isPlaybackActive(providerId)
+ fun shouldDeferIndexForPlayback(providerId: Long): Boolean = isPlaybackActive(providerId)
internal fun resetForTests() {
activePlaybackCountsByProvider.clear()
diff --git a/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt
index 309e962d..30fb8c45 100644
--- a/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/MovieRepositoryImpl.kt
@@ -418,10 +418,11 @@ class MovieRepositoryImpl @Inject constructor(
query.filterBy.type != LibraryFilterType.ALL ||
query.sortBy != LibrarySortBy.LIBRARY ||
preferencesRepository.vodDuplicateHandlingMode.first() != VodDuplicateHandlingMode.SHOW_ALL
- if (requiresCompleteCategory) {
- query.categoryId?.let {
- requestCategoryHydration(query.providerId, it, VodCategoryHydrationRequest.COMPLETE)
- }
+ val browsingProvider = loadCompatibilityProvider(query.providerId)
+ if (browsingProvider?.type == ProviderType.STALKER_PORTAL) {
+ query.categoryId?.let { syncManager.prioritizeStalkerIndexCategory(query.providerId, ContentType.MOVIE, it) }
+ } else if (requiresCompleteCategory) {
+ query.categoryId?.let { requestCategoryHydration(query.providerId, it, VodCategoryHydrationRequest.COMPLETE) }
}
query.categoryId?.takeIf { normalizedSearch.length < MIN_SEARCH_QUERY_LENGTH }?.let {
val provider = loadCompatibilityProvider(query.providerId)
@@ -435,7 +436,10 @@ class MovieRepositoryImpl @Inject constructor(
)
}
}
- emit(fetchMovieBrowseResult(query))
+ val browseQuery = if (browsingProvider?.type == ProviderType.STALKER_PORTAL &&
+ query.categoryId?.let { createStalkerProvider(query.providerId).isWildcardCategory(ContentType.MOVIE, it) } == true
+ ) query.copy(categoryId = null) else query
+ emit(fetchMovieBrowseResult(browseQuery))
}.flowOn(Dispatchers.IO)
}
@@ -466,16 +470,15 @@ class MovieRepositoryImpl @Inject constructor(
): Result<Unit> {
val provider = loadCompatibilityProvider(providerId) ?: return Result.error("Provider not found")
if (provider.type != ProviderType.STALKER_PORTAL) return Result.success(Unit)
- val loadMode = preferencesRepository.vodCategoryLoadMode.first()
- val effectiveRequest = if (
- request == VodCategoryHydrationRequest.OPEN && loadMode == VodCategoryLoadMode.COMPLETE_ON_OPEN
- ) VodCategoryHydrationRequest.COMPLETE else request
+ syncManager.prioritizeStalkerIndexCategory(providerId, ContentType.MOVIE, categoryId)
+ val effectiveRequest = if (request == VodCategoryHydrationRequest.COMPLETE) {
+ VodCategoryHydrationRequest.OPEN
+ } else request
val current = movieCategoryHydrationDao.get(providerId, categoryId)
val requestedPage = if (effectiveRequest == VodCategoryHydrationRequest.NEXT_PAGE) {
((current?.lastSuccessfulPage ?: 0) + 1).coerceAtLeast(1)
} else null
if (effectiveRequest == VodCategoryHydrationRequest.OPEN && (current?.lastSuccessfulPage ?: 0) > 0) {
- scheduleMoviePrefetch(providerId, categoryId, loadMode)
return Result.success(Unit)
}
val result = if (provider.catalogLayout == CatalogLayout.SPLIT && provider.catalogLayoutDetectionVersion > 0) {
@@ -494,40 +497,9 @@ class MovieRepositoryImpl @Inject constructor(
)
Result.success(Unit)
}
- if (result is Result.Success && request == VodCategoryHydrationRequest.OPEN) {
- scheduleMoviePrefetch(providerId, categoryId, loadMode)
- }
return result
}
- private fun scheduleMoviePrefetch(providerId: Long, categoryId: Long, loadMode: VodCategoryLoadMode) {
- if (loadMode != VodCategoryLoadMode.PAGED) return
- repositoryScope.launch {
- val provider = loadBackgroundCompatibilityProvider(providerId) ?: return@launch
- val current = movieCategoryHydrationDao.get(providerId, categoryId)
- if (current?.isComplete == true) return@launch
- if (provider.catalogLayout == CatalogLayout.SPLIT && provider.catalogLayoutDetectionVersion > 0) {
- syncManager.hydrateSplitVodCategory(
- providerId,
- categoryId,
- VodCategoryHydrationRequest.NEXT_PAGE,
- ContentType.MOVIE
- )
- } else {
- val count = movieDao.getCountByCategory(providerId, categoryId).first()
- hydrateStalkerMovieCategoryToCount(
- providerId,
- categoryId,
- provider,
- requiredCount = count + 1,
- localCount = count,
- hydration = current,
- requestedPage = ((current?.lastSuccessfulPage ?: 0) + 1).coerceAtLeast(1)
- )
- }
- }
- }
-
override fun searchMovies(providerId: Long, query: String): Flow<List<Movie>> =
query.trim().takeIf { it.length >= MIN_SEARCH_QUERY_LENGTH }?.toFtsPrefixQuery().let { ftsQuery ->
if (ftsQuery.isNullOrBlank()) {
@@ -1764,6 +1736,7 @@ class MovieRepositoryImpl @Inject constructor(
requiredCount: Int,
loadCompletely: Boolean = false
): Boolean {
+ if (localCount > 0) return false
val now = System.currentTimeMillis()
val hasEmptySuccessfulCheckpoint = localCount == 0 &&
(hydration?.lastSuccessfulPage ?: hydration?.lastLoadedPage ?: 0) > 0
diff --git a/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt
index c0def532..d17ea9d5 100644
--- a/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt
@@ -358,10 +358,11 @@ class SeriesRepositoryImpl @Inject constructor(
query.filterBy.type != LibraryFilterType.ALL ||
query.sortBy != LibrarySortBy.LIBRARY ||
preferencesRepository.vodDuplicateHandlingMode.first() != VodDuplicateHandlingMode.SHOW_ALL
- if (requiresCompleteCategory) {
- query.categoryId?.let {
- requestCategoryHydration(query.providerId, it, VodCategoryHydrationRequest.COMPLETE)
- }
+ val browsingProvider = loadCompatibilityProvider(query.providerId)
+ if (browsingProvider?.type == ProviderType.STALKER_PORTAL) {
+ query.categoryId?.let { syncManager.prioritizeStalkerIndexCategory(query.providerId, ContentType.SERIES, it) }
+ } else if (requiresCompleteCategory) {
+ query.categoryId?.let { requestCategoryHydration(query.providerId, it, VodCategoryHydrationRequest.COMPLETE) }
}
query.categoryId
?.takeIf { normalizedSearch.length < MIN_SEARCH_QUERY_LENGTH }
@@ -375,7 +376,10 @@ class SeriesRepositoryImpl @Inject constructor(
)
}
}
- emit(fetchSeriesBrowseResult(query))
+ val browseQuery = if (browsingProvider?.type == ProviderType.STALKER_PORTAL &&
+ query.categoryId?.let { createStalkerProvider(query.providerId)?.isWildcardCategory(ContentType.SERIES, it) } == true
+ ) query.copy(categoryId = null) else query
+ emit(fetchSeriesBrowseResult(browseQuery))
}.flowOn(Dispatchers.IO)
}
@@ -406,10 +410,10 @@ class SeriesRepositoryImpl @Inject constructor(
): Result<Unit> {
val provider = loadCompatibilityProvider(providerId) ?: return Result.error("Provider not found")
if (provider.type != ProviderType.STALKER_PORTAL) return Result.success(Unit)
- val mode = preferencesRepository.vodCategoryLoadMode.first()
- val effectiveRequest = if (
- request == VodCategoryHydrationRequest.OPEN && mode == VodCategoryLoadMode.COMPLETE_ON_OPEN
- ) VodCategoryHydrationRequest.COMPLETE else request
+ syncManager.prioritizeStalkerIndexCategory(providerId, ContentType.SERIES, categoryId)
+ val effectiveRequest = if (request == VodCategoryHydrationRequest.COMPLETE) {
+ VodCategoryHydrationRequest.OPEN
+ } else request
val current = seriesCategoryHydrationDao.get(providerId, categoryId)
val requestedPage = if (effectiveRequest == VodCategoryHydrationRequest.NEXT_PAGE) {
((current?.lastSuccessfulPage ?: 0) + 1).coerceAtLeast(1)
@@ -439,17 +443,6 @@ class SeriesRepositoryImpl @Inject constructor(
} else {
Result.success(Unit)
}
- if (derivedResult is Result.Success && request == VodCategoryHydrationRequest.OPEN &&
- mode == VodCategoryLoadMode.PAGED
- ) {
- repositoryScope.launch {
- try {
- requestCategoryHydration(providerId, categoryId, VodCategoryHydrationRequest.NEXT_PAGE)
- } catch (_: CredentialDecryptionException) {
- logUnreadableProviderCredentials(providerId)
- }
- }
- }
return derivedResult
}
@@ -537,10 +530,9 @@ class SeriesRepositoryImpl @Inject constructor(
if (provider.type == ProviderType.STALKER_PORTAL && seriesEntity.hasFreshStalkerDetails()) {
val localSeries = buildSeriesWithPersistedEpisodes(seriesEntity)
// Older catalog-page REPLACE writes could cascade-delete the episodes
- // while leaving the parent marked as freshly hydrated. A VOD-derived
- // series with that impossible state must self-repair on the next open.
+ // while leaving the parent marked as freshly hydrated. Retry that empty
+ // episode list when the series is opened again.
if (
- seriesEntity.catalogOrigin != SeriesCatalogOrigin.VOD_DERIVED ||
localSeries.seasons.any { season -> season.episodes.isNotEmpty() }
) {
return Result.success(attachSeriesPresentation(localSeries, knownPresentation))
@@ -1715,6 +1707,7 @@ class SeriesRepositoryImpl @Inject constructor(
requiredCount: Int,
loadCompletely: Boolean = false
): Boolean {
+ if (localCount > 0) return false
val now = System.currentTimeMillis()
val hasEmptySuccessfulCheckpoint = localCount == 0 &&
(hydration?.lastSuccessfulPage ?: hydration?.lastLoadedPage ?: 0) > 0
@@ -1987,7 +1980,7 @@ class SeriesRepositoryImpl @Inject constructor(
if (cacheState != CACHE_STATE_DETAIL_HYDRATED) return false
if (detailHydratedAt <= 0L) return false
if (remoteStaleAt > 0L) return false
- return !ContentCachePolicy.shouldRefresh(detailHydratedAt, DETAIL_REFRESH_TTL_MILLIS, now)
+ return !ContentCachePolicy.shouldRefresh(detailHydratedAt, 6L * 60L * 60L * 1000L, now)
}
private fun Provider.contentCapabilityGeneration(): Int = listOf(
diff --git a/data/src/main/java/com/streamvault/data/repository/VodRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/VodRepositoryImpl.kt
index 4671ad5b..2d6c27b8 100644
--- a/data/src/main/java/com/streamvault/data/repository/VodRepositoryImpl.kt
+++ b/data/src/main/java/com/streamvault/data/repository/VodRepositoryImpl.kt
@@ -143,31 +143,13 @@ class VodRepositoryImpl @Inject constructor(
categoryId: Long,
request: VodCategoryHydrationRequest
): Result<Unit> {
- val loadMode = preferencesRepository.vodCategoryLoadMode.first()
- val effectiveRequest = if (
- request == VodCategoryHydrationRequest.OPEN && loadMode == VodCategoryLoadMode.COMPLETE_ON_OPEN
- ) VodCategoryHydrationRequest.COMPLETE else request
- val result = syncManager.hydrateUnifiedVodCategory(providerId, categoryId, effectiveRequest)
- if (result is Result.Success && request == VodCategoryHydrationRequest.OPEN &&
- loadMode == VodCategoryLoadMode.PAGED
- ) {
- repositoryScope.launch {
- syncManager.hydrateUnifiedVodCategory(
- providerId,
- categoryId,
- VodCategoryHydrationRequest.NEXT_PAGE
- )
- }
- }
- return result
+ syncManager.prioritizeStalkerIndexCategory(providerId, ContentType.MOVIE, categoryId)
+ val effectiveRequest = if (request == VodCategoryHydrationRequest.COMPLETE) VodCategoryHydrationRequest.OPEN else request
+ return syncManager.hydrateUnifiedVodCategory(providerId, categoryId, effectiveRequest)
}
override suspend fun hydrateCompletely(providerId: Long, categoryId: Long): Result<Unit> =
- syncManager.hydrateUnifiedVodCategory(
- providerId = providerId,
- categoryId = categoryId,
- request = VodCategoryHydrationRequest.COMPLETE
- )
+ requestCategoryHydration(providerId, categoryId, VodCategoryHydrationRequest.OPEN)
override suspend fun searchVod(
providerId: Long,
diff --git a/data/src/main/java/com/streamvault/data/sync/BackgroundEpgExecution.kt b/data/src/main/java/com/streamvault/data/sync/BackgroundEpgExecution.kt
new file mode 100644
index 00000000..c4ffb8bb
--- /dev/null
+++ b/data/src/main/java/com/streamvault/data/sync/BackgroundEpgExecution.kt
@@ -0,0 +1,18 @@
+package com.streamvault.data.sync
+
+import com.streamvault.domain.model.ProviderType
+
+/** Stalker guide work is owned by its unique worker and guide mutex, independently of catalog leases. */
+internal suspend fun executeBackgroundEpg(
+ providerType: ProviderType?,
+ workflow: suspend (suspend () -> ProviderWorkflowOutcome) -> ProviderWorkflowDisposition,
+ sync: suspend () -> ProviderWorkflowOutcome
+): ProviderWorkflowDisposition = if (providerType == ProviderType.STALKER_PORTAL) {
+ when (val outcome = sync()) {
+ is ProviderWorkflowOutcome.Success -> ProviderWorkflowDisposition.SUCCEEDED
+ is ProviderWorkflowOutcome.Failure -> if (outcome.retryable) ProviderWorkflowDisposition.RETRY
+ else ProviderWorkflowDisposition.FAILED
+ }
+} else {
+ workflow(sync)
+}
diff --git a/data/src/main/java/com/streamvault/data/sync/BackgroundEpgSyncWorker.kt b/data/src/main/java/com/streamvault/data/sync/BackgroundEpgSyncWorker.kt
index 9b9fffb2..2171929f 100644
--- a/data/src/main/java/com/streamvault/data/sync/BackgroundEpgSyncWorker.kt
+++ b/data/src/main/java/com/streamvault/data/sync/BackgroundEpgSyncWorker.kt
@@ -68,13 +68,17 @@ class BackgroundEpgSyncWorker(
return Result.retry()
}
when (
- entryPoint.providerWorkflowRunner().execute(
- providerId = providerId,
- phase = ProviderWorkflowPhase.EPG,
- reason = ProviderWorkflowReason.PERIODIC,
- force = force
- ) {
- when (val result = entryPoint.syncCommands().syncEpg(providerId, force = force)) {
+ executeBackgroundEpg(provider?.type, workflow = { sync ->
+ entryPoint.providerWorkflowRunner().execute(
+ providerId = providerId,
+ phase = ProviderWorkflowPhase.EPG,
+ reason = ProviderWorkflowReason.PERIODIC,
+ force = force,
+ block = sync
+ )
+ }) {
+ val epgResult = entryPoint.syncCommands().syncEpg(providerId, force = force)
+ when (val result = epgResult) {
is com.streamvault.domain.model.Result.Success -> {
// A successful EPG sync may still have transient partial failures.
val syncState = entryPoint.syncCommands().currentSyncState(providerId)
diff --git a/data/src/main/java/com/streamvault/data/sync/ProviderEpgSyncExecutor.kt b/data/src/main/java/com/streamvault/data/sync/ProviderEpgSyncExecutor.kt
index e3e3a989..4bdae987 100644
--- a/data/src/main/java/com/streamvault/data/sync/ProviderEpgSyncExecutor.kt
+++ b/data/src/main/java/com/streamvault/data/sync/ProviderEpgSyncExecutor.kt
@@ -171,13 +171,15 @@ internal class ProviderEpgSyncExecutor(
}
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
+ transactionRunner.inTransaction {
+ 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
@@ -284,8 +286,11 @@ internal class ProviderEpgSyncExecutor(
}
val uncoveredGuideRequests = guideRequests.filterNot { it.channelKey in bulkCoveredChannelKeys }
- val perChannelGuideWindowed = uncoveredGuideRequests.size > STALKER_PER_CHANNEL_EPG_REQUESTS_PER_RUN
- val fallbackGuideRequests = if (providerRateLimited) {
+ // A usable bulk guide is the completed guide result. Many portals intentionally omit
+ // channels with no programmes; probing each omitted channel can take many minutes.
+ val bulkGuideUsable = bulkCoveredChannelKeys.isNotEmpty()
+ val perChannelGuideWindowed = !bulkGuideUsable && uncoveredGuideRequests.size > STALKER_PER_CHANNEL_EPG_REQUESTS_PER_RUN
+ val fallbackGuideRequests = if (providerRateLimited || bulkGuideUsable) {
emptyList()
} else if (perChannelGuideWindowed) {
val windowCount = (uncoveredGuideRequests.size + STALKER_PER_CHANNEL_EPG_REQUESTS_PER_RUN - 1) /
@@ -379,14 +384,16 @@ internal class ProviderEpgSyncExecutor(
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
+ transactionRunner.inTransaction {
+ 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) {
@@ -565,10 +572,12 @@ internal class ProviderEpgSyncExecutor(
}
}
if (provider.guideSourcePolicy == GuideSourcePolicy.EXTERNAL_ONLY && warnings.isEmpty() && !hasRetryableFailure) {
- val current = syncMetadataRepository.getMetadata(provider.id) ?: metadata
- syncMetadataRepository.updateMetadata(current.copy(
- lastEpgSync = now, lastEpgSuccess = now, epgCount = programDao.countByProvider(provider.id)
- ))
+ transactionRunner.inTransaction {
+ val current = syncMetadataRepository.getMetadata(provider.id) ?: metadata
+ syncMetadataRepository.updateMetadata(current.copy(
+ lastEpgSync = now, lastEpgSuccess = now, epgCount = programDao.countByProvider(provider.id)
+ ))
+ }
}
return ProviderGuideSyncResult(warnings, hasRetryableFailure)
}
diff --git a/data/src/main/java/com/streamvault/data/sync/ProviderSyncWorkScheduler.kt b/data/src/main/java/com/streamvault/data/sync/ProviderSyncWorkScheduler.kt
index 9ac005b7..c1ae84a5 100644
--- a/data/src/main/java/com/streamvault/data/sync/ProviderSyncWorkScheduler.kt
+++ b/data/src/main/java/com/streamvault/data/sync/ProviderSyncWorkScheduler.kt
@@ -93,9 +93,6 @@ class ProviderSyncWorkScheduler @Inject constructor(
val manager = androidx.work.WorkManager.getInstance(applicationContext)
val policy = AutomaticSyncExecution.policy.get() ?: com.streamvault.domain.sync.AutomaticSyncSettings()
val wasAutomatic = origins.getBoolean("stalker_$providerId", false)
- if (!origins.getBoolean("stalker_split_queue_$providerId", false) && wasAutomatic) {
- manager.cancelUniqueWork(providerWorkUniqueName(providerId))
- }
if (!automatic) manager.cancelUniqueWork(providerAutomaticIndexWorkUniqueName(providerId))
val replaceAutomatic = automatic && wasAutomatic && origins.getString("stalker_policy_$providerId", null) != policy.toString()
origins.edit {
diff --git a/data/src/main/java/com/streamvault/data/sync/ProviderWorkLockRegistry.kt b/data/src/main/java/com/streamvault/data/sync/ProviderWorkLockRegistry.kt
index 8bd80b47..fdbd1569 100644
--- a/data/src/main/java/com/streamvault/data/sync/ProviderWorkLockRegistry.kt
+++ b/data/src/main/java/com/streamvault/data/sync/ProviderWorkLockRegistry.kt
@@ -4,31 +4,42 @@ import com.streamvault.domain.util.KeyedMutexRegistry
import java.util.concurrent.atomic.AtomicInteger
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.NonCancellable
+import kotlinx.coroutines.withContext
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.
+ * Serializes catalog work per provider. Stalker guide work has its own lane so a long
+ * catalog import cannot prevent guide downloads. Both lanes participate in maintenance admission.
*/
@Singleton
class ProviderWorkLockRegistry @Inject constructor() {
private val admissionMutex = Mutex()
private val providerMutexes = KeyedMutexRegistry<Long>()
+ private val stalkerGuideMutexes = KeyedMutexRegistry<Long>()
private val admittedCount = AtomicInteger(0)
fun isAnyWorkActiveOrWaiting(): Boolean = admittedCount.get() > 0
- suspend fun <T> withProviderLock(providerId: Long, block: suspend () -> T): T {
+ suspend fun <T> withProviderLock(providerId: Long, block: suspend () -> T): T =
+ withAdmission(providerMutexes, providerId, block)
+
+ suspend fun <T> withStalkerGuideLock(providerId: Long, block: suspend () -> T): T =
+ withAdmission(stalkerGuideMutexes, providerId, block)
+
+ private suspend fun <T> withAdmission(
+ mutexes: KeyedMutexRegistry<Long>, providerId: Long, block: suspend () -> T
+ ): T {
require(providerId > 0L) { "Provider work requires a positive provider ID." }
admissionMutex.withLock {
admittedCount.incrementAndGet()
}
return try {
- providerMutexes.withLock(providerId, block)
+ mutexes.withLock(providerId, block)
} finally {
- admissionMutex.withLock {
- admittedCount.decrementAndGet()
+ withContext(NonCancellable) {
+ admissionMutex.withLock { admittedCount.decrementAndGet() }
}
}
}
@@ -46,6 +57,7 @@ class ProviderWorkLockRegistry @Inject constructor() {
suspend fun forgetProvider(providerId: Long) {
admissionMutex.withLock {
providerMutexes.forget(providerId)
+ stalkerGuideMutexes.forget(providerId)
}
}
}
diff --git a/data/src/main/java/com/streamvault/data/sync/ProviderWorkScheduling.kt b/data/src/main/java/com/streamvault/data/sync/ProviderWorkScheduling.kt
index 4f571801..c87db2a7 100644
--- a/data/src/main/java/com/streamvault/data/sync/ProviderWorkScheduling.kt
+++ b/data/src/main/java/com/streamvault/data/sync/ProviderWorkScheduling.kt
@@ -15,6 +15,12 @@ internal fun providerEpgWorkUniqueName(providerId: Long): String {
return PROVIDER_EPG_WORK_UNIQUE_PREFIX + providerId
}
+/** Catalog continuation must not inherit setup or guide failure/cancellation. */
+internal fun stalkerIndexWorkUniqueName(providerId: Long): String {
+ require(providerId > 0L) { "Provider work requires a positive provider ID." }
+ return "provider-stalker-index-$providerId"
+}
+
/** Automatic constraints must never become prerequisites of an explicit refresh. */
internal fun providerAutomaticIndexWorkUniqueName(providerId: Long): String {
require(providerId > 0L)
diff --git a/data/src/main/java/com/streamvault/data/sync/StalkerCatalogExecution.kt b/data/src/main/java/com/streamvault/data/sync/StalkerCatalogExecution.kt
new file mode 100644
index 00000000..791da405
--- /dev/null
+++ b/data/src/main/java/com/streamvault/data/sync/StalkerCatalogExecution.kt
@@ -0,0 +1,29 @@
+package com.streamvault.data.sync
+
+import com.streamvault.domain.model.ContentType
+import com.streamvault.domain.model.StalkerCatalogLoadOrder
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
+
+internal suspend fun <T : Any> executeStalkerCatalogSections(
+ sections: List<ContentType>,
+ order: StalkerCatalogLoadOrder,
+ headsOnly: Boolean,
+ isPending: suspend (ContentType) -> Boolean,
+ process: suspend (ContentType) -> T?
+): List<T> {
+ if (headsOnly || order == StalkerCatalogLoadOrder.PARALLEL) return coroutineScope {
+ sections.map { section -> async { process(section) } }.awaitAll().filterNotNull()
+ }
+ val ordered = if (order == StalkerCatalogLoadOrder.SERIES_FIRST) sections.sortedBy {
+ if (it == ContentType.SERIES) 0 else 1
+ } else sections.sortedBy { if (it == ContentType.MOVIE) 0 else 1 }
+ return buildList {
+ for (section in ordered) {
+ process(section)?.let(::add)
+ // Retry waits also keep the other section queued. Interactive browsing is independent.
+ if (isPending(section)) break
+ }
+ }
+}
diff --git a/data/src/main/java/com/streamvault/data/sync/StalkerCatalogSyncExecutor.kt b/data/src/main/java/com/streamvault/data/sync/StalkerCatalogSyncExecutor.kt
index 054dccc8..05ba2e88 100644
--- a/data/src/main/java/com/streamvault/data/sync/StalkerCatalogSyncExecutor.kt
+++ b/data/src/main/java/com/streamvault/data/sync/StalkerCatalogSyncExecutor.kt
@@ -91,7 +91,8 @@ internal class StalkerCatalogSyncExecutor(
private val emitCatalogProgress: (Long, Section, Int?, Int?) -> Unit,
private val categoryFailureWarning: (String, String, Throwable) -> String,
private val sanitizeThrowableMessage: (Throwable?) -> String,
- private val requiredHiddenCategoryIds: suspend (Long, ContentType) -> Set<Long> = { _, _ -> emptySet() }
+ private val requiredHiddenCategoryIds: suspend (Long, ContentType) -> Set<Long> = { _, _ -> emptySet() },
+ private val prepareVodCatalog: suspend (Provider, Boolean, List<ContentType>, ((String) -> Unit)?) -> Unit = { _, _, _, _ -> }
) {
suspend fun syncFull(
provider: Provider,
@@ -249,9 +250,7 @@ internal class StalkerCatalogSyncExecutor(
if (storedCategoryType == ContentType.VOD) ContentType.MOVIE.name else ContentType.VOD.name
)
movieCategoryCount = categories.size
- if (provider.stalkerCatalogMode == StalkerCatalogMode.BACKGROUND_INDEX) {
- sectionExecutor.queueIndexSection(provider.id, ContentType.MOVIE, categories.size, now)
- }
+ sectionExecutor.queueIndexSection(provider.id, ContentType.MOVIE, categories.size, now)
metadata = metadata.copy(
lastMovieSync = now,
lastMovieAttempt = now,
@@ -261,7 +260,7 @@ internal class StalkerCatalogSyncExecutor(
movieCatalogStale = true
)
syncMetadataRepository.updateMetadata(metadata)
- queuedMovieIndex = provider.stalkerCatalogMode == StalkerCatalogMode.BACKGROUND_INDEX
+ queuedMovieIndex = true
}
if (effectiveCatalogLayout == CatalogLayout.UNIFIED_VOD) {
@@ -300,15 +299,13 @@ internal class StalkerCatalogSyncExecutor(
)
catalogActivated = true
seriesCategoryCount = categories.size
- if (provider.stalkerCatalogMode == StalkerCatalogMode.BACKGROUND_INDEX) {
- sectionExecutor.queueIndexSection(provider.id, ContentType.SERIES, categories.size, now)
- }
+ 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
+ queuedSeriesIndex = true
}
if (liveCount == 0 && movieCategoryCount == 0 && seriesCategoryCount == 0) {
@@ -318,6 +315,14 @@ internal class StalkerCatalogSyncExecutor(
}
readinessTracker.categoriesReady(provider.id)
+ val preparedSections = buildList {
+ if (queuedMovieIndex) add(ContentType.MOVIE)
+ if (queuedSeriesIndex) add(ContentType.SERIES)
+ }
+ if (preparedSections.isNotEmpty()) {
+ prepareVodCatalog(provider.copy(catalogLayout = effectiveCatalogLayout), bootstrap, preparedSections, onProgress)
+ }
+
if (!bootstrap && queuedMovieIndex) {
continuationWork += SyncContinuation(
operation = SyncContinuationOperation.INDEX_CATALOG,
@@ -340,13 +345,7 @@ internal class StalkerCatalogSyncExecutor(
reason = "full live catalog and VOD category shells are committed; fetch every VOD category head"
)
} else when (provider.epgSyncMode) {
- ProviderEpgSyncMode.UPFRONT -> warnings += syncProviderEpg(
- provider,
- metadata,
- now,
- force,
- onProgress
- ).warnings
+ ProviderEpgSyncMode.UPFRONT,
ProviderEpgSyncMode.BACKGROUND -> {
continuationWork += SyncContinuation(
operation = SyncContinuationOperation.REFRESH_GUIDE,
diff --git a/data/src/main/java/com/streamvault/data/sync/StalkerIncrementalIndexExecutor.kt b/data/src/main/java/com/streamvault/data/sync/StalkerIncrementalIndexExecutor.kt
index 2898daae..e05f6857 100644
--- a/data/src/main/java/com/streamvault/data/sync/StalkerIncrementalIndexExecutor.kt
+++ b/data/src/main/java/com/streamvault/data/sync/StalkerIncrementalIndexExecutor.kt
@@ -5,8 +5,6 @@ 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
@@ -15,17 +13,6 @@ 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 = 8
-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
@@ -139,6 +126,9 @@ internal interface StalkerIncrementalIndexOperations {
indexedAt: Long
)
+ suspend fun commitCatalogPage(provider: Provider, categoryId: Long, page: StalkerPagedResult<out Any>) {}
+ suspend fun preserveCategoryRows(providerId: Long, type: ContentType, categoryId: Long) {}
+
suspend fun recordRequestFailure(providerId: Long, error: Throwable?)
fun failureState(error: Throwable): String
@@ -152,972 +142,22 @@ internal interface StalkerIncrementalIndexOperations {
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.
- */
+/** Durable category paging used by setup, refresh, and background continuation. */
internal class StalkerIncrementalIndexExecutor(
- private val operations: StalkerIncrementalIndexOperations,
- configuredWildcardPageConcurrency: Int = if (BuildConfig.STALKER_ADAPTIVE_INDEXING) {
- BuildConfig.STALKER_INDEX_PAGE_CONCURRENCY
- } else {
- 1
- },
- private val adaptiveCategoryPaging: Boolean = BuildConfig.STALKER_ADAPTIVE_INDEXING
+ operations: StalkerIncrementalIndexOperations,
+ configuredWildcardPageConcurrency: Int = BuildConfig.STALKER_INDEX_PAGE_CONCURRENCY
) {
- private val wildcardPageConcurrency = configuredWildcardPageConcurrency.coerceIn(1, 8)
-
- /** Warm page one for every visible category before starting the full catalog walk. */
- suspend fun processCategoryHeads(
- provider: Provider,
- api: StalkerProvider,
- contentType: ContentType,
- onProgress: ((String) -> Unit)?
- ) {
- require(contentType == ContentType.MOVIE || contentType == ContentType.SERIES) {
- "Unsupported Stalker category-head section: $contentType"
- }
- val allCategories = operations.allVisibleCategories(provider.id, contentType)
- val visibleCategories = operations.visibleCategories(contentType, allCategories, api)
- if (visibleCategories.isNotEmpty() && visibleCategories.all { category ->
- (operations.getHydration(provider.id, contentType, category.categoryId)?.lastSuccessfulPage ?: 0) >= 1
- }) return
- val headCategoryCount = visibleCategories.size.coerceAtLeast(1)
- processSummary(
- provider = provider,
- api = api,
- contentType = contentType,
- maxCategories = headCategoryCount,
- onProgress = onProgress,
- maxPages = headCategoryCount,
- bypassWildcardProbe = true,
- maxParallelFetches = if (adaptiveCategoryPaging) headCategoryCount else 2,
- categoryHeadsOnly = true
- )
- }
-
- suspend fun processSummary(
- provider: Provider,
- api: StalkerProvider,
- contentType: ContentType,
- maxCategories: Int,
- onProgress: ((String) -> Unit)?,
- maxPages: Int? = null,
- bypassWildcardProbe: Boolean = false,
- maxParallelFetches: Int? = null,
- categoryHeadsOnly: Boolean = false
- ) {
- 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(category.type, 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
- }
+ private val importer = StalkerPagedCatalogImporter(operations, configuredWildcardPageConcurrency)
- 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
- }
- }
- var categoryPlan = visibleCategories
- val explicitCategoryPaging = adaptiveCategoryPaging && visibleCategories.any {
- !api.isWildcardCategory(it.type, it.categoryId)
- }
- val wildcardCheckpoint = wildcardCategory?.let {
- operations.getHydration(provider.id, contentType, it.categoryId)
- }
- val wildcardProbePending = !explicitCategoryPaging || wildcardCheckpoint?.isComplete == true ||
- (wildcardCheckpoint?.lastSuccessfulPage ?: 0) == 0
- if ((!bypassWildcardProbe || explicitCategoryPaging) && wildcardProbePending &&
- wildcardCategory != null && learnedWildcardSupport != false) {
- val wildcardIsSoleCategory = visibleCategories.size == 1 &&
- visibleCategories.first().categoryId == wildcardCategory.categoryId
- StalkerTelemetry.strategySelected(
- provider.id,
- "${contentType.name}_WILDCARD",
- when {
- learnedWildcardSupport == true -> "VALIDATED_CACHE"
- wildcardIsSoleCategory -> "CAPABILITY_PROBE"
- else -> "EXPLICIT_CATEGORY_PROBE"
- }
- )
- val outcome = processWildcard(
- provider = provider,
- api = api,
- contentType = contentType,
- wildcardCategory = wildcardCategory,
- visibleCategories = allVisibleCategories,
- maxPages = if (explicitCategoryPaging) 1 else
- maxPages?.coerceAtLeast(1) ?: STALKER_INCREMENTAL_WILDCARD_PAGE_SLICE_SIZE,
- initialJob = initialJob,
- onProgress = onProgress,
- wholeResponseProbe = explicitCategoryPaging
- )
- outcome.capabilitySupported?.let { supported ->
- api.recordWildcardCapability(contentType, supported)
- }
- if (!outcome.shouldFallback) {
- if (!outcome.complete && !explicitCategoryPaging) return
- if (outcome.complete) {
- val backfill = wildcardBackfillCategories(
- provider = provider,
- api = api,
- contentType = contentType,
- visibleCategories = visibleCategories
- )
- if (backfill.isEmpty()) {
- if (!wildcardIsSoleCategory) {
- operations.pruneStaleRows(provider.id, contentType)
- }
- return
- }
- operations.log(
- "Stalker ${contentType.name} wildcard index complete for provider ${provider.id}; " +
- "backfilling ${backfill.size} categories without wildcard rows."
- )
- categoryPlan = backfill
- }
- }
- } else if (wildcardCategory != null && learnedWildcardSupport == false) {
- StalkerTelemetry.strategySelected(provider.id, "${contentType.name}_CATEGORY", "WILDCARD_KNOWN_UNSUPPORTED")
- }
+ suspend fun prepareCatalog(provider: Provider, api: StalkerProvider, contentType: ContentType,
+ freshSource: Boolean, onProgress: ((String) -> Unit)?) =
+ importer.prepare(provider, api, contentType, freshSource, onProgress)
- val hydrationByCategory = categoryPlan.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 = categoryPlan.size,
- completedCategories = completedBefore,
- failedCategories = failedBefore,
- indexedRows = indexedBefore,
- lastAttemptAt = now,
- lastError = null
- )
-
- var restoreMovieWatchProgressPending = false
- try {
- val pending = buildList {
- categoryPlan.forEach { category ->
- if (size >= maxCategories) return@forEach
- val hydration = hydrationByCategory[category.categoryId]
- if (categoryHeadsOnly && (hydration?.lastSuccessfulPage ?: 0) >= 1) return@forEach
- 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 = if (categoryHeadsOnly && adaptiveCategoryPaging) {
- (maxParallelFetches ?: 8).coerceIn(1, 8)
- } else if (adaptiveCategoryPaging) wildcardPageConcurrency else
- categoryFetchConcurrencyLimit(provider, maxCategories, maxParallelFetches)
- 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 &&
- (maxPages == null || pagesCommitted < maxPages.coerceAtLeast(1))
- ) {
- if (pagesCommitted > 0) {
- delay(StalkerTrafficCoordinator.backgroundInterPageDelayMillis(provider.id))
- }
- val windowSize = minOf(
- if (forceSequential) 1 else parallelFetchLimit,
- if (adaptiveCategoryPaging && !categoryHeadsOnly) Int.MAX_VALUE else pendingQueue.size,
- maxPages?.let { (it - pagesCommitted).coerceAtLeast(1) } ?: Int.MAX_VALUE
- )
- val window = buildList {
- repeat(minOf(windowSize, pendingQueue.size)) { 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)
- }.let { firsts ->
- if (!adaptiveCategoryPaging || categoryHeadsOnly || firsts.isEmpty()) firsts else buildList {
- addAll(firsts)
- // Known totals let even a single large category fill the shared page pool.
- for (first in firsts) {
- val lastPage = first.hydration?.advertisedTotalPages
- ?: first.hydration?.totalPages ?: first.nextPage
- for (page in first.nextPage + 1..lastPage.coerceAtMost(first.nextPage + windowSize - 1)) {
- if (size >= windowSize) break
- add(first.copy(nextPage = page))
- }
- }
- }.sortedWith(compareBy({ it.category.categoryId }, { it.nextPage }))
- }
- if (attempts.isEmpty()) continue
- val fetchedResults = coroutineScope {
- attempts.map { attempt ->
- async {
- val result = operations.fetchSummaryPage(
- provider = provider,
- api = api,
- contentType = contentType,
- categoryId = attempt.category.categoryId,
- page = attempt.nextPage
- )
- if (result is Result.Error) operations.recordRequestFailure(provider.id, result.exception)
- CategoryFetchResult(
- attempt = attempt,
- result = result
- )
- }
- }.awaitAll()
- }
-
- var windowRetryableFailures = 0
- val successfulPages = mutableListOf<SuccessfulPage>()
- val validationHydration = mutableMapOf<Long, StalkerHydrationSnapshot?>()
- val blockedCategories = mutableSetOf<Long>()
- val failedAttempts = mutableListOf<suspend () -> Unit>()
- for (fetched in fetchedResults) {
- val category = fetched.attempt.category
- if (category.categoryId in blockedCategories) continue
- val hydration = validationHydration[category.categoryId] ?: fetched.attempt.hydration
- val nextPage = fetched.attempt.nextPage
- 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)
- blockedCategories += category.categoryId
- failedAttempts += suspend { 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
- }
- if (nextPage == 1) api.recordVodPageSize(contentType, result.data.pageSize)
- 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
- )
- if (hydration != null) validationHydration[category.categoryId] = hydration.copy(
- lastSuccessfulPage = nextPage,
- lastLoadedPage = nextPage,
- itemCount = hydration.itemCount + dedupedItems.size,
- lastPageFingerprint = pageFingerprint,
- advertisedTotalItems = result.data.advertisedTotalItems,
- advertisedTotalPages = result.data.advertisedTotalPages
- )
- if (result.data.isComplete || result.data.isTruncated) blockedCategories += category.categoryId
- }
- 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)
- blockedCategories += category.categoryId
- failedAttempts += suspend { 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)
- }
- 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
- )
- }
- val visibleRowCount = operations.currentIndexedRowCount(provider.id, contentType)
- operations.updateSummaryMetadata(provider.id, contentType, visibleRowCount, "RUNNING", indexedAt)
- upsertIndexJob(
- providerId = provider.id,
- section = contentType.name,
- state = "RUNNING",
- now = indexedAt,
- indexedRows = visibleRowCount,
- lastAttemptAt = indexedAt
- )
- }
- failedAttempts.forEach { it() }
- if (!categoryHeadsOnly) {
- successfulPages.map { it.category }.distinctBy { it.categoryId }.forEach { category ->
- if (category.categoryId !in blockedCategories &&
- pendingQueue.none { it.categoryId == category.categoryId } &&
- canAttempt(operations.getHydration(provider.id, contentType, category.categoryId), System.currentTimeMillis())) {
- pendingQueue.addLast(category)
- }
- }
- }
- if (!adaptiveCategoryPaging && !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 = categoryPlan.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 = categoryPlan.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 data class WildcardRunOutcome(
- val shouldFallback: Boolean = false,
- val complete: Boolean = false,
- val capabilitySupported: Boolean? = null
- )
-
- private suspend fun processWildcard(
- provider: Provider,
- api: StalkerProvider,
- contentType: ContentType,
- wildcardCategory: CategoryEntity,
- visibleCategories: List<CategoryEntity>,
- maxPages: Int,
- initialJob: StalkerIndexJobEntity?,
- onProgress: ((String) -> Unit)?,
- wholeResponseProbe: Boolean = false
- ): WildcardRunOutcome {
- val now = System.currentTimeMillis()
- val normalVisibleCategoryIds = mutableSetOf<Long>()
- visibleCategories.forEach { category ->
- if (!api.isWildcardCategory(category.type, category.categoryId)) {
- normalVisibleCategoryIds += category.categoryId
- }
- }
- val visibleCategoryIds = normalVisibleCategoryIds.takeIf { it.isNotEmpty() }
- val hydration = operations.getHydration(provider.id, contentType, wildcardCategory.categoryId)
- if (hydration?.isComplete == true) {
- return WildcardRunOutcome(complete = true, capabilitySupported = true)
- }
- if (hydration?.isTerminalFailure == true) {
- return WildcardRunOutcome(shouldFallback = true, capabilitySupported = false)
- }
- if (hydration?.isTruncated == true) {
- return WildcardRunOutcome(shouldFallback = true, capabilitySupported = true)
- }
- if (!canAttempt(hydration, now)) return WildcardRunOutcome()
-
- 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()
- var capabilityProven = (hydration?.lastSuccessfulPage ?: 0) > 0
-
- 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)
- val remainingPages = currentHydration?.advertisedTotalPages
- ?: currentHydration?.totalPages?.takeIf { it > 0 }
- val windowSize = minOf(
- wildcardPageConcurrency,
- maxPages - pagesProcessed,
- STALKER_INCREMENTAL_MAX_PARALLEL_CATEGORY_FETCHES,
- if (adaptiveCategoryPaging) remainingPages?.let { (it - nextPage + 1).coerceAtLeast(1) } ?: 1
- else STALKER_INCREMENTAL_MAX_PARALLEL_CATEGORY_FETCHES
- ).coerceAtLeast(1)
- val requestedPages = (nextPage until nextPage + windowSize).toList()
- requestedPages.forEach { page ->
- operations.progress(
- provider.id,
- onProgress,
- "Indexing ${indexSectionLabel(contentType)}: All page $page"
- )
- }
- val fetchedPages = coroutineScope {
- requestedPages.map { page ->
- async {
- val result = operations.fetchWildcardPage(
- provider = provider,
- api = api,
- contentType = contentType,
- categoryId = wildcardCategory.categoryId,
- page = page
- )
- if (result is Result.Error) {
- // Apply a 429 cooldown as soon as any concurrent request reports it,
- // rather than waiting for slower siblings in this window to finish.
- operations.recordRequestFailure(provider.id, result.exception)
- }
- page to result
- }
- }.awaitAll()
- }.sortedBy { (page, _) -> page }
-
- var stopAfterWindow = false
- for ((requestedPage, coordinatedResult) in fetchedPages) {
- val checkpoint = operations.getHydration(provider.id, contentType, wildcardCategory.categoryId)
- if (!canAttempt(checkpoint, System.currentTimeMillis())) {
- stopAfterWindow = true
- break
- }
- if (nextAttemptPage(checkpoint) != requestedPage) {
- operations.log(
- "Discarding uncommitted Stalker wildcard page $requestedPage for provider ${provider.id}; " +
- "the durable checkpoint now expects page ${nextAttemptPage(checkpoint)}."
- )
- stopAfterWindow = true
- break
- }
- operations.markAttemptStarted(
- providerId = provider.id,
- contentType = contentType,
- categoryId = wildcardCategory.categoryId,
- hydration = checkpoint,
- attemptedPage = requestedPage,
- now = System.currentTimeMillis()
- )
- 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 (requestedPage == 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 = checkpoint,
- attemptedPage = requestedPage,
- now = indexedAt,
- message = message,
- retryable = false,
- pageFingerprint = null
- )
- operations.log("$message Falling back to per-category indexing for provider ${provider.id}.")
- return WildcardRunOutcome(shouldFallback = true, capabilitySupported = false)
- }
-
- val pageFingerprint = StalkerIndexPolicy.pageFingerprint(visibleItems, contentType)
- val anomaly = StalkerIndexPolicy.detectPageAnomaly(
- hydration = checkpoint,
- requestedPage = requestedPage,
- 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 = checkpoint,
- attemptedPage = requestedPage,
- now = indexedAt,
- message = anomaly,
- retryable = false,
- pageFingerprint = pageFingerprint
- )
- operations.log("Stalker wildcard ${contentType.name} indexing disabled for provider ${provider.id}: $anomaly")
- return WildcardRunOutcome(shouldFallback = true, capabilitySupported = false)
- }
-
- if (requestedPage == 1) api.recordVodPageSize(contentType, result.data.pageSize)
- 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 completeResponse = !wholeResponseProbe ||
- (result.data.advertisedTotalItems?.let { it > 0 && result.data.items.size >= it } == true)
- val pageComplete = completeResponse && !result.data.isTruncated && (
- result.data.isComplete ||
- (result.data.items.isEmpty() && result.data.totalPages in 1..requestedPage)
- )
- operations.markAttemptSucceeded(
- providerId = provider.id,
- contentType = contentType,
- categoryId = wildcardCategory.categoryId,
- hydration = checkpoint,
- attemptedPage = requestedPage,
- 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
- )
- capabilityProven = true
- pagesProcessed += 1
- if (pageComplete || result.data.isTruncated) {
- stopAfterWindow = true
- 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 = checkpoint,
- attemptedPage = requestedPage,
- now = failedAt,
- message = result.message,
- retryable = retryable,
- pageFingerprint = checkpoint?.lastPageFingerprint
- )
- if (!retryable) {
- return WildcardRunOutcome(shouldFallback = true, capabilitySupported = false)
- }
- stopAfterWindow = true
- break
- }
- is Result.Loading -> {
- stopAfterWindow = true
- break
- }
- }
- }
- if (stopAfterWindow) break
- }
-
- 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" && normalVisibleCategoryIds.isEmpty()) {
- 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 WildcardRunOutcome(
- complete = finalState == "SUCCESS",
- capabilitySupported = capabilityProven
- )
- } finally {
- if (contentType == ContentType.MOVIE && restoreMovieWatchProgressPending) {
- operations.restoreMovieWatchProgress(provider.id)
- }
- }
- }
-
- private suspend fun wildcardBackfillCategories(
- provider: Provider,
- api: StalkerProvider,
- contentType: ContentType,
- visibleCategories: List<CategoryEntity>
- ): List<CategoryEntity> {
- val normalCategories = visibleCategories.filterNot { category ->
- api.isWildcardCategory(category.type, category.categoryId)
- }
- if (normalCategories.isEmpty()) return emptyList()
- val localRows = operations.categoriesWithLocalRows(provider.id, contentType)
- val advertisedTotals = normalCategories.mapNotNull { category ->
- operations.getHydration(provider.id, contentType, category.categoryId)
- ?.advertisedTotalItems
- ?.let { total -> category.categoryId to total }
- }.toMap()
- return StalkerIndexPolicy.wildcardBackfillCategories(
- normalCategories = normalCategories,
- localRowCounts = localRows,
- advertisedTotals = advertisedTotals
- )
- }
-
- 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,
- requestedLimit: Int? = null
- ): Int =
- minOf(
- maxCategories.coerceAtLeast(1),
- (requestedLimit ?: operations.runtimeProfile.maxCategoryConcurrency).coerceAtLeast(1),
- 2
- ).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
- )
- )
- }
+ suspend fun processCategoryHeads(provider: Provider, api: StalkerProvider, contentType: ContentType,
+ onProgress: ((String) -> Unit)?) =
+ importer.run(provider, api, contentType, headsOnly = true, onProgress = onProgress)
- private fun indexSectionLabel(contentType: ContentType): String = when (contentType) {
- ContentType.MOVIE -> "movies"
- ContentType.SERIES -> "series"
- else -> contentType.name.lowercase()
- }
+ suspend fun processSummary(provider: Provider, api: StalkerProvider, contentType: ContentType,
+ maxCategories: Int, onProgress: ((String) -> Unit)?, maxPages: Int? = null) =
+ importer.run(provider, api, contentType, maxPages = maxPages, onProgress = onProgress)
}
diff --git a/data/src/main/java/com/streamvault/data/sync/StalkerIncrementalIndexOperationsAdapter.kt b/data/src/main/java/com/streamvault/data/sync/StalkerIncrementalIndexOperationsAdapter.kt
index a9fe174e..14d6dd32 100644
--- a/data/src/main/java/com/streamvault/data/sync/StalkerIncrementalIndexOperationsAdapter.kt
+++ b/data/src/main/java/com/streamvault/data/sync/StalkerIncrementalIndexOperationsAdapter.kt
@@ -59,12 +59,18 @@ internal data class StalkerIncrementalIndexCallbacks(
val progress: (Long, ((String) -> Unit)?, String) -> Unit,
val restoreMovieWatchProgress: suspend (Long) -> Unit,
val upsertJob: suspend (CatalogIndexJobUpdate) -> Unit,
- val log: (String) -> Unit
+ val log: (String) -> Unit,
+ val commitCatalogPage: suspend (Provider, Long, StalkerPagedResult<out Any>) -> Unit = { _, _, _ -> },
+ val preserveCategoryRows: suspend (Long, ContentType, Long) -> Unit = { _, _, _ -> }
)
internal class CallbackStalkerIncrementalIndexOperations(
private val callbacks: StalkerIncrementalIndexCallbacks
) : StalkerIncrementalIndexOperations {
+ override suspend fun commitCatalogPage(provider: Provider, categoryId: Long, page: StalkerPagedResult<out Any>) =
+ callbacks.commitCatalogPage(provider, categoryId, page)
+ override suspend fun preserveCategoryRows(providerId: Long, type: ContentType, categoryId: Long) =
+ callbacks.preserveCategoryRows(providerId, type, categoryId)
override val runtimeProfile: CatalogSyncRuntimeProfile
get() = callbacks.runtimeProfile()
diff --git a/data/src/main/java/com/streamvault/data/sync/StalkerIndexCheckpointStore.kt b/data/src/main/java/com/streamvault/data/sync/StalkerIndexCheckpointStore.kt
index 6bad4717..c1f975e0 100644
--- a/data/src/main/java/com/streamvault/data/sync/StalkerIndexCheckpointStore.kt
+++ b/data/src/main/java/com/streamvault/data/sync/StalkerIndexCheckpointStore.kt
@@ -259,7 +259,7 @@ internal class StalkerIndexCheckpointStore(
}
}
- private companion object {
+ 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.kt
index 0ac7346b..dc11137b 100644
--- a/data/src/main/java/com/streamvault/data/sync/StalkerIndexContinuationCoordinator.kt
+++ b/data/src/main/java/com/streamvault/data/sync/StalkerIndexContinuationCoordinator.kt
@@ -8,6 +8,7 @@ import com.streamvault.domain.model.ProviderEpgSyncMode
import com.streamvault.domain.model.ProviderType
import com.streamvault.domain.model.StalkerCatalogMode
import com.streamvault.domain.model.StalkerIndexState
+import com.streamvault.data.remote.stalker.StalkerAdvancedOptionsCodec
/**
* Owns durable Stalker index continuation decisions around the section executor.
@@ -32,7 +33,9 @@ internal class StalkerIndexContinuationCoordinator(
private val cancelIndex: (Long) -> Unit,
private val scheduleIndex: (Long, Long, Boolean) -> Unit,
private val scheduleBackgroundEpg: (Long) -> Unit,
- private val log: (String) -> Unit = {}
+ private val log: (String) -> Unit = {},
+ private val guideRowCount: suspend (Long) -> Int = { 1 },
+ private val recoverBackgroundEpg: (Long) -> Unit = scheduleBackgroundEpg
) {
suspend fun chooseNextSection(
provider: Provider,
@@ -55,14 +58,19 @@ internal class StalkerIndexContinuationCoordinator(
} else {
sectionState(provider, api, ContentType.SERIES, force, now)
}
+ val order = StalkerAdvancedOptionsCodec.decode(provider.stalkerAdvancedOptionsJson).catalogLoadOrder
return StalkerIndexPolicy.chooseNextSection(
layout = provider.catalogLayout,
requestedSection = requestedSection,
movie = movie,
- series = series
+ series = series,
+ order = order
)
}
+ suspend fun isSectionPending(provider: Provider, api: StalkerProvider, type: ContentType): Boolean =
+ sectionState(provider, api, type, false, System.currentTimeMillis()).pending
+
suspend fun scheduleNextSection(provider: Provider, api: StalkerProvider) {
val decision = chooseNextSection(
provider = provider,
@@ -117,6 +125,10 @@ internal class StalkerIndexContinuationCoordinator(
} else if (provider.stalkerCatalogMode == StalkerCatalogMode.BACKGROUND_INDEX || hasPendingOneTime) {
scheduleIndex(provider.id, 0L, false)
}
+ if (hasPendingOneTime && provider.epgSyncMode != ProviderEpgSyncMode.SKIP && guideRowCount(provider.id) == 0) {
+ // Replace retries backed off by the old shared catalog lease on upgrade/startup.
+ recoverBackgroundEpg(provider.id)
+ }
}
}
@@ -167,7 +179,7 @@ internal class StalkerIndexContinuationCoordinator(
val retryDelaySeconds = StalkerIndexPolicy.nextRetryDelaySeconds(hydrations, now)
val hasUnresolvedWork = hydrations.any { hydration ->
hydration == null ||
- (!hydration.isComplete && !hydration.isTerminalFailure && hydration.retryBudgetRemaining > 0)
+ (!hydration.isComplete && !hydration.isTruncated && !hydration.isTerminalFailure && hydration.retryBudgetRemaining > 0)
}
val needsStateReconciliation = job?.state in setOf(
StalkerIndexState.QUEUED,
diff --git a/data/src/main/java/com/streamvault/data/sync/StalkerIndexPolicy.kt b/data/src/main/java/com/streamvault/data/sync/StalkerIndexPolicy.kt
index 476526de..0a42bb70 100644
--- a/data/src/main/java/com/streamvault/data/sync/StalkerIndexPolicy.kt
+++ b/data/src/main/java/com/streamvault/data/sync/StalkerIndexPolicy.kt
@@ -5,6 +5,7 @@ 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.StalkerCatalogLoadOrder
import com.streamvault.domain.model.Movie
import com.streamvault.domain.model.Series
import com.streamvault.domain.model.VodCatalogItem
@@ -63,8 +64,17 @@ internal object StalkerIndexPolicy {
layout: CatalogLayout,
requestedSection: ContentType?,
movie: StalkerCatalogSectionState,
- series: StalkerCatalogSectionState
+ series: StalkerCatalogSectionState,
+ order: StalkerCatalogLoadOrder = StalkerCatalogLoadOrder.PARALLEL
): StalkerCatalogDecision {
+ if (requestedSection == null && layout != CatalogLayout.UNIFIED_VOD && order != StalkerCatalogLoadOrder.PARALLEL) {
+ val first = if (order == StalkerCatalogLoadOrder.MOVIES_FIRST) movie else series
+ if (first.pending) return StalkerCatalogDecision(
+ first.contentType.takeIf { first.runnable },
+ retryDelaySeconds = if (first.runnable) 0 else first.retryDelaySeconds.coerceAtLeast(10),
+ reason = "configured first section still has pending pages"
+ )
+ }
if (requestedSection == ContentType.MOVIE && movie.runnable) {
return StalkerCatalogDecision(
ContentType.MOVIE,
diff --git a/data/src/main/java/com/streamvault/data/sync/StalkerIndexWorker.kt b/data/src/main/java/com/streamvault/data/sync/StalkerIndexWorker.kt
index 674655f5..85665314 100644
--- a/data/src/main/java/com/streamvault/data/sync/StalkerIndexWorker.kt
+++ b/data/src/main/java/com/streamvault/data/sync/StalkerIndexWorker.kt
@@ -210,7 +210,7 @@ class StalkerIndexWorker(
.build()
WorkManager.getInstance(context).enqueueUniqueWork(
- if (automatic) providerAutomaticIndexWorkUniqueName(providerId) else providerWorkUniqueName(providerId),
+ if (automatic) providerAutomaticIndexWorkUniqueName(providerId) else stalkerIndexWorkUniqueName(providerId),
stalkerIndexExistingWorkPolicy(force || replaceAutomatic, appendSuccessor),
request
)
@@ -218,7 +218,7 @@ class StalkerIndexWorker(
fun cancel(context: Context, providerId: Long) {
if (providerId > 0L) {
- WorkManager.getInstance(context).cancelUniqueWork(providerWorkUniqueName(providerId))
+ WorkManager.getInstance(context).cancelUniqueWork(stalkerIndexWorkUniqueName(providerId))
WorkManager.getInstance(context).cancelUniqueWork(providerAutomaticIndexWorkUniqueName(providerId))
}
}
diff --git a/data/src/main/java/com/streamvault/data/sync/StalkerPagedCatalogImporter.kt b/data/src/main/java/com/streamvault/data/sync/StalkerPagedCatalogImporter.kt
new file mode 100644
index 00000000..b2c362a5
--- /dev/null
+++ b/data/src/main/java/com/streamvault/data/sync/StalkerPagedCatalogImporter.kt
@@ -0,0 +1,304 @@
+package com.streamvault.data.sync
+
+import com.streamvault.data.local.entity.CategoryEntity
+import com.streamvault.data.remote.stalker.StalkerPagedResult
+import com.streamvault.data.remote.stalker.StalkerProvider
+import com.streamvault.data.remote.stalker.StalkerVodCatalogItem
+import com.streamvault.data.remote.stalker.StalkerTrafficCoordinator
+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.CancellationException
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Semaphore
+import java.util.concurrent.ConcurrentHashMap
+
+internal object StalkerCatalogPriority {
+ private val categories = ConcurrentHashMap<Pair<Long, ContentType>, Long>()
+ fun select(providerId: Long, type: ContentType, categoryId: Long) { categories[providerId to type] = categoryId }
+ fun selected(providerId: Long, type: ContentType): Long? = categories[providerId to type]
+}
+
+/** A concurrent category-head sweep, followed by resumable ordered page windows per category. */
+internal class StalkerPagedCatalogImporter(
+ private val operations: StalkerIncrementalIndexOperations,
+ private val concurrency: Int = 8
+) {
+ private data class Task(val category: CategoryEntity, val page: Int)
+ private data class Reply(val task: Task, val result: Result<StalkerPagedResult<out Any>>)
+
+ suspend fun prepare(
+ provider: Provider,
+ api: StalkerProvider,
+ type: ContentType,
+ freshSource: Boolean,
+ onProgress: ((String) -> Unit)?
+ ) {
+ run(provider, api, type, headsOnly = true, onProgress = onProgress)
+ val categories = categories(provider, api, type)
+ val receipts = categories.mapNotNull { operations.getHydration(provider.id, type, it.categoryId) }
+ val deferredPages = receipts.sumOf { (it.totalPages - it.lastSuccessfulPage).coerceAtLeast(0) }
+ val pageSize = receipts.maxOfOrNull { it.pageSize } ?: 0
+ val defer = freshSource && pageSize in 1..50 && deferredPages >= 200
+ operations.log("Stalker ${type.name} catalog plan provider=${provider.id} categories=${categories.size} pageSize=$pageSize remainingPages=$deferredPages deferred=$defer")
+ if (!defer) run(provider, api, type, onProgress = onProgress)
+ }
+
+ private suspend fun categories(provider: Provider, api: StalkerProvider, type: ContentType): List<CategoryEntity> {
+ val all = operations.allVisibleCategories(provider.id, type)
+ val visible = operations.visibleCategories(type, all, api)
+ val concrete = visible.filterNot { api.isWildcardCategory(it.type, it.categoryId) }
+ return concrete.ifEmpty { visible }
+ }
+
+ suspend fun run(
+ provider: Provider, api: StalkerProvider, type: ContentType,
+ headsOnly: Boolean = false, maxPages: Int? = null,
+ onProgress: ((String) -> Unit)? = null
+ ) = Import(provider, api, type, headsOnly, maxPages).execute()
+
+ private inner class Import(
+ private val provider: Provider,
+ private val api: StalkerProvider,
+ private val type: ContentType,
+ private val headsOnly: Boolean,
+ private val maxPages: Int?
+ ) {
+ private val started = System.currentTimeMillis()
+ private lateinit var categories: List<CategoryEntity>
+ private val checkpoints = mutableMapOf<Long, StalkerHydrationSnapshot?>()
+ private val buffers = mutableMapOf<Long, java.util.TreeMap<Int, Reply>>()
+ private val blocked = mutableSetOf<Long>()
+ private var committed = 0
+ private var rows = 0
+ private var restoreProgress = false
+ private var nextPublication = 256
+ private var initialCounts: Map<Long, Int> = emptyMap()
+
+ private suspend fun accept(reply: Reply): Int {
+ val id = reply.task.category.categoryId
+ if (id in blocked) return 1
+ var consumed = 0
+ val buffer = buffers.getOrPut(id) { java.util.TreeMap() }
+ buffer[reply.task.page] = reply
+ while (true) {
+ val previous = checkpoints[id]
+ val next = ((previous?.lastSuccessfulPage ?: 0) + 1).coerceAtLeast(1)
+ val ready = buffer.remove(next) ?: break
+ consumed++
+ val result = ready.result
+ val now = System.currentTimeMillis()
+ val payload = (result as? Result.Success)?.data
+ val fingerprint = payload?.let { StalkerIndexPolicy.pageFingerprint(it.items, type) }
+ val anomaly = payload?.let { StalkerIndexPolicy.detectPageAnomaly(previous, next, it, fingerprint) }
+ if (payload == null || anomaly != null) {
+ val error = (result as? Result.Error)
+ operations.markAttemptFailed(provider.id, type, id, previous, next, now,
+ anomaly ?: error?.message ?: "Unexpected loading state",
+ error?.exception?.let { operations.failureState(it) != "FAILED_PERMANENT" } ?: true,
+ previous?.lastPageFingerprint)
+ blocked += id
+ consumed += buffer.size
+ buffer.clear()
+ checkpoints[id] = operations.getHydration(provider.id, type, id)
+ break
+ }
+ val items = StalkerIndexPolicy.dedupePageItems(payload.items, type)
+ store(provider.id, type, items, now)
+ operations.commitCatalogPage(provider, id, payload)
+ if (type == ContentType.MOVIE && items.isNotEmpty()) restoreProgress = true
+ val unchanged = provider.catalogLayout != com.streamvault.domain.model.CatalogLayout.UNIFIED_VOD &&
+ next == 1 && (initialCounts[id] ?: 0) > 0 && initialCounts[id] == payload.advertisedTotalItems
+ if (unchanged) operations.preserveCategoryRows(provider.id, type, id)
+ val complete = payload.isComplete || unchanged
+ val receiptPage = if (unchanged) payload.totalPages.coerceAtLeast(1) else next
+ val count = if (unchanged) initialCounts.getValue(id) else (previous?.itemCount ?: 0) + items.size
+ operations.markAttemptSucceeded(provider.id, type, id, previous, receiptPage, now, count,
+ payload.totalPages, payload.pageSize, payload.advertisedTotalItems, payload.advertisedTotalPages,
+ complete, payload.isTruncated, payload.terminationReason, fingerprint)
+ checkpoints[id] = StalkerHydrationSnapshot(now, count, if (payload.isTruncated) "TRUNCATED" else "SUCCESS",
+ payload.terminationReason, receiptPage, receiptPage, receiptPage, payload.totalPages, payload.advertisedTotalItems,
+ payload.advertisedTotalPages, complete, payload.pageSize, 0, 0, StalkerIndexCheckpointStore.STALKER_CATEGORY_RETRY_BUDGET, fingerprint)
+ committed++
+ rows += items.size
+ if (complete || payload.isTruncated) {
+ blocked += id
+ consumed += buffer.size
+ buffer.clear()
+ break
+ }
+ }
+ if (rows >= nextPublication) {
+ publish(provider.id, type, "RUNNING", categories, checkpoints, System.currentTimeMillis())
+ nextPublication = rows + 256
+ }
+ return consumed
+ }
+
+ private suspend fun fetch(task: Task): Reply {
+ var result: Result<StalkerPagedResult<out Any>> = Result.Loading
+ for (attempt in 0..2) {
+ result = try {
+ operations.fetchSummaryPage(provider, api, type, task.category.categoryId, task.page)
+ } catch (cancelled: CancellationException) { throw cancelled }
+ catch (error: Exception) { Result.error(error.message ?: error.javaClass.simpleName, error) }
+ val failure = result as? Result.Error ?: break
+ operations.recordRequestFailure(provider.id, failure.exception)
+ if (attempt == 2 || failure.exception?.let { operations.failureState(it) == "FAILED_PERMANENT" } == true) break
+ delay(750L * (attempt + 1))
+ }
+ return Reply(task, result)
+ }
+
+ private suspend fun drain(tasks: List<Task>) = coroutineScope {
+ if (tasks.isEmpty()) return@coroutineScope
+ val requests = Channel<Task>(concurrency.coerceIn(1, 8))
+ val replies = Channel<Reply>(concurrency.coerceIn(1, 8))
+ // A slow early page cannot make the reorder buffer grow with the entire catalog.
+ val credits = Semaphore(concurrency.coerceIn(1, 8) * 2)
+ launch {
+ val queue = ArrayDeque(tasks)
+ var previousPriority: Long? = null
+ try {
+ while (queue.isNotEmpty()) {
+ credits.acquire()
+ val priority = StalkerCatalogPriority.selected(provider.id, type)
+ if (priority != null && priority != previousPriority) {
+ val preferred = queue.filter { it.category.categoryId == priority }
+ queue.removeAll(preferred.toSet())
+ preferred.asReversed().forEach { queue.addFirst(it) }
+ previousPriority = priority
+ }
+ requests.send(queue.removeFirst())
+ }
+ } finally { requests.close() }
+ }
+ val workers = List(concurrency.coerceIn(1, 8)) {
+ launch { for (task in requests) replies.send(fetch(task)) }
+ }
+ launch { workers.forEach { it.join() }; replies.close() }
+ for (reply in replies) repeat(accept(reply)) { credits.release() }
+ }
+
+ private suspend fun drainBackfill() {
+ val queue = ArrayDeque(categories.filter { category ->
+ category.categoryId !in blocked &&
+ StalkerIndexPolicy.canAttempt(checkpoints[category.categoryId], System.currentTimeMillis())
+ })
+ while (queue.isNotEmpty()) {
+ val priority = StalkerCatalogPriority.selected(provider.id, type)
+ queue.firstOrNull { it.categoryId == priority }?.let { queue.remove(it); queue.addFirst(it) }
+ val category = queue.removeFirst()
+ while (category.categoryId !in blocked) {
+ if (StalkerTrafficCoordinator.shouldDeferIndexForPlayback(provider.id)) return
+ val h = checkpoints[category.categoryId] ?: break
+ if (h.isComplete || h.isTruncated || h.isTerminalFailure) break
+ val next = h.lastSuccessfulPage + 1
+ val last = h.totalPages.coerceAtLeast(next)
+ val remaining = maxPages?.minus(committed) ?: Int.MAX_VALUE
+ if (remaining <= 0) return
+ val size = minOf(concurrency.coerceIn(1, 8), remaining, last - next + 1)
+ val replies = coroutineScope {
+ (next until next + size).map { page -> async { fetch(Task(category, page)) } }.awaitAll()
+ }
+ // Commit only the contiguous prefix. A hole leaves the cursor at that page
+ // and the next pass retries it before any later page is made visible.
+ for (reply in replies) {
+ accept(reply)
+ if (category.categoryId in blocked) break
+ }
+ }
+ }
+ }
+
+ suspend fun execute() {
+ categories = categories(provider, api, type)
+ initialCounts = operations.categoriesWithLocalRows(provider.id, type)
+ for (category in categories) checkpoints[category.categoryId] = operations.getHydration(provider.id, type, category.categoryId)
+ publish(provider.id, type, "RUNNING", categories, checkpoints, started)
+ try {
+ // A paginated all-category response must never turn into a second full catalog walk.
+ val all = operations.allVisibleCategories(provider.id, type)
+ val wildcard = all.firstOrNull { api.isWildcardCategory(it.type, it.categoryId) }
+ if (wildcard != null && categories.none { it.categoryId == wildcard.categoryId } &&
+ checkpoints.values.all { (it?.lastSuccessfulPage ?: 0) == 0 } &&
+ operations.getHydration(provider.id, type, wildcard.categoryId) == null) {
+ val probe = operations.fetchWildcardPage(provider, api, type, wildcard.categoryId, 1)
+ val page = (probe as? Result.Success)?.data
+ val whole = page != null && !page.isTruncated && page.items.isNotEmpty() &&
+ page.advertisedTotalItems?.let { it > 0 && page.items.size >= it } == true
+ api.recordWildcardCapability(type, whole)
+ if (whole) {
+ val fullPage = requireNotNull(page)
+ val visible = StalkerIndexPolicy.filterToVisibleCategories(fullPage.items, type, categories.map { it.categoryId }.toSet())
+ val now = System.currentTimeMillis()
+ store(provider.id, type, visible, now)
+ restoreProgress = type == ContentType.MOVIE
+ for (category in categories) {
+ val categoryItems = StalkerIndexPolicy.filterToVisibleCategories(visible, type, setOf(category.categoryId))
+ operations.commitCatalogPage(provider, category.categoryId,
+ StalkerPagedResult(items = categoryItems, page = 1, totalPages = 1, pageSize = fullPage.pageSize,
+ advertisedTotalItems = categoryItems.size, advertisedTotalPages = 1))
+ operations.markAttemptSucceeded(provider.id, type, category.categoryId, null, 1, now, categoryItems.size,
+ 1, fullPage.pageSize, categoryItems.size, 1, true, false, null, null)
+ checkpoints[category.categoryId] = operations.getHydration(provider.id, type, category.categoryId)
+ }
+ operations.pruneStaleRows(provider.id, type)
+ publish(provider.id, type, "SUCCESS", categories, checkpoints, now)
+ return
+ }
+ operations.markAttemptSucceeded(provider.id, type, wildcard.categoryId, null, 1, System.currentTimeMillis(),
+ 0, page?.totalPages ?: 1, page?.pageSize ?: 0, page?.advertisedTotalItems,
+ page?.advertisedTotalPages, false, false, null, null)
+ }
+
+ val heads = categories.filter { (checkpoints[it.categoryId]?.lastSuccessfulPage ?: 0) == 0 &&
+ StalkerIndexPolicy.canAttempt(checkpoints[it.categoryId], System.currentTimeMillis()) }
+ drain(heads.map { Task(it, 1) })
+ publish(provider.id, type, "RUNNING", categories, checkpoints, System.currentTimeMillis())
+ if (!headsOnly) {
+ drainBackfill()
+ }
+ val pending = checkpoints.values.any { it == null || (!it.isComplete && !it.isTruncated && !it.isTerminalFailure) }
+ val partial = checkpoints.values.any { it?.hasPruneSuppressionRisk == true || it?.isTerminalFailure == true }
+ val state = when { pending -> "QUEUED"; partial -> "PARTIAL"; else -> "SUCCESS" }
+ if (state == "SUCCESS") operations.pruneStaleRows(provider.id, type)
+ publish(provider.id, type, state, categories, checkpoints, System.currentTimeMillis())
+ operations.log("Stalker ${type.name} catalog provider=${provider.id} state=$state pages=$committed rows=$rows elapsedMs=${System.currentTimeMillis() - started}")
+ } finally {
+ if (restoreProgress) operations.restoreMovieWatchProgress(provider.id)
+ }
+ }
+ }
+
+ private suspend fun store(providerId: Long, type: ContentType, items: List<Any>, now: Long) {
+ if (type == ContentType.SERIES) {
+ operations.upsertSeriesSummaryBatch(providerId, items.filterIsInstance<Series>(), now)
+ } else {
+ val classified = items.filterIsInstance<StalkerVodCatalogItem>()
+ operations.upsertMovieSummaryBatch(providerId, items.filterIsInstance<Movie>() +
+ classified.mapNotNull { (it.item as? VodCatalogItem.MovieItem)?.movie }, now)
+ operations.upsertVodDerivedSeriesSummaryBatch(providerId,
+ classified.mapNotNull { (it.item as? VodCatalogItem.SeriesItem)?.series }, now)
+ }
+ }
+
+ private suspend fun publish(
+ providerId: Long, type: ContentType, state: String, categories: List<CategoryEntity>,
+ checkpoints: Map<Long, StalkerHydrationSnapshot?>, now: Long
+ ) {
+ val count = operations.currentIndexedRowCount(providerId, type)
+ operations.upsertJob(CatalogIndexJobUpdate(providerId, type.name, state, now,
+ totalCategories = categories.size, completedCategories = checkpoints.values.count { it?.isComplete == true },
+ indexedRows = count, lastAttemptAt = now, lastSuccessAt = now.takeIf { state == "SUCCESS" }))
+ operations.updateSummaryMetadata(providerId, type, count, state, now)
+ }
+}
diff --git a/data/src/main/java/com/streamvault/data/sync/SyncManager.kt b/data/src/main/java/com/streamvault/data/sync/SyncManager.kt
index 4b61ce86..95211554 100644
--- a/data/src/main/java/com/streamvault/data/sync/SyncManager.kt
+++ b/data/src/main/java/com/streamvault/data/sync/SyncManager.kt
@@ -42,6 +42,7 @@ import com.streamvault.data.remote.stalker.StalkerApiService
import com.streamvault.data.remote.stalker.StalkerApiError
import com.streamvault.data.remote.stalker.StalkerPlaybackMode
import com.streamvault.data.remote.stalker.StalkerProvider
+import com.streamvault.data.remote.stalker.StalkerAdvancedOptionsCodec
import com.streamvault.data.remote.stalker.StalkerVodCatalogItem
import com.streamvault.data.remote.stalker.StalkerRemoteIdentityResolver
import com.streamvault.data.remote.stalker.StalkerRequestCoordinator
@@ -230,7 +231,8 @@ class SyncManager @Inject constructor(
private val syncProviderSnapshotAdapter = SyncProviderSnapshotAdapter(providerSnapshotRepository)
private val syncStatusPublicationCoordinator = SyncStatusPublicationCoordinator(
syncMetadataRepository = syncMetadataRepository,
- syncProgressBus = syncProgressBus
+ syncProgressBus = syncProgressBus,
+ transactionRunner = transactionRunner
)
private val syncErrorSanitizer = SyncErrorSanitizer()
private val xtreamAdaptiveSyncPolicy = XtreamAdaptiveSyncPolicy()
@@ -282,7 +284,9 @@ class SyncManager @Inject constructor(
)
},
scheduleBackgroundEpg = providerSyncWorkScheduler::scheduleBackgroundEpg,
- log = { message -> Log.i(TAG, message) }
+ log = { message -> Log.i(TAG, message) },
+ guideRowCount = programDao::countByProvider,
+ recoverBackgroundEpg = { providerSyncWorkScheduler.scheduleBackgroundEpg(it, force = true) }
)
}
private val stalkerIncrementalIndexExecutor by lazy {
@@ -303,9 +307,6 @@ class SyncManager @Inject constructor(
movieDao.getCategoryCounts(providerId).first().forEach { count ->
counts[count.categoryId] = (counts[count.categoryId] ?: 0) + count.item_count
}
- seriesDao.getCategoryCounts(providerId).first().forEach { count ->
- counts[count.categoryId] = (counts[count.categoryId] ?: 0) + count.item_count
- }
} else if (contentType == ContentType.SERIES) {
seriesDao.getCategoryCounts(providerId).first().forEach { count ->
counts[count.categoryId] = (counts[count.categoryId] ?: 0) + count.item_count
@@ -395,7 +396,13 @@ class SyncManager @Inject constructor(
catalogIndexJobStore.upsert(update)
}
},
- log = { message -> Log.i(TAG, message) }
+ log = { message -> Log.i(TAG, message) },
+ commitCatalogPage = ::commitStalkerCatalogPage,
+ preserveCategoryRows = { providerId, type, categoryId ->
+ inFencedStalkerIndexTransaction(providerId) {
+ xtreamContentIndexDao.markCategoryRowsFresh(providerId, type.name, categoryId)
+ }
+ }
)
)
)
@@ -704,6 +711,17 @@ class SyncManager @Inject constructor(
sanitizeThrowableMessage = ::sanitizeThrowableMessage,
requiredHiddenCategoryIds = { providerId, type ->
pendingBackupRestoreCoordinator?.requiredHiddenCategoryIds(providerId, type).orEmpty()
+ },
+ prepareVodCatalog = { provider, fresh, sections, onProgress ->
+ coroutineScope {
+ sections.map { type -> async {
+ withStalkerIndexSectionLock(provider.id, type) {
+ stalkerIncrementalIndexExecutor.prepareCatalog(
+ provider, createStalkerSyncProvider(provider), type, fresh, onProgress
+ )
+ }
+ } }.awaitAll()
+ }
}
)
}
@@ -894,11 +912,13 @@ class SyncManager @Inject constructor(
runCatching { providerSyncWorkScheduler.cancelStalkerIndex(providerId) }
.onFailure { error -> Log.w(TAG, "Failed to cancel Stalker index work: ${sanitizeThrowableMessage(error)}") }
withProviderLock(providerId) {
- resetState(providerId)
- stalkerReadinessTracker.clear(providerId)
- xtreamAdaptiveSyncPolicy.forgetProvider(providerId)
- syncCatalogStore.clearProviderStaging(providerId)
- epgRepository.onProviderDeleted(providerId)
+ providerWorkLocks.withStalkerGuideLock(providerId) {
+ resetState(providerId)
+ stalkerReadinessTracker.clear(providerId)
+ xtreamAdaptiveSyncPolicy.forgetProvider(providerId)
+ syncCatalogStore.clearProviderStaging(providerId)
+ epgRepository.onProviderDeleted(providerId)
+ }
}
providerSyncLocks.forgetProvider(providerId)
providerWorkLocks.forgetProvider(providerId)
@@ -1000,10 +1020,9 @@ class SyncManager @Inject constructor(
section: ContentType,
categoryId: Long
) {
- // Interactive repositories hydrate the requested category directly. Retained as a
- // source-compatible no-op while callers migrate to the request coordinator.
if (providerId <= 0L || categoryId == Long.MIN_VALUE) return
if (section != ContentType.MOVIE && section != ContentType.SERIES) return
+ StalkerCatalogPriority.select(providerId, section, categoryId)
}
override suspend fun syncEpg(
@@ -1014,10 +1033,15 @@ class SyncManager @Inject constructor(
val providerEntity = providerDao.getById(providerId)
?: return com.streamvault.domain.model.Result.error("Provider $providerId not found")
- return withProviderLock(providerId) {
+ val sync: suspend () -> Result<Unit> = {
val freshProviderEntity = providerDao.getById(providerId)
- ?: return@withProviderLock com.streamvault.domain.model.Result.error("Provider $providerId not found")
- syncEpgLocked(freshProviderEntity, force, onProgress)
+ if (freshProviderEntity == null) Result.error("Provider $providerId not found")
+ else syncEpgLocked(freshProviderEntity, force, onProgress)
+ }
+ return if (providerEntity.type == ProviderType.STALKER_PORTAL) {
+ providerWorkLocks.withStalkerGuideLock(providerId, sync)
+ } else {
+ withProviderLock(providerId, sync)
}
}
@@ -1273,7 +1297,7 @@ class SyncManager @Inject constructor(
scheduleStalkerIndexSync(providerId, section = null, force = false)
when (provider.epgSyncMode) {
- ProviderEpgSyncMode.UPFRONT -> return syncEpg(providerId = providerId, force = true, onProgress = null)
+ ProviderEpgSyncMode.UPFRONT,
ProviderEpgSyncMode.BACKGROUND -> scheduleBackgroundEpgSync(providerId)
ProviderEpgSyncMode.SKIP -> Unit
}
@@ -1789,14 +1813,15 @@ class SyncManager @Inject constructor(
scheduleContinuation: Boolean
): com.streamvault.domain.model.Result<Unit> {
return withStalkerSummaryLock(providerId, section) lock@{
- val playbackDelayMillis = if (StalkerTrafficCoordinator.shouldDeferIndexForPlayback(providerId)) 2_000L else 0L
+ val playbackDelayMillis = if (StalkerTrafficCoordinator.shouldDeferIndexForPlayback(providerId)) 15 * 60_000L else 0L
if (playbackDelayMillis > 0L) {
Log.i(TAG, "Deferring Stalker catalog work for provider $providerId because playback is active.")
scheduleStalkerIndexSync(
providerId = providerId,
section = null,
force = force,
- initialDelaySeconds = ((playbackDelayMillis + 999L) / 1000L).coerceAtLeast(1L)
+ initialDelaySeconds = ((playbackDelayMillis + 999L) / 1000L).coerceAtLeast(1L),
+ appendSuccessor = true
)
return@lock com.streamvault.domain.model.Result.success(Unit)
}
@@ -1814,96 +1839,70 @@ class SyncManager @Inject constructor(
when { it.movies && !it.series -> ContentType.MOVIE; it.series && !it.movies -> ContentType.SERIES; else -> null }
}
val api = createStalkerSyncProvider(provider)
- if (BuildConfig.STALKER_ADAPTIVE_INDEXING && !categoryHeadsOnly && automaticPolicy?.enabled != false) {
- val sections = listOf(ContentType.MOVIE, ContentType.SERIES).filter { type ->
+ val candidates = (effectiveSection?.let { listOf(it) }
+ ?: listOf(ContentType.MOVIE, ContentType.SERIES)).filter { type ->
(type != ContentType.SERIES || provider.catalogLayout != CatalogLayout.UNIFIED_VOD) &&
(automaticPolicy == null || if (type == ContentType.MOVIE) automaticPolicy.movies else automaticPolicy.series)
}
- // Recovery may run before the bootstrap continuation. Finish all missing heads
- // before any category starts its remaining-page crawl.
- warmStalkerCategoryHeads(provider, sections)
- }
- val decision = stalkerIndexContinuationCoordinator.chooseNextSection(
- provider = provider,
- api = api,
- requestedSection = effectiveSection,
- force = force,
- now = System.currentTimeMillis()
- )
- val contentType = decision.contentType
- if (contentType == null) {
- Log.i(TAG, "Stalker catalog worker skipped provider $providerId: ${decision.reason}")
- if (decision.retryDelaySeconds > 0L) {
- scheduleStalkerIndexSync(
- providerId = providerId,
- section = null,
- force = false,
- initialDelaySeconds = decision.retryDelaySeconds,
- appendSuccessor = true
- )
- } else {
- stalkerIndexContinuationCoordinator.scheduleEpgIfCatalogIdle(provider)
- }
- return@lock com.streamvault.domain.model.Result.success(Unit)
- }
- if (categoryHeadsOnly && section != null && contentType != section) {
- Log.i(TAG, "Stalker category-head warmup skipped ${contentType.name} for provider $providerId while ${section.name} was requested.")
- return@lock com.streamvault.domain.model.Result.success(Unit)
- }
- Log.i(TAG, "Stalker catalog worker selected ${contentType.name} for provider $providerId: ${decision.reason}")
-
- val warnings = mutableListOf<String>()
- val failures = mutableListOf<Throwable>()
- var sawRetryableFailure = false
- val categoryLimit = maxCategoriesPerSection?.coerceAtLeast(1) ?: STALKER_INDEX_CATEGORY_SLICE_SIZE
- val failure = runSuspendCatching {
- if (categoryHeadsOnly) {
- stalkerIncrementalIndexExecutor.processCategoryHeads(
- provider = provider,
- api = api,
- contentType = contentType,
- onProgress = onProgress
- )
- } else {
- stalkerIncrementalIndexExecutor.processSummary(
- provider = provider,
- api = api,
- contentType = contentType,
- maxCategories = categoryLimit,
- onProgress = onProgress,
- maxPages = maxPagesPerSection
- )
- }
- }.exceptionOrNull()
- if (failure != null) {
- val failedAt = System.currentTimeMillis()
- val state = StalkerIndexRecoveryPolicy.failureState(failure, ::sanitizeThrowableMessage)
- upsertXtreamIndexJob(
- providerId = providerId,
- section = contentType.name,
- state = state,
- now = failedAt,
- lastAttemptAt = failedAt,
- lastError = sanitizeThrowableMessage(failure)
+ suspend fun process(type: ContentType): Throwable? =
+ withStalkerIndexSectionLock(provider.id, type) {
+ val decision = stalkerIndexContinuationCoordinator.chooseNextSection(
+ provider, api, type, force, System.currentTimeMillis())
+ if (decision.contentType != type) return@withStalkerIndexSectionLock null
+ runSuspendCatching {
+ if (categoryHeadsOnly) stalkerIncrementalIndexExecutor.processCategoryHeads(provider, api, type, onProgress)
+ else stalkerIncrementalIndexExecutor.processSummary(provider, api, type, Int.MAX_VALUE,
+ onProgress, maxPages = maxPagesPerSection)
+ }.exceptionOrNull()
+ }
+ val failures = executeStalkerCatalogSections(
+ sections = candidates,
+ order = StalkerAdvancedOptionsCodec.decode(provider.stalkerAdvancedOptionsJson).catalogLoadOrder,
+ headsOnly = categoryHeadsOnly,
+ isPending = { stalkerIndexContinuationCoordinator.isSectionPending(provider, api, it) },
+ process = ::process
)
- failures += failure
- sawRetryableFailure = sawRetryableFailure || state != "FAILED_PERMANENT"
- warnings += "${contentType.name.lowercase().replaceFirstChar { it.titlecase() }} indexing failed: ${sanitizeThrowableMessage(failure)}"
- }
-
- val result = if (warnings.isNotEmpty()) {
- val message = warnings.joinToString("; ")
- val cause = failures.firstOrNull()
- val exception = if (sawRetryableFailure) IOException(message, cause) else IllegalStateException(message, cause)
- com.streamvault.domain.model.Result.error(warnings.first(), exception)
- } else {
if (scheduleContinuation) {
stalkerIndexContinuationCoordinator.scheduleNextSection(provider, api)
stalkerIndexContinuationCoordinator.scheduleEpgIfCatalogIdle(provider)
}
- com.streamvault.domain.model.Result.success(Unit)
+ return@lock (failures.firstOrNull()?.let {
+ Result.error(sanitizeThrowableMessage(it), it)
+ } ?: Result.success(Unit)).alsoApplyPendingRestore(providerId)
}
- result.alsoApplyPendingRestore(providerId)
+ }
+
+ private suspend fun commitStalkerCatalogPage(
+ provider: Provider,
+ categoryId: Long,
+ page: com.streamvault.data.remote.stalker.StalkerPagedResult<out Any>
+ ) {
+ if (provider.catalogLayout != CatalogLayout.UNIFIED_VOD) return
+ val items = page.items.filterIsInstance<StalkerVodCatalogItem>()
+ inFencedStalkerIndexTransaction(provider.id) {
+ val current = vodCategoryHydrationDao.get(provider.id, categoryId)
+ val entries = items.mapIndexed { index, entry ->
+ when (val item = entry.item) {
+ is VodCatalogItem.MovieItem -> VodCatalogEntryEntity(provider.id, categoryId, entry.rawItemId,
+ ContentType.MOVIE, item.movie.streamId, page.page, index)
+ is VodCatalogItem.SeriesItem -> VodCatalogEntryEntity(provider.id, categoryId, entry.rawItemId,
+ ContentType.SERIES, item.series.seriesId, page.page, index)
+ }
+ }
+ vodCatalogEntryDao.replacePage(provider.id, categoryId, page.page, entries)
+ // An interactive category request may have advanced while this page was in flight.
+ if ((current?.lastSuccessfulPage ?: 0) > page.page) return@inFencedStalkerIndexTransaction
+ vodCategoryHydrationDao.upsert(VodCategoryHydrationEntity(
+ providerId = provider.id, categoryId = categoryId,
+ lastLoadedPage = page.page, lastAttemptedPage = page.page, lastSuccessfulPage = page.page,
+ totalPages = page.totalPages, advertisedTotalItems = page.advertisedTotalItems,
+ advertisedTotalPages = page.advertisedTotalPages, pageSize = page.pageSize,
+ itemCount = vodCatalogEntryDao.countByCategory(provider.id, categoryId),
+ isComplete = page.isComplete && !page.isTruncated,
+ hasMovies = current?.hasMovies == true || items.any { it.item is VodCatalogItem.MovieItem },
+ hasSeries = current?.hasSeries == true || items.any { it.item is VodCatalogItem.SeriesItem },
+ lastHydratedAt = System.currentTimeMillis(), lastStatus = if (page.isTruncated) "TRUNCATED" else "SUCCESS"
+ ))
}
}
@@ -1922,11 +1921,7 @@ class SyncManager @Inject constructor(
} else api.getUnifiedVodPage(categoryId, page)
}
if (splitVod && contentType == ContentType.MOVIE) {
- val seriesCategoryId = api.projectVodCategoryToSeries(categoryId)
- ?: return Result.error("Unable to resolve VOD-derived Series category")
- return if (BuildConfig.STALKER_ADAPTIVE_INDEXING) {
- api.getSplitVodPage(categoryId, seriesCategoryId, page, sortBy = StalkerProvider.WILDCARD_INDEX_SORT)
- } else api.getSplitVodPage(categoryId, seriesCategoryId, page)
+ return api.getSplitVodPage(categoryId, page, sortBy = StalkerProvider.WILDCARD_INDEX_SORT)
}
return fetchStalkerSummaryPage(api, contentType, categoryId, page)
}
@@ -1974,7 +1969,7 @@ class SyncManager @Inject constructor(
): Result<com.streamvault.data.remote.stalker.StalkerPagedResult<out Any>> {
suspend fun fetch(): Result<com.streamvault.data.remote.stalker.StalkerPagedResult<out Any>> =
if (contentType == ContentType.MOVIE && provider.catalogLayout == CatalogLayout.UNIFIED_VOD) {
- api.getUnifiedVodPage(categoryId, page, sortBy = StalkerProvider.WILDCARD_INDEX_SORT)
+ api.getUnifiedVodPageUsingItemCategories(categoryId, page)
} else {
fetchStalkerWildcardSummaryPage(api, contentType, categoryId, page)
}
@@ -2028,7 +2023,7 @@ class SyncManager @Inject constructor(
api.getVodStreamsPage(categoryId, page, sortBy = StalkerProvider.WILDCARD_INDEX_SORT)
} else api.getVodStreamsPage(categoryId, page)
ContentType.SERIES -> if (BuildConfig.STALKER_ADAPTIVE_INDEXING) {
- api.getSeriesListPage(categoryId, page, sortBy = StalkerProvider.WILDCARD_INDEX_SORT)
+ api.getNativeSeriesListPage(categoryId, page, sortBy = StalkerProvider.WILDCARD_INDEX_SORT)
} else api.getSeriesListPage(categoryId, page)
else -> Result.error("Unsupported Stalker summary page section: $contentType")
}
@@ -2040,7 +2035,7 @@ class SyncManager @Inject constructor(
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)
+ ContentType.SERIES -> api.getNativeSeriesListPageUsingItemCategories(categoryId, page)
else -> Result.error("Unsupported Stalker wildcard summary page section: $contentType")
}
diff --git a/data/src/main/java/com/streamvault/data/sync/SyncStatusPublicationCoordinator.kt b/data/src/main/java/com/streamvault/data/sync/SyncStatusPublicationCoordinator.kt
index 46112dfd..e1ea3105 100644
--- a/data/src/main/java/com/streamvault/data/sync/SyncStatusPublicationCoordinator.kt
+++ b/data/src/main/java/com/streamvault/data/sync/SyncStatusPublicationCoordinator.kt
@@ -1,6 +1,7 @@
package com.streamvault.data.sync
import com.streamvault.domain.model.ContentType
+import com.streamvault.data.local.DatabaseTransactionRunner
import com.streamvault.domain.model.SyncMetadata
import com.streamvault.domain.model.SyncState
import com.streamvault.domain.model.VodSyncMode
@@ -19,7 +20,8 @@ import java.util.concurrent.ConcurrentHashMap
internal class SyncStatusPublicationCoordinator(
private val syncMetadataRepository: SyncMetadataRepository,
private val syncProgressBus: SyncProgressBus,
- private val syncStateTracker: SyncStateTracker = SyncStateTracker()
+ private val syncStateTracker: SyncStateTracker = SyncStateTracker(),
+ private val transactionRunner: DatabaseTransactionRunner? = null
) {
val syncState: StateFlow<SyncState>
get() = syncStateTracker.aggregateState
@@ -33,7 +35,10 @@ internal class SyncStatusPublicationCoordinator(
fun currentSyncState(providerId: Long): SyncState = syncStateTracker.current(providerId)
- suspend fun updateStatus(providerId: Long, status: String) {
+ private suspend fun <T> inMetadataTransaction(block: suspend () -> T): T =
+ transactionRunner?.inTransaction(block) ?: block()
+
+ suspend fun updateStatus(providerId: Long, status: String) = inMetadataTransaction {
val metadata = (syncMetadataRepository.getMetadata(providerId) ?: SyncMetadata(providerId))
.copy(lastSyncStatus = status)
syncMetadataRepository.updateMetadata(metadata)
@@ -46,7 +51,7 @@ internal class SyncStatusPublicationCoordinator(
finalState: String,
now: Long,
movieSyncMode: VodSyncMode
- ) {
+ ) = inMetadataTransaction {
val metadata = syncMetadataRepository.getMetadata(providerId) ?: SyncMetadata(providerId)
when (contentType) {
ContentType.MOVIE -> syncMetadataRepository.updateMetadata(
diff --git a/data/src/test/java/com/streamvault/data/provider/StalkerLearningMapperTest.kt b/data/src/test/java/com/streamvault/data/provider/StalkerLearningMapperTest.kt
new file mode 100644
index 00000000..084eecff
--- /dev/null
+++ b/data/src/test/java/com/streamvault/data/provider/StalkerLearningMapperTest.kt
@@ -0,0 +1,41 @@
+package com.streamvault.data.provider
+
+import com.google.common.truth.Truth.assertThat
+import com.google.gson.Gson
+import com.streamvault.data.local.entity.StalkerPortalStateEntity
+import com.streamvault.domain.model.CapabilityState
+import com.streamvault.domain.model.StalkerObservation
+import com.streamvault.domain.model.StalkerObservationSource
+import com.streamvault.domain.model.StalkerPortalLearning
+import org.junit.Test
+
+class StalkerLearningMapperTest {
+ @Test fun repairsPartialPersistedLearningWithoutOptionalCollections() {
+ val state = StalkerPortalStateEntity(providerId = 1, configurationGeneration = 2,
+ seriesWildcardSupported = false, learningJson = """{"configurationGeneration":2,"capabilities":{"series":{"value":"UNSUPPORTED","configurationGeneration":2,"source":"CATALOG","observedAt":1}}}""")
+ val learning = requireNotNull(state.toGenerationValidLearning(Gson(), 2))
+ assertThat(learning.capabilities).doesNotContainKey("series")
+ assertThat(learning.discoveryEvidence).isEmpty()
+ }
+ @Test fun rejectedWildcardDoesNotDisablePagedCatalogs() {
+ val state = StalkerPortalStateEntity(providerId = 1, configurationGeneration = 2,
+ movieWildcardSupported = false, seriesWildcardSupported = false)
+ val learning = requireNotNull(state.toGenerationValidLearning(Gson(), 2))
+ assertThat(learning.capabilities).doesNotContainKey("vod")
+ assertThat(learning.capabilities).doesNotContainKey("series")
+ assertThat(learning.capabilities["series_wildcard"]?.value).isEqualTo(CapabilityState.UNSUPPORTED)
+ }
+
+ @Test fun repairsLegacyWildcardCapabilityWithoutRemovingActualEndpointRestriction() {
+ val gson = Gson()
+ val old = StalkerPortalLearning(configurationGeneration = 2, capabilities = mapOf(
+ "series" to StalkerObservation(CapabilityState.UNSUPPORTED, 2, StalkerObservationSource.CATALOG, 1),
+ "vod" to StalkerObservation(CapabilityState.RESTRICTED, 2, StalkerObservationSource.DISCOVERY, 1)
+ ))
+ val state = StalkerPortalStateEntity(providerId = 1, configurationGeneration = 2,
+ movieWildcardSupported = false, seriesWildcardSupported = false, learningJson = gson.toJson(old))
+ val learning = requireNotNull(state.toGenerationValidLearning(gson, 2))
+ assertThat(learning.capabilities).doesNotContainKey("series")
+ assertThat(learning.capabilities["vod"]?.value).isEqualTo(CapabilityState.RESTRICTED)
+ }
+}
diff --git a/data/src/test/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiServiceTest.kt b/data/src/test/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiServiceTest.kt
index 44afada0..e852ed47 100644
--- a/data/src/test/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiServiceTest.kt
+++ b/data/src/test/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiServiceTest.kt
@@ -2741,17 +2741,18 @@ class OkHttpStalkerApiServiceTest {
}
@Test
- fun getSeriesDetails_fetches_shell_season_page_for_explicit_episode_cmds() = runTest {
+ fun getSeriesDetails_usesInlineEpisodeNumbersWithoutExtraSeasonRequests() = runTest {
val requestedSeasonIds = mutableListOf<String>()
val service = OkHttpStalkerApiService(
okHttpClient = OkHttpClient.Builder()
.addInterceptor { chain ->
val request = chain.request()
val action = request.url.queryParameter("action").orEmpty()
+ assertThat(request.url.queryParameter("category")).isEqualTo("42")
val seasonId = request.url.queryParameter("season_id").orEmpty()
val body = when {
action != "get_ordered_list" -> error("Unexpected action '$action'")
- seasonId == "0" -> """
+ seasonId.isEmpty() -> """
{"js":{"total_items":1,"max_page_items":14,"data":[{"id":"55000:1","name":"Season 1","description":"Doc","series":[1,2,3,4],"cmd":"eyJzZXJpZXNfaWQiOjU1MDAwLCJzZWFzb25fbnVtIjoxLCJ0eXBlIjoic2VyaWVzIn0=","screenshot_uri":"https://img.example.com/season1.jpg"}]}}
""".trimIndent()
seasonId == "1" -> {
@@ -2774,7 +2775,7 @@ class OkHttpStalkerApiServiceTest {
json = Json { ignoreUnknownKeys = true }
)
- val result = service.getSeriesDetails(
+ val result = service.getSeriesDetailsInCategory(
session = StalkerSession(
loadUrl = "https://portal.example.com/server/load.php",
portalReferer = "https://portal.example.com/c/",
@@ -2787,20 +2788,21 @@ class OkHttpStalkerApiServiceTest {
timezone = "UTC",
locale = "en"
),
- seriesId = "55000:55000"
+ seriesId = "55000:55000",
+ categoryId = "42"
)
assertThat(result).isInstanceOf(Result.Success::class.java)
val success = result as Result.Success
- assertThat(requestedSeasonIds).containsExactly("1")
+ assertThat(requestedSeasonIds).isEmpty()
assertThat(success.data.seasons).hasSize(1)
val season = success.data.seasons.single()
- assertThat(season.episodes).hasSize(1)
- assertThat(season.episodes.single().cmd).isEqualTo("ffmpeg http://example.com/episode1.mp4")
+ assertThat(season.episodes).hasSize(4)
+ assertThat(season.episodes.map { it.playbackSelector }).containsExactly(1, 2, 3, 4).inOrder()
}
@Test
- fun getSeriesDetails_preserves_shell_season_numbers_when_followup_rows_omit_them() = runTest {
+ fun getSeriesDetails_preservesInlineSeasonNumbersWithoutFollowupRequests() = runTest {
val requestedSeasonIds = mutableListOf<String>()
val service = OkHttpStalkerApiService(
okHttpClient = OkHttpClient.Builder()
@@ -2810,7 +2812,7 @@ class OkHttpStalkerApiServiceTest {
val seasonId = request.url.queryParameter("season_id").orEmpty()
val body = when {
action != "get_ordered_list" -> error("Unexpected action '$action'")
- seasonId == "0" ->
+ seasonId.isEmpty() ->
"""
{"js":{"total_items":2,"max_page_items":14,"data":[
{"id":"55000:alpha","name":"Season 1","description":"Alpha","series":[1,2],"cmd":"shell-cmd-1"},
@@ -2867,7 +2869,7 @@ class OkHttpStalkerApiServiceTest {
assertThat(result).isInstanceOf(Result.Success::class.java)
val success = result as Result.Success
- assertThat(requestedSeasonIds).containsExactly("1", "2")
+ assertThat(requestedSeasonIds).isEmpty()
assertThat(success.data.seasons.map { it.seasonNumber }).containsExactly(1, 2).inOrder()
assertThat(success.data.seasons.map { it.name }).containsExactly("Season 1", "Season 2").inOrder()
assertThat(success.data.seasons[0].episodes.map { it.episodeNumber }).containsExactly(1, 2).inOrder()
diff --git a/data/src/test/java/com/streamvault/data/remote/stalker/SortedPagingTestSupport.kt b/data/src/test/java/com/streamvault/data/remote/stalker/SortedPagingTestSupport.kt
new file mode 100644
index 00000000..8e393a87
--- /dev/null
+++ b/data/src/test/java/com/streamvault/data/remote/stalker/SortedPagingTestSupport.kt
@@ -0,0 +1,20 @@
+package com.streamvault.data.remote.stalker
+
+import org.mockito.kotlin.any
+import org.mockito.kotlin.anyOrNull
+import org.mockito.kotlin.doSuspendableAnswer
+import org.mockito.kotlin.whenever
+
+/** Interface default overloads are not executed by Mockito mocks. */
+suspend fun StalkerApiService.delegateSortedPagingToBasicStubs() {
+ whenever(getSeriesDetailsInCategory(any(), any(), any(), any()))
+ .doSuspendableAnswer { call -> getSeriesDetails(call.getArgument(0), call.getArgument(1), call.getArgument(2)) }
+ whenever(getVodStreamsPage(any(), any(), anyOrNull(), any(), anyOrNull(), anyOrNull()))
+ .doSuspendableAnswer { call ->
+ getVodStreamsPage(call.getArgument(0), call.getArgument(1), call.getArgument(2), call.getArgument(3))
+ }
+ whenever(getSeriesPage(any(), any(), anyOrNull(), any(), anyOrNull()))
+ .doSuspendableAnswer { call ->
+ getSeriesPage(call.getArgument(0), call.getArgument(1), call.getArgument(2), call.getArgument(3))
+ }
+}
diff --git a/data/src/test/java/com/streamvault/data/remote/stalker/StalkerPortalStateStoreTest.kt b/data/src/test/java/com/streamvault/data/remote/stalker/StalkerPortalStateStoreTest.kt
index ad9a9464..cb15297e 100644
--- a/data/src/test/java/com/streamvault/data/remote/stalker/StalkerPortalStateStoreTest.kt
+++ b/data/src/test/java/com/streamvault/data/remote/stalker/StalkerPortalStateStoreTest.kt
@@ -17,6 +17,15 @@ import org.junit.Test
import java.util.Base64
class StalkerPortalStateStoreTest {
+ @Test
+ fun `rejected wildcard is a paging capability rather than a disabled catalog`() = runTest {
+ val store = StalkerPortalStateStore(FakePortalStateDao(), TestCredentialCrypto())
+ store.recordWildcard(1, ContentType.SERIES, false, configurationGeneration = 2)
+ val capabilities = Json.parseToJsonElement(requireNotNull(store.get(1)).learningJson)
+ .jsonObject.getValue("capabilities").jsonObject
+ assertThat(capabilities.keys).contains("series_wildcard")
+ assertThat(capabilities.keys).doesNotContain("series")
+ }
@Test
fun `first run adopts learning generation created after handshake`() = runTest {
val dao = FakePortalStateDao()
diff --git a/data/src/test/java/com/streamvault/data/remote/stalker/StalkerProviderTest.kt b/data/src/test/java/com/streamvault/data/remote/stalker/StalkerProviderTest.kt
index dfa6c11c..a1c56368 100644
--- a/data/src/test/java/com/streamvault/data/remote/stalker/StalkerProviderTest.kt
+++ b/data/src/test/java/com/streamvault/data/remote/stalker/StalkerProviderTest.kt
@@ -1118,60 +1118,21 @@ class StalkerProviderTest {
}
@Test
- fun vodPaging_detectsZeroBasedPortalAndPersistsOffsetAcrossProviderInstances() = runTest {
- val dao = FakePortalStateDao()
- val store = StalkerPortalStateStore(dao, TestCredentialCrypto())
+ fun vodPagingRequestsOneBasedPagesWithoutSamplingPageZero() = runTest {
val api = FakeStalkerApiService(
profile = StalkerProviderProfile(accountName = "Room"),
vodPageResultsByPage = mapOf(
- 0 to stalkerVodPage(0, "zero-first", "First page"),
- 1 to stalkerVodPage(1, "zero-second", "Second page"),
- 2 to stalkerVodPage(2, "zero-third", "Third page")
- )
- )
- fun provider() = StalkerProvider(
- providerId = 47L,
- api = api,
- portalUrl = "https://portal.example.com/c/",
- macAddress = "00:1A:79:12:34:56",
- deviceProfile = "MAG250",
- timezone = "UTC",
- locale = "en",
- configurationGeneration = 9L,
- portalStateStore = store
- )
-
- val first = provider().getVodStreamsPage(categoryId = null, page = 1) as Result.Success
- assertThat(first.data.items.single().name).isEqualTo("First page")
- assertThat(first.data.page).isEqualTo(1)
- assertThat(api.vodPageRequests).containsExactly(0, 1).inOrder()
- assertThat(store.getVodPageBase(47L, 9L)).isEqualTo(0)
-
- val resumed = provider().getVodStreamsPage(categoryId = null, page = 2) as Result.Success
- assertThat(resumed.data.items.single().name).isEqualTo("Second page")
- assertThat(resumed.data.page).isEqualTo(2)
- assertThat(api.vodPageRequests).containsExactly(0, 1, 1).inOrder()
- assertThat(api.authenticateCalls).isEqualTo(1)
- }
-
- @Test
- fun vodPaging_detectsOneBasedPortalWhenPageZeroAliasesPageOne() = runTest {
- val api = FakeStalkerApiService(
- profile = StalkerProviderProfile(accountName = "Room"),
- vodPageResultsByPage = mapOf(
- 0 to stalkerVodPage(0, "one-first", "First page"),
- 1 to stalkerVodPage(1, "one-first", "First page"),
- 2 to stalkerVodPage(2, "one-second", "Second page")
+ 0 to stalkerVodPage(0, "last", "Last page"),
+ 1 to stalkerVodPage(1, "first", "First page"),
+ 2 to stalkerVodPage(2, "second", "Second page")
)
)
val provider = categoryReuseProvider(api)
-
val first = provider.getVodStreamsPage(categoryId = null, page = 1) as Result.Success
val second = provider.getVodStreamsPage(categoryId = null, page = 2) as Result.Success
-
assertThat(first.data.items.single().name).isEqualTo("First page")
assertThat(second.data.items.single().name).isEqualTo("Second page")
- assertThat(api.vodPageRequests).containsExactly(0, 1, 2).inOrder()
+ assertThat(api.vodPageRequests).containsExactly(1, 2).inOrder()
}
private fun stalkerVodPage(page: Int, id: String, title: String) = StalkerPagedItems(
@@ -1221,6 +1182,58 @@ class StalkerProviderTest {
assertThat(series.categoryName).isEqualTo("Drama")
}
+ @Test
+ fun unifiedBulkPagePreservesMovieAndSeriesCategories() = runTest {
+ val source = categoryReuseProvider(FakeStalkerApiService(
+ profile = StalkerProviderProfile(accountName = "Room"),
+ vodCategories = listOf(StalkerCategoryRecord("*", "All"), StalkerCategoryRecord("10", "Mixed")),
+ vodPageItems = listOf(
+ StalkerItemRecord(id = "1", name = "Movie", categoryId = "10", cmd = "http://cdn.example.com/1.mp4"),
+ StalkerItemRecord(id = "2", name = "Series", categoryId = "10", isSeries = true)
+ )
+ ))
+ val categories = (source.getUnifiedVodCategories() as Result.Success).data
+ val result = source.getUnifiedVodPageUsingItemCategories(categories.first().id, 1) as Result.Success
+ assertThat(result.data.items.map { entry -> when (val item = entry.item) {
+ is VodCatalogItem.MovieItem -> item.movie.categoryId
+ is VodCatalogItem.SeriesItem -> item.series.categoryId
+ } }).containsExactly(categories.last().id, categories.last().id)
+ }
+
+ @Test
+ fun nativeSeriesBulkPagePreservesEachItemsCategory() = runTest {
+ val source = categoryReuseProvider(FakeStalkerApiService(
+ profile = StalkerProviderProfile(accountName = "Room"),
+ seriesCategories = listOf(StalkerCategoryRecord("*", "All"), StalkerCategoryRecord("10", "Series")),
+ seriesPageItems = listOf(StalkerItemRecord(id = "2", name = "Series", categoryId = "10", isSeries = true))
+ ))
+ val categories = (source.getSeriesCategories() as Result.Success).data
+ val result = source.getNativeSeriesListPageUsingItemCategories(categories.first().id, 1) as Result.Success
+ assertThat(result.data.items.single().categoryId).isEqualTo(categories.last().id)
+ }
+
+ @Test
+ fun categoryMappingsSurviveLargeLiveIdentityCacheEviction() = runTest {
+ val resolver = StalkerRemoteIdentityResolver(FakeIdentityDao(), DirectTransactionRunner)
+ val api = FakeStalkerApiService(
+ profile = StalkerProviderProfile(accountName = "Room"),
+ liveStreams = (1..5_000).map {
+ StalkerItemRecord(id = "$it", name = "Channel $it", categoryId = "10", cmd = "http://cdn.example.com/$it.ts")
+ },
+ vodCategories = (1..600).map { StalkerCategoryRecord("$it", "Movies $it") },
+ seriesCategories = listOf(StalkerCategoryRecord("20", "Series"))
+ )
+ val provider = StalkerProvider(
+ providerId = 7, api = api, portalUrl = "https://portal.example.com/c/",
+ macAddress = "00:1A:79:12:34:56", deviceProfile = "MAG250", timezone = "UTC", locale = "en",
+ identityResolver = resolver
+ )
+ provider.streamLiveStreams { }
+ val categories = (provider.getVodCategories() as Result.Success).data
+ assertThat(categories.map { it.id }).containsExactlyElementsIn((1L..600L).toList()).inOrder()
+ categories.forEach { assertThat(provider.projectVodCategoryToSeries(it.id)).isNotNull() }
+ }
+
@Test
fun streamLiveStreams_resolves_large_catalog_identities_in_batches() = runTest {
val transactionRunner = CountingTransactionRunner()
diff --git a/data/src/test/java/com/streamvault/data/remote/stalker/StalkerRequestCoordinatorTest.kt b/data/src/test/java/com/streamvault/data/remote/stalker/StalkerRequestCoordinatorTest.kt
index 29411972..487fea87 100644
--- a/data/src/test/java/com/streamvault/data/remote/stalker/StalkerRequestCoordinatorTest.kt
+++ b/data/src/test/java/com/streamvault/data/remote/stalker/StalkerRequestCoordinatorTest.kt
@@ -130,12 +130,10 @@ class StalkerRequestCoordinatorTest {
}
@Test
- fun playbackTrickleUsesTwentySecondsForEveryWireRequestAndInteractiveStillWins() = runTest {
+ fun playbackPausesIndexRequestsWhileInteractiveMetadataRemainsAvailable() = runTest {
val coordinator = StalkerRequestCoordinator(null, true) { testScheduler.currentTime }
StalkerTrafficCoordinator.notePlaybackStarted(74L)
try {
- val first = coordinator.acquireNetworkPermit(74L, StalkerNetworkPriority.INDEX)
- coordinator.releaseNetworkPermit(first)
val next = async { coordinator.acquireNetworkPermit(74L, StalkerNetworkPriority.INDEX) }
runCurrent()
val interactive = coordinator.acquireNetworkPermit(74L, StalkerNetworkPriority.INTERACTIVE)
@@ -144,9 +142,10 @@ class StalkerRequestCoordinatorTest {
runCurrent()
assertThat(next.isCompleted).isFalse()
coordinator.releaseNetworkPermit(interactive)
+ StalkerTrafficCoordinator.forgetProvider(74L)
advanceUntilIdle()
val second = next.await()
- assertThat(second.admittedAt - first.admittedAt).isAtLeast(20_000L)
+ assertThat(second.admittedAt).isAtLeast(21_000L)
coordinator.releaseNetworkPermit(second)
} finally { StalkerTrafficCoordinator.forgetProvider(74L) }
}
diff --git a/data/src/test/java/com/streamvault/data/remote/stalker/StalkerTrafficCoordinatorTest.kt b/data/src/test/java/com/streamvault/data/remote/stalker/StalkerTrafficCoordinatorTest.kt
index a9fcbb9c..520ba700 100644
--- a/data/src/test/java/com/streamvault/data/remote/stalker/StalkerTrafficCoordinatorTest.kt
+++ b/data/src/test/java/com/streamvault/data/remote/stalker/StalkerTrafficCoordinatorTest.kt
@@ -7,10 +7,9 @@ import org.junit.Test
class StalkerTrafficCoordinatorTest {
@Test
- fun `opt in lets worker run during playback with all pacing at wire admission`() {
+ fun `background continuation yields during playback even with adaptive network admission`() {
StalkerTrafficCoordinator.notePlaybackStarted(7L)
- assertThat(StalkerTrafficCoordinator.shouldDeferIndexForPlayback(7L, false)).isTrue()
- assertThat(StalkerTrafficCoordinator.shouldDeferIndexForPlayback(7L, true)).isFalse()
+ assertThat(StalkerTrafficCoordinator.shouldDeferIndexForPlayback(7L)).isTrue()
assertThat(StalkerTrafficCoordinator.backgroundInterPageDelayMillis(7L, true)).isEqualTo(0L)
}
diff --git a/data/src/test/java/com/streamvault/data/repository/MovieRepositoryImplTest.kt b/data/src/test/java/com/streamvault/data/repository/MovieRepositoryImplTest.kt
index 1cc76a8d..01d7c46d 100644
--- a/data/src/test/java/com/streamvault/data/repository/MovieRepositoryImplTest.kt
+++ b/data/src/test/java/com/streamvault/data/repository/MovieRepositoryImplTest.kt
@@ -38,6 +38,7 @@ import com.streamvault.data.remote.stalker.stalkerStableHashId
import com.streamvault.data.remote.dto.XtreamCategory
import com.streamvault.data.remote.dto.XtreamStream
import com.streamvault.data.remote.stalker.StalkerApiService
+import com.streamvault.data.remote.stalker.delegateSortedPagingToBasicStubs
import com.streamvault.data.remote.xtream.XtreamApiService
import com.streamvault.data.remote.xtream.XtreamStreamUrlResolver
import com.streamvault.data.security.CredentialCrypto
@@ -806,7 +807,7 @@ class MovieRepositoryImplTest {
}
@Test
- fun `complete request hydrates every advertised stalker movie page before returning`() = runTest {
+ fun `complete request opens one page and leaves remaining pages to background indexing`() = runTest {
whenever(preferencesRepository.parentalControlLevel).thenReturn(flowOf(0))
whenever(preferencesRepository.vodCategoryLoadMode).thenReturn(flowOf(VodCategoryLoadMode.PAGED))
whenever(movieDao.getCountByCategory(7L, 42L)).thenReturn(
@@ -835,10 +836,9 @@ class MovieRepositoryImplTest {
VodCategoryHydrationRequest.COMPLETE
)
- (1..3).forEach { page ->
- verify(stalkerApiService).getVodStreamsPage(any(), any(), anyOrNull(), eq(page))
- }
- verify(stalkerApiService, never()).getVodStreamsPage(any(), any(), anyOrNull(), eq(4))
+ verify(stalkerApiService).getVodStreamsPage(any(), any(), anyOrNull(), eq(1))
+ verify(stalkerApiService, never()).getVodStreamsPage(any(), any(), anyOrNull(), eq(2))
+ verify(syncManager).prioritizeStalkerIndexCategory(7L, ContentType.MOVIE, 42L)
}
@Test
@@ -868,7 +868,7 @@ class MovieRepositoryImplTest {
Result.success(stalkerMoviePage(page = 4, itemCount = 14))
)
- createRepository().getMoviesByCategoryPage(7L, 42L, limit = 60, offset = 60).first()
+ createRepository().requestCategoryHydration(7L, 42L, VodCategoryHydrationRequest.NEXT_PAGE)
verify(stalkerApiService).getVodStreamsPage(any(), any(), anyOrNull(), eq(4))
verify(stalkerApiService, never()).getVodStreamsPage(any(), any(), anyOrNull(), eq(5))
@@ -1333,6 +1333,7 @@ class MovieRepositoryImplTest {
}
private suspend fun stubProvider(provider: Provider) {
+ stalkerApiService.delegateSortedPagingToBasicStubs()
whenever(providerDao.getById(provider.id)).thenReturn(provider.toEntity())
val snapshot = provider.toProviderSnapshot()
whenever(providerCapabilityResolver.snapshot(provider.id)).thenReturn(snapshot)
diff --git a/data/src/test/java/com/streamvault/data/repository/SeriesRepositoryImplTest.kt b/data/src/test/java/com/streamvault/data/repository/SeriesRepositoryImplTest.kt
index 1a168971..faca20f2 100644
--- a/data/src/test/java/com/streamvault/data/repository/SeriesRepositoryImplTest.kt
+++ b/data/src/test/java/com/streamvault/data/repository/SeriesRepositoryImplTest.kt
@@ -42,6 +42,7 @@ import com.streamvault.data.remote.stalker.StalkerSession
import com.streamvault.data.remote.dto.XtreamCategory
import com.streamvault.data.remote.dto.XtreamSeriesItem
import com.streamvault.data.remote.stalker.StalkerApiService
+import com.streamvault.data.remote.stalker.delegateSortedPagingToBasicStubs
import com.streamvault.data.remote.xtream.XtreamParsingException
import com.streamvault.data.remote.xtream.XtreamApiService
import com.streamvault.data.remote.xtream.XtreamStreamUrlResolver
@@ -112,6 +113,7 @@ class SeriesRepositoryImplTest {
@Before
fun clearStalkerCaches() {
+ kotlinx.coroutines.runBlocking { stalkerApiService.delegateSortedPagingToBasicStubs() }
StalkerProvider.clearSharedAuthCacheForTests()
StalkerProvider.clearResolvedStreamUrlCacheForTests()
}
@@ -644,6 +646,7 @@ class SeriesRepositoryImplTest {
@Test
fun `scrolling cached stalker series category appends exactly one natural page`() = runTest {
+ whenever(seriesDao.countByCategoryAndOrigin(any(), any(), any())).thenReturn(0)
whenever(preferencesRepository.parentalControlLevel).thenReturn(flowOf(0))
whenever(seriesDao.getCountByCategory(7L, 77L)).thenReturn(flowOf(42), flowOf(56))
whenever(seriesDao.getByCategoryPage(7L, 77L, 60, 60)).thenReturn(flowOf(emptyList()))
@@ -669,7 +672,7 @@ class SeriesRepositoryImplTest {
Result.success(stalkerSeriesPage(page = 4, itemCount = 14))
)
- createRepository().getSeriesByCategoryPage(7L, 77L, limit = 60, offset = 60).first()
+ createRepository().requestCategoryHydration(7L, 77L, com.streamvault.domain.model.VodCategoryHydrationRequest.NEXT_PAGE)
verify(stalkerApiService).getSeriesPage(any(), any(), anyOrNull(), eq(4))
verify(stalkerApiService, never()).getSeriesPage(any(), any(), anyOrNull(), eq(5))
diff --git a/data/src/test/java/com/streamvault/data/repository/VodRepositoryImplTest.kt b/data/src/test/java/com/streamvault/data/repository/VodRepositoryImplTest.kt
index 260d6440..6c1d1e52 100644
--- a/data/src/test/java/com/streamvault/data/repository/VodRepositoryImplTest.kt
+++ b/data/src/test/java/com/streamvault/data/repository/VodRepositoryImplTest.kt
@@ -42,6 +42,7 @@ import org.mockito.kotlin.verify
import org.mockito.kotlin.verifyNoInteractions
import org.mockito.kotlin.whenever
import org.mockito.kotlin.timeout
+import org.mockito.kotlin.never
class VodRepositoryImplTest {
private val movieDao = mock<MovieDao>()
@@ -204,7 +205,7 @@ class VodRepositoryImplTest {
}
@Test
- fun openInPagedMode_fetchesOnePageThenPrefetchesExactlyOnePage() = runTest {
+ fun openPrioritizesCategoryAndLeavesBackfillToSharedImporter() = runTest {
whenever(preferences.vodCategoryLoadMode).thenReturn(flowOf(VodCategoryLoadMode.PAGED))
whenever(syncManager.hydrateUnifiedVodCategory(8, 201, VodCategoryHydrationRequest.OPEN))
.thenReturn(Result.success(Unit))
@@ -214,7 +215,8 @@ class VodRepositoryImplTest {
repository().requestCategoryHydration(8, 201, VodCategoryHydrationRequest.OPEN)
verify(syncManager).hydrateUnifiedVodCategory(8, 201, VodCategoryHydrationRequest.OPEN)
- verify(syncManager, timeout(1_000)).hydrateUnifiedVodCategory(
+ verify(syncManager).prioritizeStalkerIndexCategory(8, ContentType.MOVIE, 201)
+ verify(syncManager, never()).hydrateUnifiedVodCategory(
8,
201,
VodCategoryHydrationRequest.NEXT_PAGE
@@ -240,14 +242,14 @@ class VodRepositoryImplTest {
}
@Test
- fun completeOnOpenMode_usesCompleteRequestWithoutPagedOpen() = runTest {
+ fun completeOnOpenPreferenceDoesNotBlockStalkerBrowsing() = runTest {
whenever(preferences.vodCategoryLoadMode).thenReturn(flowOf(VodCategoryLoadMode.COMPLETE_ON_OPEN))
- whenever(syncManager.hydrateUnifiedVodCategory(8, 202, VodCategoryHydrationRequest.COMPLETE))
+ whenever(syncManager.hydrateUnifiedVodCategory(8, 202, VodCategoryHydrationRequest.OPEN))
.thenReturn(Result.success(Unit))
repository().requestCategoryHydration(8, 202, VodCategoryHydrationRequest.OPEN)
- verify(syncManager).hydrateUnifiedVodCategory(8, 202, VodCategoryHydrationRequest.COMPLETE)
+ verify(syncManager).hydrateUnifiedVodCategory(8, 202, VodCategoryHydrationRequest.OPEN)
}
@Test
diff --git a/data/src/test/java/com/streamvault/data/sync/BackgroundEpgExecutionTest.kt b/data/src/test/java/com/streamvault/data/sync/BackgroundEpgExecutionTest.kt
new file mode 100644
index 00000000..2e50f8a8
--- /dev/null
+++ b/data/src/test/java/com/streamvault/data/sync/BackgroundEpgExecutionTest.kt
@@ -0,0 +1,69 @@
+package com.streamvault.data.sync
+
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.domain.model.ProviderType
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.async
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class BackgroundEpgExecutionTest {
+ @Test
+ fun `Stalker guide runs while catalog lane is occupied and guide requests still serialize`() = runTest {
+ val locks = ProviderWorkLockRegistry()
+ val catalogEntered = CompletableDeferred<Unit>()
+ val guideEntered = CompletableDeferred<Unit>()
+ val release = CompletableDeferred<Unit>()
+ val catalog = async {
+ locks.withProviderLock(1L) { catalogEntered.complete(Unit); release.await() }
+ }
+ catalogEntered.await()
+ val guide = async {
+ executeBackgroundEpg(ProviderType.STALKER_PORTAL, workflow = { error("Catalog workflow must not own guide") }) {
+ locks.withStalkerGuideLock(1L) {
+ guideEntered.complete(Unit)
+ release.await()
+ ProviderWorkflowOutcome.Success()
+ }
+ }
+ }
+ guideEntered.await()
+ val secondGuideEntered = CompletableDeferred<Unit>()
+ val secondGuide = async { locks.withStalkerGuideLock(1L) { secondGuideEntered.complete(Unit) } }
+ testScheduler.runCurrent()
+ assertThat(secondGuideEntered.isCompleted).isFalse()
+ assertThat(locks.runWhenNoWorkActive { true }).isFalse()
+ release.complete(Unit)
+ catalog.await()
+ assertThat(guide.await()).isEqualTo(ProviderWorkflowDisposition.SUCCEEDED)
+ secondGuide.await()
+ assertThat(locks.isAnyWorkActiveOrWaiting()).isFalse()
+ }
+
+ @Test
+ fun `Stalker guide can take longer than sixty seconds and maps failures independently`() = runTest {
+ val results = listOf(
+ ProviderWorkflowOutcome.Success() to ProviderWorkflowDisposition.SUCCEEDED,
+ ProviderWorkflowOutcome.Failure("NETWORK", null, retryable = true) to ProviderWorkflowDisposition.RETRY,
+ ProviderWorkflowOutcome.Failure("INVALID", null, retryable = false) to ProviderWorkflowDisposition.FAILED
+ )
+ for ((outcome, expected) in results) {
+ assertThat(executeBackgroundEpg(ProviderType.STALKER_PORTAL, { error("Unexpected catalog lease") }) {
+ delay(90_000)
+ outcome
+ }).isEqualTo(expected)
+ }
+ }
+
+ @Test
+ fun `other providers keep their workflow admission`() = runTest {
+ var ran = false
+ val result = executeBackgroundEpg(ProviderType.XTREAM_CODES, workflow = { ProviderWorkflowDisposition.BUSY }) {
+ ran = true
+ ProviderWorkflowOutcome.Success()
+ }
+ assertThat(result).isEqualTo(ProviderWorkflowDisposition.BUSY)
+ assertThat(ran).isFalse()
+ }
+}
diff --git a/data/src/test/java/com/streamvault/data/sync/ProviderWorkSchedulingTest.kt b/data/src/test/java/com/streamvault/data/sync/ProviderWorkSchedulingTest.kt
index 3b06b44d..32072c98 100644
--- a/data/src/test/java/com/streamvault/data/sync/ProviderWorkSchedulingTest.kt
+++ b/data/src/test/java/com/streamvault/data/sync/ProviderWorkSchedulingTest.kt
@@ -6,15 +6,15 @@ import org.junit.Test
class ProviderWorkSchedulingTest {
@Test
- fun `all provider phases resolve to one unique work identity`() {
+ fun `Stalker catalog guide and setup have independent work identities`() {
val identities = listOf(
providerWorkUniqueName(7L),
- providerWorkUniqueName(7L),
- providerWorkUniqueName(7L),
- providerWorkUniqueName(7L)
+ stalkerIndexWorkUniqueName(7L),
+ providerEpgWorkUniqueName(7L),
+ providerAutomaticIndexWorkUniqueName(7L)
)
- assertThat(identities.distinct()).containsExactly("provider-workflow-7")
+ assertThat(identities.distinct()).hasSize(4)
}
@Test
diff --git a/data/src/test/java/com/streamvault/data/sync/StalkerCatalogExecutionTest.kt b/data/src/test/java/com/streamvault/data/sync/StalkerCatalogExecutionTest.kt
new file mode 100644
index 00000000..e22556eb
--- /dev/null
+++ b/data/src/test/java/com/streamvault/data/sync/StalkerCatalogExecutionTest.kt
@@ -0,0 +1,122 @@
+package com.streamvault.data.sync
+
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.data.remote.stalker.StalkerAdvancedOptions
+import com.streamvault.data.remote.stalker.StalkerAdvancedOptionsCodec
+import com.streamvault.domain.model.CatalogLayout
+import com.streamvault.domain.model.ContentType
+import com.streamvault.domain.model.StalkerCatalogLoadOrder
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.async
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.whenever
+
+class StalkerCatalogExecutionTest {
+ private val sections = listOf(ContentType.MOVIE, ContentType.SERIES)
+
+ @Test
+ fun `default and old saved options are parallel and new choices round trip`() {
+ assertThat(StalkerAdvancedOptionsCodec.decode("").catalogLoadOrder).isEqualTo(StalkerCatalogLoadOrder.PARALLEL)
+ assertThat(StalkerAdvancedOptionsCodec.decode("""{"hwVersion":"custom"}""").catalogLoadOrder)
+ .isEqualTo(StalkerCatalogLoadOrder.PARALLEL)
+ for (order in StalkerCatalogLoadOrder.entries) {
+ val original = StalkerAdvancedOptions(hwVersion = "custom", catalogLoadOrder = order)
+ assertThat(StalkerAdvancedOptionsCodec.decodeStrict(StalkerAdvancedOptionsCodec.encode(original))).isEqualTo(original)
+ }
+ val future = StalkerAdvancedOptionsCodec.decode("""{"catalogLoadOrder":"FUTURE","hwVersion":"custom"}""")
+ assertThat(future.catalogLoadOrder).isEqualTo(StalkerCatalogLoadOrder.PARALLEL)
+ assertThat(future.hwVersion).isEqualTo("custom")
+ }
+
+ @Test
+ fun `parallel mode and category heads start both sections without waiting for the other`() = runTest {
+ for ((order, heads) in listOf(StalkerCatalogLoadOrder.PARALLEL to false,
+ StalkerCatalogLoadOrder.MOVIES_FIRST to true, StalkerCatalogLoadOrder.SERIES_FIRST to true)) {
+ val entered = mutableSetOf<ContentType>()
+ val bothEntered = CompletableDeferred<Unit>()
+ val work = async {
+ executeStalkerCatalogSections(sections, order, heads, isPending = { true }) { section ->
+ entered += section
+ if (entered.size == 2) bothEntered.complete(Unit)
+ bothEntered.await()
+ section
+ }
+ }
+ bothEntered.await()
+ assertThat(work.await()).containsExactlyElementsIn(sections)
+ }
+ }
+
+ @Test
+ fun `serial choices keep the other section queued until the preferred section finishes`() = runTest {
+ for (order in listOf(StalkerCatalogLoadOrder.MOVIES_FIRST, StalkerCatalogLoadOrder.SERIES_FIRST)) {
+ val first = if (order == StalkerCatalogLoadOrder.MOVIES_FIRST) ContentType.MOVIE else ContentType.SERIES
+ val visited = mutableListOf<ContentType>()
+ val entered = CompletableDeferred<Unit>()
+ val release = CompletableDeferred<Unit>()
+ val work = async {
+ executeStalkerCatalogSections(sections, order, false, isPending = { false }) { section ->
+ visited += section
+ if (section == first) { entered.complete(Unit); release.await() }
+ section
+ }
+ }
+ entered.await()
+ assertThat(visited).containsExactly(first)
+ release.complete(Unit)
+ work.await()
+ assertThat(visited.first()).isEqualTo(first)
+ assertThat(visited).hasSize(2)
+ }
+ }
+
+ @Test
+ fun `retry waits keep the second section queued without an immediate successor loop`() = runTest {
+ for (order in listOf(StalkerCatalogLoadOrder.MOVIES_FIRST, StalkerCatalogLoadOrder.SERIES_FIRST)) {
+ val first = if (order == StalkerCatalogLoadOrder.MOVIES_FIRST) ContentType.MOVIE else ContentType.SERIES
+ val visited = mutableListOf<ContentType>()
+ executeStalkerCatalogSections(sections, order, false, isPending = { true }) { section -> visited += section; section }
+ assertThat(visited).containsExactly(first)
+ fun state(type: ContentType) = StalkerCatalogSectionState(type, type != first,
+ if (type == first) 120 else 0, true, "QUEUED", 0)
+ val decision = StalkerIndexPolicy.chooseNextSection(CatalogLayout.SPLIT, null,
+ state(ContentType.MOVIE), state(ContentType.SERIES), order)
+ assertThat(decision.contentType).isNull()
+ assertThat(decision.retryDelaySeconds).isEqualTo(120L)
+ }
+ }
+
+ @Test
+ fun `a terminal truncated first section releases the queued second section`() = runTest {
+ val dao = mock<com.streamvault.data.local.dao.StalkerIndexJobDao>()
+ whenever(dao.get(1L, ContentType.MOVIE.name)).thenReturn(
+ com.streamvault.data.local.entity.StalkerIndexJobEntity(1L, ContentType.MOVIE,
+ com.streamvault.domain.model.StalkerIndexState.PARTIAL))
+ val provider = com.streamvault.domain.model.LegacyProvider(1L, "Portal",
+ com.streamvault.domain.model.ProviderType.STALKER_PORTAL, serverUrl = "https://portal.invalid",
+ stalkerAdvancedOptionsJson = StalkerAdvancedOptionsCodec.encode(
+ StalkerAdvancedOptions(catalogLoadOrder = StalkerCatalogLoadOrder.MOVIES_FIRST)))
+ val truncated = StalkerHydrationSnapshot(1, 14, "TRUNCATED", null,
+ 1, 1, 1, 100, 1400, 100, false, 14, 0, 0, 3, null)
+ val coordinator = StalkerIndexContinuationCoordinator(
+ stalkerIndexJobStore = StalkerIndexJobStore(dao),
+ loadCategories = { _, type -> listOf(com.streamvault.data.local.entity.CategoryEntity(
+ categoryId = if (type == ContentType.MOVIE) 10 else 20, name = "Category", type = type, providerId = 1)) },
+ loadHydration = { _, type, _ -> if (type == ContentType.MOVIE) truncated else null },
+ visibleCategories = { _, _, categories, _ -> categories },
+ loadProvider = { provider }, loadStalkerProviders = { listOf(1) },
+ deleteLegacyJobs = {}, cancelIndex = {}, scheduleIndex = { _, _, _ -> }, scheduleBackgroundEpg = {})
+ val decision = coordinator.chooseNextSection(provider, mock(), null, false, 10)
+ assertThat(decision.contentType).isEqualTo(ContentType.SERIES)
+ }
+
+ @Test
+ fun `unified VOD and disabled sections never wait for an absent section`() = runTest {
+ val visited = mutableListOf<ContentType>()
+ executeStalkerCatalogSections(listOf(ContentType.MOVIE), StalkerCatalogLoadOrder.SERIES_FIRST, false,
+ isPending = { true }) { visited += it; it }
+ assertThat(visited).containsExactly(ContentType.MOVIE)
+ }
+}
diff --git a/data/src/test/java/com/streamvault/data/sync/StalkerIncrementalIndexExecutorTest.kt b/data/src/test/java/com/streamvault/data/sync/StalkerIncrementalIndexExecutorTest.kt
index 65b60c13..fe3d84fd 100644
--- a/data/src/test/java/com/streamvault/data/sync/StalkerIncrementalIndexExecutorTest.kt
+++ b/data/src/test/java/com/streamvault/data/sync/StalkerIncrementalIndexExecutorTest.kt
@@ -20,14 +20,95 @@ import org.junit.Test
class StalkerIncrementalIndexExecutorTest {
@Test
- fun wildcardWindowFetchesConcurrentlyAndCommitsCheckpointPagesInOrder() = runTest {
+ fun unifiedPageKeepsMoviesAndSeriesAndItsOrderedPageReceipt() = runTest {
+ val category = CategoryEntity(categoryId = 10L, name = "Catalog", type = ContentType.VOD, providerId = 91L)
+ val operations = WildcardIndexOperations(category, summaryPageCount = 1, mixedPage = true)
+ val api = mock<StalkerProvider>()
+ whenever(api.isWildcardCategory(org.mockito.kotlin.any(), org.mockito.kotlin.any())).thenReturn(false)
+ StalkerIncrementalIndexExecutor(operations).processCategoryHeads(
+ LegacyProvider(91L, "Portal", ProviderType.STALKER_PORTAL, serverUrl = "https://portal.invalid",
+ catalogLayout = CatalogLayout.UNIFIED_VOD), api, ContentType.MOVIE, null)
+ assertThat(operations.indexedMovies).hasSize(1)
+ assertThat(operations.indexedDerivedSeries).hasSize(1)
+ assertThat(operations.pageReceipts).containsExactly(10L to 1)
+ assertThat(operations.categoryHydration(10L)?.isComplete).isTrue()
+ }
+
+ @Test
+ fun unchangedCategoryCountKeepsCachedRowsWithoutWalkingEveryPageAgain() = runTest {
+ val category = CategoryEntity(categoryId = 10L, name = "Catalog", type = ContentType.MOVIE, providerId = 91L)
+ val operations = WildcardIndexOperations(category, summaryPageCount = 5, storedCategoryCounts = mapOf(10L to 5))
+ val api = mock<StalkerProvider>()
+ whenever(api.isWildcardCategory(org.mockito.kotlin.any(), org.mockito.kotlin.any())).thenReturn(false)
+ StalkerIncrementalIndexExecutor(operations).prepareCatalog(
+ LegacyProvider(91L, "Portal", ProviderType.STALKER_PORTAL, serverUrl = "https://portal.invalid"), api, ContentType.MOVIE, false, null)
+ assertThat(operations.summaryFetches).containsExactly(10L to 1)
+ assertThat(operations.preservedCategories).containsExactly(10L)
+ assertThat(operations.categoryHydration(10L)?.isComplete).isTrue()
+ }
+ @Test
+ fun freshLargeCatalogDefersOnlyAfterEveryCategoryHeadIsStored() = runTest {
+ val categories = (1L..24L).map { CategoryEntity(categoryId = it, name = "Category $it", type = ContentType.MOVIE, providerId = 91L) }
+ val operations = WildcardIndexOperations(categories.first(), categories = categories, summaryPageCount = 20)
+ val api = mock<StalkerProvider>()
+ whenever(api.isWildcardCategory(org.mockito.kotlin.any(), org.mockito.kotlin.any())).thenReturn(false)
+ StalkerIncrementalIndexExecutor(operations).prepareCatalog(
+ LegacyProvider(91L, "Portal", ProviderType.STALKER_PORTAL, serverUrl = "https://portal.invalid"), api, ContentType.MOVIE, true, null)
+ assertThat(operations.summaryFetches).containsExactlyElementsIn(categories.map { it.categoryId to 1 })
+ assertThat(operations.indexedMovies).hasSize(24)
+ categories.forEach { assertThat(operations.categoryHydration(it.categoryId)?.lastSuccessfulPage).isEqualTo(1) }
+ }
+
+ @Test
+ fun backgroundContinuationYieldsForPlaybackAndResumesItsPersistedPage() = runTest {
+ val category = CategoryEntity(categoryId = 10L, name = "Category", type = ContentType.MOVIE, providerId = 91L)
+ val operations = WildcardIndexOperations(category, summaryPageCount = 5)
+ val api = mock<StalkerProvider>()
+ whenever(api.isWildcardCategory(org.mockito.kotlin.any(), org.mockito.kotlin.any())).thenReturn(false)
+ val executor = StalkerIncrementalIndexExecutor(operations)
+ val provider = LegacyProvider(91L, "Portal", ProviderType.STALKER_PORTAL, serverUrl = "https://portal.invalid")
+ executor.processCategoryHeads(provider, api, ContentType.MOVIE, null)
+ com.streamvault.data.remote.stalker.StalkerTrafficCoordinator.notePlaybackStarted(91L)
+ try {
+ executor.processSummary(provider, api, ContentType.MOVIE, 1, null)
+ assertThat(operations.committedPages).containsExactly(1)
+ } finally { com.streamvault.data.remote.stalker.StalkerTrafficCoordinator.notePlaybackStopped(91L) }
+ executor.processSummary(provider, api, ContentType.MOVIE, 1, null)
+ assertThat(operations.committedPages).containsExactlyElementsIn(1..5).inOrder()
+ }
+
+ @Test
+ fun smallCatalogFinishesDuringSetup() = runTest {
+ val category = CategoryEntity(categoryId = 10L, name = "Category", type = ContentType.MOVIE, providerId = 91L)
+ val operations = WildcardIndexOperations(category, summaryPageCount = 5)
+ val api = mock<StalkerProvider>()
+ whenever(api.isWildcardCategory(org.mockito.kotlin.any(), org.mockito.kotlin.any())).thenReturn(false)
+ StalkerIncrementalIndexExecutor(operations).prepareCatalog(
+ LegacyProvider(91L, "Portal", ProviderType.STALKER_PORTAL, serverUrl = "https://portal.invalid"), api, ContentType.MOVIE, true, null)
+ assertThat(operations.committedPages).containsExactlyElementsIn(1..5).inOrder()
+ assertThat(operations.categoryHydration(10L)?.isComplete).isTrue()
+ }
+
+ @Test
+ fun backgroundPageWindowsWaitForTheirContiguousPrefixBeforeStartingTheNextWindow() = runTest {
+ val category = CategoryEntity(categoryId = 10L, name = "Category", type = ContentType.MOVIE, providerId = 91L)
+ val operations = WildcardIndexOperations(category, summaryPageCount = 40)
+ val api = mock<StalkerProvider>()
+ whenever(api.isWildcardCategory(org.mockito.kotlin.any(), org.mockito.kotlin.any())).thenReturn(false)
+ StalkerIncrementalIndexExecutor(operations).processSummary(
+ LegacyProvider(91L, "Portal", ProviderType.STALKER_PORTAL, serverUrl = "https://portal.invalid"), api, ContentType.MOVIE, 1, null)
+ assertThat(operations.summaryCompletions.indexOf(10)).isGreaterThan(operations.summaryCompletions.indexOf(2))
+ assertThat(operations.committedPages).containsExactlyElementsIn(1..40).inOrder()
+ }
+ @Test
+ fun soleWildcardCategoryUsesOneBasedPagesAndCommitsInOrder() = runTest {
val wildcard = CategoryEntity(categoryId = -9L, name = "All", type = ContentType.MOVIE, providerId = 91L)
val operations = WildcardIndexOperations(wildcard)
val api = mock<StalkerProvider>()
whenever(api.isWildcardCategory(org.mockito.kotlin.any(), org.mockito.kotlin.any())).thenReturn(false)
whenever(api.isWildcardCategory(ContentType.MOVIE, wildcard.categoryId)).thenReturn(true)
- StalkerIncrementalIndexExecutor(operations, configuredWildcardPageConcurrency = 2, adaptiveCategoryPaging = false)
+ StalkerIncrementalIndexExecutor(operations, configuredWildcardPageConcurrency = 2)
.processSummary(
provider = LegacyProvider(
id = 91L,
@@ -43,21 +124,21 @@ class StalkerIncrementalIndexExecutorTest {
maxPages = 2
)
- assertThat(operations.maxConcurrentFetches).isEqualTo(2)
- assertThat(operations.completedFetchPages).containsExactly(2, 1).inOrder()
+ assertThat(operations.summaryFetches).containsExactly(-9L to 1, -9L to 2).inOrder()
+ assertThat(operations.completedFetchPages).isEmpty()
assertThat(operations.committedPages).containsExactly(1, 2).inOrder()
assertThat(operations.hydration?.lastSuccessfulPage).isEqualTo(2)
- assertThat(operations.indexedMovies.map(Movie::id)).containsExactly(1L, 2L).inOrder()
+ assertThat(operations.indexedMovies.map(Movie::id)).containsExactly(-899L, -898L).inOrder()
}
@Test
fun failedPageDoesNotCommitLaterPageAndRetryResumesFromTheGap() = runTest {
val wildcard = CategoryEntity(categoryId = -9L, name = "All", type = ContentType.MOVIE, providerId = 91L)
- val operations = WildcardIndexOperations(wildcard, failPageOneOnce = true)
+ val operations = WildcardIndexOperations(wildcard, summaryFailurePageOnce = 1, summaryFailuresRemaining = 3)
val api = mock<StalkerProvider>()
whenever(api.isWildcardCategory(org.mockito.kotlin.any(), org.mockito.kotlin.any())).thenReturn(false)
whenever(api.isWildcardCategory(ContentType.MOVIE, wildcard.categoryId)).thenReturn(true)
- val executor = StalkerIncrementalIndexExecutor(operations, configuredWildcardPageConcurrency = 2, adaptiveCategoryPaging = false)
+ val executor = StalkerIncrementalIndexExecutor(operations, configuredWildcardPageConcurrency = 2)
val provider = LegacyProvider(
id = 91L,
name = "Portal",
@@ -77,7 +158,7 @@ class StalkerIncrementalIndexExecutorTest {
assertThat(operations.committedPages).containsExactly(1, 2).inOrder()
assertThat(operations.hydration?.lastSuccessfulPage).isEqualTo(2)
- assertThat(operations.indexedMovies.map(Movie::id)).containsExactly(1L, 2L).inOrder()
+ assertThat(operations.indexedMovies.map(Movie::id)).containsExactly(-899L, -898L).inOrder()
}
@Test
@@ -94,7 +175,7 @@ class StalkerIncrementalIndexExecutorTest {
whenever(api.isWildcardCategory(org.mockito.kotlin.any(), org.mockito.kotlin.any())).thenReturn(false)
whenever(api.isWildcardCategory(ContentType.MOVIE, wildcard.categoryId)).thenReturn(true)
- StalkerIncrementalIndexExecutor(operations, configuredWildcardPageConcurrency = 2, adaptiveCategoryPaging = false)
+ StalkerIncrementalIndexExecutor(operations, configuredWildcardPageConcurrency = 2)
.processCategoryHeads(
provider = LegacyProvider(
id = 91L,
@@ -110,7 +191,7 @@ class StalkerIncrementalIndexExecutorTest {
assertThat(operations.summaryFetches).containsExactly(10L to 1, 20L to 1).inOrder()
assertThat(operations.maxConcurrentFetches).isEqualTo(2)
- assertThat(operations.completedFetchPages).isEmpty()
+ assertThat(operations.completedFetchPages).containsExactly(1)
assertThat(operations.categoryHydration(10L)?.lastSuccessfulPage).isEqualTo(1)
assertThat(operations.categoryHydration(20L)?.lastSuccessfulPage).isEqualTo(1)
assertThat(operations.indexedMovies).hasSize(2)
@@ -125,7 +206,7 @@ class StalkerIncrementalIndexExecutorTest {
val api = mock<StalkerProvider>()
whenever(api.isWildcardCategory(org.mockito.kotlin.any(), org.mockito.kotlin.any())).thenReturn(false)
whenever(api.isWildcardCategory(ContentType.MOVIE, wildcard.categoryId)).thenReturn(true)
- val executor = StalkerIncrementalIndexExecutor(operations, 8, adaptiveCategoryPaging = true)
+ val executor = StalkerIncrementalIndexExecutor(operations, 8)
val provider = LegacyProvider(91L, "Portal", ProviderType.STALKER_PORTAL,
serverUrl = "https://portal.invalid", catalogLayout = CatalogLayout.SPLIT)
@@ -133,9 +214,9 @@ class StalkerIncrementalIndexExecutorTest {
assertThat(operations.completedFetchPages).containsExactly(1)
assertThat(operations.summaryFetches).containsExactlyElementsIn(categories.map { it.categoryId to 1 })
- assertThat(operations.summaryFetchCountAtFirstCommit).isEqualTo(8)
+ assertThat(operations.summaryFetchCountAtFirstCommit).isAtLeast(8)
assertThat(operations.maxConcurrentFetches).isEqualTo(8)
- assertThat(operations.metadataPublications.any { (state, rows) -> state == "RUNNING" && rows in 2..24 }).isTrue()
+ assertThat(operations.metadataPublications.any { (state, rows) -> state == "RUNNING" && rows in 1..24 }).isTrue()
categories.forEach { assertThat(operations.categoryHydration(it.categoryId)?.lastSuccessfulPage).isEqualTo(1) }
operations.summaryFetches.clear()
executor.processCategoryHeads(provider, api, ContentType.MOVIE, null)
@@ -149,7 +230,7 @@ class StalkerIncrementalIndexExecutorTest {
val operations = WildcardIndexOperations(category, summaryPageCount = 9)
val api = mock<StalkerProvider>()
whenever(api.isWildcardCategory(org.mockito.kotlin.any(), org.mockito.kotlin.any())).thenReturn(false)
- val executor = StalkerIncrementalIndexExecutor(operations, 8, adaptiveCategoryPaging = true)
+ val executor = StalkerIncrementalIndexExecutor(operations, 8)
val provider = LegacyProvider(91L, "Portal", ProviderType.STALKER_PORTAL, serverUrl = "https://portal.invalid")
executor.processCategoryHeads(provider, api, ContentType.MOVIE, null)
operations.committedPages.clear()
@@ -167,10 +248,10 @@ class StalkerIncrementalIndexExecutorTest {
fun adaptiveCategoryWindowNeverCheckpointsPastAFailedPage() = runTest {
val category = CategoryEntity(categoryId = 10L, name = "Action", type = ContentType.MOVIE, providerId = 91L)
val operations = WildcardIndexOperations(category, summaryPageCount = 9,
- summaryFailurePageOnce = 4, summaryFailuresRemaining = 2)
+ summaryFailurePageOnce = 4, summaryFailuresRemaining = 3)
val api = mock<StalkerProvider>()
whenever(api.isWildcardCategory(org.mockito.kotlin.any(), org.mockito.kotlin.any())).thenReturn(false)
- val executor = StalkerIncrementalIndexExecutor(operations, 8, adaptiveCategoryPaging = true)
+ val executor = StalkerIncrementalIndexExecutor(operations, 8)
val provider = LegacyProvider(91L, "Portal", ProviderType.STALKER_PORTAL, serverUrl = "https://portal.invalid")
executor.processCategoryHeads(provider, api, ContentType.MOVIE, null)
operations.committedPages.clear()
@@ -188,10 +269,12 @@ class StalkerIncrementalIndexExecutorTest {
private var failPageOneOnce: Boolean = false,
private val categories: List<CategoryEntity> = listOf(wildcard),
categoryConcurrency: Int = 2,
- private val singlePageProbe: Boolean = false,
+ private val singlePageProbe: Boolean = true,
private val summaryPageCount: Int = 2,
private var summaryFailurePageOnce: Int? = null,
- private var summaryFailuresRemaining: Int = 1
+ private var summaryFailuresRemaining: Int = 1,
+ private val mixedPage: Boolean = false,
+ private val storedCategoryCounts: Map<Long, Int> = emptyMap()
) : StalkerIncrementalIndexOperations {
override val runtimeProfile = CatalogSyncRuntimeProfile(
tier = DeviceSyncTier.HIGH,
@@ -223,6 +306,9 @@ class StalkerIncrementalIndexExecutorTest {
var summaryFetchCountAtFirstCommit: Int? = null
val summaryCompletions = mutableListOf<Int>()
val indexedMovies = mutableListOf<Movie>()
+ val indexedDerivedSeries = mutableListOf<com.streamvault.domain.model.Series>()
+ val pageReceipts = mutableListOf<Pair<Long, Int>>()
+ val preservedCategories = mutableListOf<Long>()
val metadataPublications = mutableListOf<Pair<String, Int>>()
var activeFetches = 0
private set
@@ -237,8 +323,9 @@ class StalkerIncrementalIndexExecutorTest {
contentType: ContentType,
categories: List<CategoryEntity>,
api: StalkerProvider
- ) = categories.filterNot { category ->
- category.categoryId == wildcard.categoryId && categories.any { it.categoryId != wildcard.categoryId }
+ ): List<CategoryEntity> {
+ val concrete = categories.filterNot { api.isWildcardCategory(it.type, it.categoryId) }
+ return concrete.ifEmpty { categories }
}
override suspend fun getJob(providerId: Long, contentType: ContentType): StalkerIndexJobEntity? = null
@@ -252,7 +339,13 @@ class StalkerIncrementalIndexExecutorTest {
override suspend fun currentIndexedRowCount(providerId: Long, contentType: ContentType): Int = indexedMovies.size
- override suspend fun categoriesWithLocalRows(providerId: Long, contentType: ContentType): Map<Long, Int> = emptyMap()
+ override suspend fun categoriesWithLocalRows(providerId: Long, contentType: ContentType): Map<Long, Int> = storedCategoryCounts
+
+ override suspend fun preserveCategoryRows(providerId: Long, type: ContentType, categoryId: Long) { preservedCategories += categoryId }
+
+ override suspend fun commitCatalogPage(provider: LegacyProvider, categoryId: Long, page: StalkerPagedResult<out Any>) {
+ pageReceipts += categoryId to page.page
+ }
override suspend fun pruneStaleRows(providerId: Long, contentType: ContentType): Int = 0
@@ -282,7 +375,12 @@ class StalkerIncrementalIndexExecutorTest {
}
Result.success(
StalkerPagedResult(
- items = listOf(Movie(id = categoryId * 100 + page, name = "Category $categoryId", streamId = categoryId * 100 + page)),
+ items = if (mixedPage) listOf(
+ com.streamvault.data.remote.stalker.StalkerVodCatalogItem("movie",
+ com.streamvault.domain.model.VodCatalogItem.MovieItem(Movie(id = 100, name = "Movie", streamId = 100))),
+ com.streamvault.data.remote.stalker.StalkerVodCatalogItem("series",
+ com.streamvault.domain.model.VodCatalogItem.SeriesItem(com.streamvault.domain.model.Series(id = 200, name = "Series", seriesId = 200)))
+ ) else listOf(Movie(id = categoryId * 100 + page, name = "Category $categoryId", streamId = categoryId * 100 + page)),
page = page,
totalPages = summaryPageCount,
pageSize = 1,
@@ -438,7 +536,7 @@ class StalkerIncrementalIndexExecutorTest {
override suspend fun upsertSeriesSummaryBatch(providerId: Long, series: List<com.streamvault.domain.model.Series>, indexedAt: Long) = Unit
- override suspend fun upsertVodDerivedSeriesSummaryBatch(providerId: Long, series: List<com.streamvault.domain.model.Series>, indexedAt: Long) = Unit
+ override suspend fun upsertVodDerivedSeriesSummaryBatch(providerId: Long, series: List<com.streamvault.domain.model.Series>, indexedAt: Long) { indexedDerivedSeries += series }
override suspend fun recordRequestFailure(providerId: Long, error: Throwable?) = Unit
diff --git a/data/src/test/java/com/streamvault/data/sync/SyncManagerTest.kt b/data/src/test/java/com/streamvault/data/sync/SyncManagerTest.kt
index 369b9a58..67949ef7 100644
--- a/data/src/test/java/com/streamvault/data/sync/SyncManagerTest.kt
+++ b/data/src/test/java/com/streamvault/data/sync/SyncManagerTest.kt
@@ -71,6 +71,7 @@ import com.streamvault.data.remote.stalker.StalkerRemoteIdentityResolver
import com.streamvault.data.remote.stalker.stalkerStableHashId
import com.streamvault.data.remote.stalker.StalkerSession
import com.streamvault.data.remote.stalker.StalkerApiService
+import com.streamvault.data.remote.stalker.delegateSortedPagingToBasicStubs
import com.streamvault.data.remote.stalker.StalkerAdvancedOptions
import com.streamvault.data.remote.stalker.StalkerAdvancedOptionsCodec
import com.streamvault.data.remote.stalker.StalkerDeviceProfile
@@ -363,6 +364,9 @@ class SyncManagerTest {
org.mockito.kotlin.whenever(preferencesRepo.xtreamBase64TextCompatibility).thenReturn(flowOf(false))
org.mockito.kotlin.whenever(preferencesRepo.getHiddenCategoryIds(any(), any())).thenReturn(flowOf(emptySet()))
runBlocking {
+ stalkerApiService.delegateSortedPagingToBasicStubs()
+ org.mockito.kotlin.whenever(movieDao.getCategoryCounts(any())).thenReturn(flowOf(emptyList()))
+ org.mockito.kotlin.whenever(seriesDao.getCategoryCounts(any())).thenReturn(flowOf(emptyList()))
org.mockito.kotlin.whenever(
stalkerLiveCategoryRetryDao.getForProvider(any(), any())
).thenReturn(emptyList())
@@ -452,7 +456,8 @@ class SyncManagerTest {
providerEntity: Provider? = null,
readinessTracker: StalkerReadinessTracker = StalkerReadinessTracker(),
portalStateStore: com.streamvault.data.remote.stalker.StalkerPortalStateStore = mock(),
- commitFence: ProviderWorkflowCommitFence = ProviderWorkflowCommitFence()
+ commitFence: ProviderWorkflowCommitFence = ProviderWorkflowCommitFence(),
+ workLocks: ProviderWorkLockRegistry = ProviderWorkLockRegistry()
): SyncManager {
val configuredProvider = if (providerPresent) providerEntity ?: sampleProvider(providerType) else null
// Keep the existing sync fixtures on the streaming fallback contract while their
@@ -618,7 +623,7 @@ class SyncManagerTest {
override suspend fun updateCatalogLayout(providerId: Long, layout: CatalogLayout, detectionVersion: Int) = Unit
},
- providerWorkLocks = ProviderWorkLockRegistry(),
+ providerWorkLocks = workLocks,
providerSyncLocks = ProviderSyncLockRegistry(),
stalkerPlaybackCapabilityCache = com.streamvault.data.provider.StalkerPlaybackCapabilityCache(typedProviderClientFactory),
providerSyncWorkScheduler = workScheduler
@@ -2190,7 +2195,7 @@ class SyncManagerTest {
}
@Test
- fun `processQueuedStalkerIndexJobs prefers wildcard for learned support and backfills excluded categories`() = runTest {
+ fun `processQueuedStalkerIndexJobs accepts a whole wildcard dump without another category crawl`() = runTest {
val providerEntity = sampleProvider(ProviderType.STALKER_PORTAL).copy(
serverUrl = "http://example.com",
username = "",
@@ -2342,7 +2347,7 @@ class SyncManagerTest {
assertThat(result.isSuccess).isTrue()
assertThat(hydrationByCategory[wildcardCategoryId]?.lastError).isNull()
verify(stalkerApiService).getVodStreamsPage(any(), any(), eq("*"), eq(1), anyOrNull(), eq("added"))
- verify(stalkerApiService).getVodStreamsPage(any(), any(), eq("9"), eq(1))
+ verify(stalkerApiService, org.mockito.kotlin.never()).getVodStreamsPage(any(), any(), eq("9"), eq(1))
verify(portalStateStore).recordWildcard(eq(1L), eq(ContentType.MOVIE), eq(true), any(), anyOrNull())
verify(stalkerApiService, org.mockito.kotlin.never()).getVodStreamsPage(any(), any(), eq("5"), any())
verify(xtreamContentIndexDao, atLeastOnce()).pruneStaleLocalContentRows(1L, ContentType.MOVIE.name)
@@ -2981,10 +2986,7 @@ class SyncManagerTest {
assertThat(failure).isInstanceOf(ProviderWorkflowSupersededException::class.java)
verify(stalkerApiService).getVodStreamsPage(any(), any(), eq("5"), eq(1))
verify(movieDao, org.mockito.kotlin.never()).insertAll(any())
- val attemptedCheckpoint = argumentCaptor<MovieCategoryHydrationEntity>()
- verify(movieCategoryHydrationDao).upsert(attemptedCheckpoint.capture())
- assertThat(attemptedCheckpoint.firstValue.lastStatus).isEqualTo("RUNNING")
- assertThat(attemptedCheckpoint.firstValue.lastSuccessfulPage).isEqualTo(0)
+ verify(movieCategoryHydrationDao, org.mockito.kotlin.never()).upsert(any())
verify(xtreamContentIndexDao, org.mockito.kotlin.never())
.upsertAll(any())
}
@@ -3536,7 +3538,7 @@ class SyncManagerTest {
assertThat(readinessTracker.current(1L)?.authenticatedAt).isNotNull()
assertThat(readinessTracker.current(1L)?.liveReadyAt).isNotNull()
assertThat(readinessTracker.current(1L)?.categoriesReadyAt).isNotNull()
- verify(xtreamIndexJobDao, org.mockito.kotlin.times(0)).upsert(any())
+ verify(xtreamIndexJobDao, atLeastOnce()).upsert(any())
verify(stalkerApiService).getVodCategories(any(), any())
verify(stalkerApiService).getSeriesCategories(any(), any())
verify(stalkerApiService).streamLiveStreams(any(), any(), any())
@@ -3862,7 +3864,7 @@ class SyncManagerTest {
assertThat(result).isInstanceOf(Result.Success::class.java)
verify(stalkerApiService).getVodCategories(any(), any())
verify(stalkerApiService).getSeriesCategories(any(), any())
- verify(xtreamIndexJobDao, org.mockito.kotlin.times(0)).upsert(any())
+ verify(xtreamIndexJobDao, atLeastOnce()).upsert(any())
}
@Test
@@ -3915,9 +3917,33 @@ class SyncManagerTest {
it.type == ContentType.SERIES && it.name == "All Series" &&
it.categoryId == stalkerSyntheticCategoryId(1L, ContentType.SERIES, "*")
}).isTrue()
- verify(xtreamIndexJobDao, org.mockito.kotlin.times(0)).upsert(any())
- verify(stalkerApiService, org.mockito.kotlin.times(0)).getVodStreamsPage(any(), any(), anyOrNull(), any())
- verify(stalkerApiService, org.mockito.kotlin.times(0)).getSeriesPage(any(), any(), anyOrNull(), any())
+ verify(xtreamIndexJobDao, atLeastOnce()).upsert(any())
+ verify(stalkerApiService, org.mockito.kotlin.never()).getVodStreamsPage(any(), any(), anyOrNull(), any())
+ verify(stalkerApiService, org.mockito.kotlin.never()).getSeriesPage(any(), any(), anyOrNull(), any())
+ }
+
+ @Test
+ fun stalker_startup_recovers_empty_guide_alongside_pending_catalog() = runTest {
+ for (mode in listOf(ProviderEpgSyncMode.UPFRONT, ProviderEpgSyncMode.BACKGROUND)) {
+ val provider = sampleProvider(ProviderType.STALKER_PORTAL).copy(epgSyncMode = mode)
+ val manager = buildManager(providerType = ProviderType.STALKER_PORTAL, providerEntity = provider)
+ org.mockito.kotlin.whenever(xtreamIndexJobDao.get(1L, ContentType.MOVIE.name)).thenReturn(
+ XtreamIndexJobEntity(providerId = 1L, section = ContentType.MOVIE.name, state = "QUEUED"))
+ org.mockito.kotlin.whenever(programDao.countByProvider(1L)).thenReturn(0)
+ manager.reconcileStalkerIndexWorkAtStartup()
+ }
+ verify(workScheduler, org.mockito.kotlin.times(2)).scheduleBackgroundEpg(1L, true)
+ verify(workScheduler, org.mockito.kotlin.times(2)).scheduleStalkerIndex(1L, false, false, 0L, false)
+ }
+
+ @Test
+ fun stalker_startup_preserves_skipped_guide_with_pending_catalog() = runTest {
+ val provider = sampleProvider(ProviderType.STALKER_PORTAL).copy(epgSyncMode = ProviderEpgSyncMode.SKIP)
+ val manager = buildManager(providerType = ProviderType.STALKER_PORTAL, providerEntity = provider)
+ org.mockito.kotlin.whenever(xtreamIndexJobDao.get(1L, ContentType.MOVIE.name)).thenReturn(
+ XtreamIndexJobEntity(providerId = 1L, section = ContentType.MOVIE.name, state = "QUEUED"))
+ manager.reconcileStalkerIndexWorkAtStartup()
+ verify(workScheduler, org.mockito.kotlin.never()).scheduleBackgroundEpg(any(), any())
}
@Test
@@ -3965,6 +3991,10 @@ class SyncManagerTest {
val result = manager.sync(providerId = 1L, force = false)
assertThat(result).isInstanceOf(Result.Success::class.java)
+ assertThat(manager.resumeStalkerBootstrap(1L)).isInstanceOf(Result.Success::class.java)
+ verify(workScheduler, atLeastOnce()).scheduleStalkerIndex(1L, false, false, 0L, false)
+ verify(workScheduler, atLeastOnce()).scheduleBackgroundEpg(1L, false)
+ verify(stalkerApiService, org.mockito.kotlin.never()).streamEpg(any(), any(), any(), any(), any())
verify(stalkerApiService, org.mockito.kotlin.times(0)).getVodStreamsPage(any(), any(), anyOrNull(), any())
verify(stalkerApiService, org.mockito.kotlin.times(0)).getSeriesPage(any(), any(), anyOrNull(), any())
}
@@ -4470,7 +4500,7 @@ class SyncManagerTest {
}
@Test
- fun sync_stalker_upfront_epg_imports_native_portal_guide_before_returning() = runTest {
+ fun sync_stalker_epg_imports_guide_while_catalog_provider_lock_is_held() = runTest {
val providerEntity = sampleProvider(ProviderType.STALKER_PORTAL).copy(
serverUrl = "http://example.com",
username = "",
@@ -4479,7 +4509,9 @@ class SyncManagerTest {
epgSyncMode = ProviderEpgSyncMode.UPFRONT,
epgUrl = ""
)
- val manager = buildManager(providerType = ProviderType.STALKER_PORTAL, providerEntity = providerEntity)
+ val workLocks = ProviderWorkLockRegistry()
+ val manager = buildManager(providerType = ProviderType.STALKER_PORTAL, providerEntity = providerEntity,
+ workLocks = workLocks)
org.mockito.kotlin.whenever(stalkerApiService.authenticate(any())).thenReturn(
Result.success(
@@ -4534,12 +4566,24 @@ class SyncManagerTest {
assertThat(result).isInstanceOf(Result.Success::class.java)
verify(stalkerApiService).streamLiveStreams(any(), any(), any())
verify(stalkerApiService, org.mockito.kotlin.times(0)).getLiveStreams(any(), any(), eq("10"))
+ verify(workScheduler).scheduleBackgroundEpg(1L, false)
+ verify(stalkerApiService, org.mockito.kotlin.never()).streamEpg(any(), any(), any(), any(), any())
+ val catalogEntered = CompletableDeferred<Unit>()
+ val releaseCatalog = CompletableDeferred<Unit>()
+ val catalog = async {
+ workLocks.withProviderLock(1L) { catalogEntered.complete(Unit); releaseCatalog.await() }
+ }
+ catalogEntered.await()
+ try {
+ assertThat(withTimeout(1_000) { manager.syncEpg(1L, force = true) })
+ .isInstanceOf(Result.Success::class.java)
+ } finally { releaseCatalog.complete(Unit); catalog.await() }
verify(stalkerApiService).streamEpg(any(), any(), eq("100"), any(), any())
verify(programDao, atLeastOnce()).insertAll(any())
}
@Test
- fun sync_stalker_upfront_epg_imports_native_portal_guide_in_batches() = runTest {
+ fun syncEpg_stalker_imports_native_portal_guide_in_batches_after_catalog_handoff() = runTest {
val providerEntity = sampleProvider(ProviderType.STALKER_PORTAL).copy(
serverUrl = "http://example.com",
username = "",
@@ -4601,6 +4645,7 @@ class SyncManagerTest {
val result = manager.sync(providerId = 1L, force = true)
assertThat(result).isInstanceOf(Result.Success::class.java)
+ assertThat(manager.syncEpg(1L, force = true)).isInstanceOf(Result.Success::class.java)
verify(programDao, atLeastOnce()).insertAll(any())
}
@@ -4765,7 +4810,7 @@ class SyncManagerTest {
}
@Test
- fun retrySection_epg_stalker_uses_bulk_first_and_only_falls_back_for_uncovered_keys() = runTest {
+ fun retrySection_epg_stalker_finishes_after_usable_bulk_without_crawling_uncovered_channels() = runTest {
val providerEntity = sampleProvider(ProviderType.STALKER_PORTAL).copy(
serverUrl = "http://example.com",
username = "",
@@ -4823,7 +4868,7 @@ class SyncManagerTest {
assertThat(result).isInstanceOf(Result.Success::class.java)
verify(stalkerApiService, org.mockito.kotlin.times(1)).streamBulkEpg(any(), any(), eq(6), any())
verify(stalkerApiService, org.mockito.kotlin.times(0)).streamEpg(any(), any(), eq("shared-guide-id"), any(), any())
- verify(stalkerApiService, org.mockito.kotlin.times(1)).streamEpg(any(), any(), eq("sports-guide-id"), any(), any())
+ verify(stalkerApiService, org.mockito.kotlin.never()).streamEpg(any(), any(), any(), any(), any())
}
@Test
diff --git a/data/src/test/java/com/streamvault/data/sync/SyncStatusPublicationCoordinatorTest.kt b/data/src/test/java/com/streamvault/data/sync/SyncStatusPublicationCoordinatorTest.kt
index 204044c2..3fa6141a 100644
--- a/data/src/test/java/com/streamvault/data/sync/SyncStatusPublicationCoordinatorTest.kt
+++ b/data/src/test/java/com/streamvault/data/sync/SyncStatusPublicationCoordinatorTest.kt
@@ -9,9 +9,45 @@ import com.streamvault.domain.repository.SyncMetadataRepository
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.launch
import org.junit.Test
class SyncStatusPublicationCoordinatorTest {
+ @Test
+ fun `concurrent guide and catalog metadata preserve both counts`() = runTest {
+ val repository = FakeSyncMetadataRepository(SyncMetadata(providerId = 7L))
+ val slowRepository = object : SyncMetadataRepository by repository {
+ override suspend fun getMetadata(providerId: Long): SyncMetadata? {
+ val value = repository.getMetadata(providerId)
+ kotlinx.coroutines.delay(1)
+ return value
+ }
+ }
+ val mutex = kotlinx.coroutines.sync.Mutex()
+ val transactions = object : com.streamvault.data.local.DatabaseTransactionRunner {
+ override suspend fun <T> inTransaction(block: suspend () -> T): T {
+ mutex.lock()
+ return try { block() } finally { mutex.unlock() }
+ }
+ }
+ val coordinator = SyncStatusPublicationCoordinator(slowRepository, SyncProgressBus(), transactionRunner = transactions)
+ kotlinx.coroutines.coroutineScope {
+ launch {
+ coordinator.updateSummaryMetadata(7L, ContentType.MOVIE, 500, "RUNNING", 100, VodSyncMode.PAGED)
+ }
+ launch {
+ transactions.inTransaction {
+ val metadata = requireNotNull(slowRepository.getMetadata(7L))
+ slowRepository.updateMetadata(metadata.copy(epgCount = 200, lastEpgSuccess = 100))
+ }
+ }
+ }
+ val metadata = requireNotNull(repository.getMetadata(7L))
+ assertThat(metadata.movieCount).isEqualTo(500)
+ assertThat(metadata.epgCount).isEqualTo(200)
+ assertThat(metadata.lastEpgSuccess).isEqualTo(100)
+ }
+
@Test
fun `partial movie publication preserves the known catalog count and marks it stale`() = runTest {
val repository = FakeSyncMetadataRepository(
diff --git a/domain/src/main/java/com/streamvault/domain/model/Provider.kt b/domain/src/main/java/com/streamvault/domain/model/Provider.kt
index fd04cfef..7f5afe72 100644
--- a/domain/src/main/java/com/streamvault/domain/model/Provider.kt
+++ b/domain/src/main/java/com/streamvault/domain/model/Provider.kt
@@ -109,6 +109,12 @@ enum class StalkerCatalogMode {
BACKGROUND_INDEX
}
+enum class StalkerCatalogLoadOrder {
+ PARALLEL,
+ MOVIES_FIRST,
+ SERIES_FIRST
+}
+
enum class StalkerReadiness {
AUTHENTICATING,
LIVE_READY,
diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MoviesViewModel.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MoviesViewModel.kt
index caa5a94e..6ac72fe2 100644
--- a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MoviesViewModel.kt
+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/movies/MoviesViewModel.kt
@@ -506,6 +506,11 @@ class MoviesViewModel @Inject constructor(
SelectedMovieCategoryRequest(
providerId = provider.id,
selectedCategory = selection.selectedCategory,
+ selectedProviderCategoryItemCount = if (provider.type == ProviderType.STALKER_PORTAL) {
+ dependencies.providerCategories.firstOrNull { it.name == selection.selectedCategory }?.id
+ ?.let { dependencies.providerCategoryCounts[it] ?: dependencies.providerCategoryCounts.values.sum() }
+ ?: dependencies.providerCategoryCounts.values.sum()
+ } else 0,
loadLimit = selection.loadLimit,
query = selection.query,
filterType = selection.filterType,
@@ -1641,6 +1646,7 @@ private data class MovieCategorySelectionDependencies(
private data class SelectedMovieCategoryRequest(
val providerId: Long,
val selectedCategory: String?,
+ val selectedProviderCategoryItemCount: Int,
val loadLimit: Int,
val query: String,
val filterType: LibraryFilterType,
diff --git a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesViewModel.kt b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesViewModel.kt
index ee04451d..39d52f59 100644
--- a/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesViewModel.kt
+++ b/feature/catalog/src/main/java/com/streamvault/feature/catalog/presentation/series/SeriesViewModel.kt
@@ -454,7 +454,9 @@ class SeriesViewModel @Inject constructor(
seriesRepository.getCategories(provider.id),
playbackHistoryRepository.getRecentlyWatchedByProvider(provider.id, limit = 100),
preferencesRepository.getHiddenCategoryIds(provider.id, ContentType.SERIES),
- preferencesRepository.getCategorySortMode(provider.id, ContentType.SERIES)
+ preferencesRepository.getCategorySortMode(provider.id, ContentType.SERIES),
+ if (provider.type == ProviderType.STALKER_PORTAL) seriesRepository.getCategoryItemCounts(provider.id)
+ else flowOf(emptyMap<Long, Int>())
) { values ->
val allFavorites = values[0] as List<com.streamvault.domain.model.Favorite>
val customCategories = values[1] as List<Category>
@@ -463,6 +465,7 @@ class SeriesViewModel @Inject constructor(
val hiddenCategoryIds = values[4] as Set<Long>
val sortMode = values[5] as CategorySortMode
SeriesCategorySelectionDependencies(
+ providerCategoryCounts = values[6] as Map<Long, Int>,
allFavorites = allFavorites,
customCategories = customCategories,
providerCategories = applyProviderCategoryDisplayPreferences(
@@ -502,6 +505,11 @@ class SeriesViewModel @Inject constructor(
SelectedSeriesCategoryRequest(
providerId = provider.id,
selectedCategory = selection.selectedCategory,
+ selectedProviderCategoryItemCount = if (provider.type == ProviderType.STALKER_PORTAL) {
+ dependencies.providerCategories.firstOrNull { it.name == selection.selectedCategory }?.id
+ ?.let { dependencies.providerCategoryCounts[it] ?: dependencies.providerCategoryCounts.values.sum() }
+ ?: dependencies.providerCategoryCounts.values.sum()
+ } else 0,
loadLimit = selection.loadLimit,
query = selection.query,
filterType = selection.filterType,
@@ -1636,6 +1644,7 @@ private data class SeriesCategorySelectionDependencies(
val history: List<PlaybackHistory>,
val customCategories: List<Category>,
val providerCategories: List<Category>,
+ val providerCategoryCounts: Map<Long, Int>,
val hiddenCategoryIds: Set<Long>,
val traktAccountState: TraktAccountState = TraktAccountState(),
val traktWatchlistState: TraktWatchlistState = TraktWatchlistState(),
@@ -1645,6 +1654,7 @@ private data class SeriesCategorySelectionDependencies(
private data class SelectedSeriesCategoryRequest(
val providerId: Long,
val selectedCategory: String?,
+ val selectedProviderCategoryItemCount: Int,
val loadLimit: Int,
val query: String,
val filterType: LibraryFilterType,
diff --git a/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderSetupAdvancedOptions.kt b/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderSetupAdvancedOptions.kt
index 4fd5b324..7f97dd8f 100644
--- a/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderSetupAdvancedOptions.kt
+++ b/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderSetupAdvancedOptions.kt
@@ -35,6 +35,7 @@ import com.streamvault.domain.model.ProviderEpgSyncMode
import com.streamvault.domain.model.ProviderXtreamLiveSyncMode
import com.streamvault.domain.model.StalkerAuthMode
import com.streamvault.domain.model.StalkerCatalogMode
+import com.streamvault.domain.model.StalkerCatalogLoadOrder
@Composable
internal fun AdvancedProviderOptionsSection(options: ProviderAdvancedOptions) {
@@ -48,6 +49,7 @@ internal fun AdvancedProviderOptionsSection(options: ProviderAdvancedOptions) {
onToggleM3uVodClassification = options.onToggleM3uVodClassification,
onSelectEpgSyncMode = options.onSelectEpgSyncMode,
onSelectStalkerCatalogMode = options.onSelectStalkerCatalogMode,
+ onSelectStalkerCatalogLoadOrder = options.onSelectStalkerCatalogLoadOrder,
onSelectXtreamLiveSyncMode = options.onSelectXtreamLiveSyncMode,
onSelectGuideSourcePolicy = options.onSelectGuideSourcePolicy,
onSelectChannelLogoSourcePolicy = options.onSelectChannelLogoSourcePolicy,
@@ -106,6 +108,7 @@ internal fun AdvancedProviderOptionsSection(
onToggleM3uVodClassification: () -> Unit,
onSelectEpgSyncMode: (ProviderEpgSyncMode) -> Unit,
onSelectStalkerCatalogMode: (StalkerCatalogMode) -> Unit,
+ onSelectStalkerCatalogLoadOrder: (StalkerCatalogLoadOrder) -> Unit = {},
onSelectXtreamLiveSyncMode: (ProviderXtreamLiveSyncMode) -> Unit,
onSelectGuideSourcePolicy: (GuideSourcePolicy) -> Unit,
onSelectChannelLogoSourcePolicy: (ChannelLogoSourcePolicy) -> Unit,
@@ -483,6 +486,29 @@ internal fun AdvancedProviderOptionsSection(
selected = uiState.stalkerCatalogMode == StalkerCatalogMode.BACKGROUND_INDEX,
onSelect = { onSelectStalkerCatalogMode(StalkerCatalogMode.BACKGROUND_INDEX) }
)
+ Text(
+ text = stringResource(R.string.setup_stalker_load_order_title),
+ style = MaterialTheme.typography.titleSmall,
+ color = TextPrimary
+ )
+ PolicyOptionRow(
+ title = stringResource(R.string.setup_stalker_load_parallel_title),
+ description = stringResource(R.string.setup_stalker_load_parallel_description),
+ selected = uiState.stalkerCatalogLoadOrder == StalkerCatalogLoadOrder.PARALLEL,
+ onSelect = { onSelectStalkerCatalogLoadOrder(StalkerCatalogLoadOrder.PARALLEL) }
+ )
+ PolicyOptionRow(
+ title = stringResource(R.string.setup_stalker_load_movies_first_title),
+ description = stringResource(R.string.setup_stalker_load_movies_first_description),
+ selected = uiState.stalkerCatalogLoadOrder == StalkerCatalogLoadOrder.MOVIES_FIRST,
+ onSelect = { onSelectStalkerCatalogLoadOrder(StalkerCatalogLoadOrder.MOVIES_FIRST) }
+ )
+ PolicyOptionRow(
+ title = stringResource(R.string.setup_stalker_load_series_first_title),
+ description = stringResource(R.string.setup_stalker_load_series_first_description),
+ selected = uiState.stalkerCatalogLoadOrder == StalkerCatalogLoadOrder.SERIES_FIRST,
+ onSelect = { onSelectStalkerCatalogLoadOrder(StalkerCatalogLoadOrder.SERIES_FIRST) }
+ )
}
Column(
diff --git a/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderSetupAdvancedOptionsModel.kt b/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderSetupAdvancedOptionsModel.kt
index 3dfbb2ac..ab7ae6ff 100644
--- a/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderSetupAdvancedOptionsModel.kt
+++ b/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderSetupAdvancedOptionsModel.kt
@@ -6,6 +6,7 @@ import com.streamvault.domain.model.ProviderEpgSyncMode
import com.streamvault.domain.model.ProviderXtreamLiveSyncMode
import com.streamvault.domain.model.StalkerAuthMode
import com.streamvault.domain.model.StalkerCatalogMode
+import com.streamvault.domain.model.StalkerCatalogLoadOrder
/** UI values and callbacks shared by the provider-specific advanced sections. */
internal data class ProviderAdvancedOptions(
@@ -18,6 +19,7 @@ internal data class ProviderAdvancedOptions(
val onToggleM3uVodClassification: () -> Unit,
val onSelectEpgSyncMode: (ProviderEpgSyncMode) -> Unit,
val onSelectStalkerCatalogMode: (StalkerCatalogMode) -> Unit,
+ val onSelectStalkerCatalogLoadOrder: (StalkerCatalogLoadOrder) -> Unit = {},
val onSelectXtreamLiveSyncMode: (ProviderXtreamLiveSyncMode) -> Unit,
val onSelectGuideSourcePolicy: (GuideSourcePolicy) -> Unit,
val onSelectChannelLogoSourcePolicy: (ChannelLogoSourcePolicy) -> Unit,
diff --git a/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderSetupProviderForms.kt b/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderSetupProviderForms.kt
index 238e4740..29594cab 100644
--- a/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderSetupProviderForms.kt
+++ b/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderSetupProviderForms.kt
@@ -28,6 +28,7 @@ import com.streamvault.domain.model.ProviderEpgSyncMode
import com.streamvault.domain.model.ProviderXtreamLiveSyncMode
import com.streamvault.domain.model.StalkerAuthMode
import com.streamvault.domain.model.StalkerCatalogMode
+import com.streamvault.domain.model.StalkerCatalogLoadOrder
import com.streamvault.domain.model.StalkerProtocolPreference
@Composable
@@ -101,6 +102,7 @@ internal fun ProviderFormContent(
onToggleM3uVodClassification: () -> Unit,
onSelectEpgSyncMode: (ProviderEpgSyncMode) -> Unit,
onSelectStalkerCatalogMode: (StalkerCatalogMode) -> Unit,
+ onSelectStalkerCatalogLoadOrder: (StalkerCatalogLoadOrder) -> Unit = {},
onSelectStalkerProtocolPreference: (StalkerProtocolPreference) -> Unit,
onSelectStalkerProfile: (String) -> Unit,
onSelectXtreamLiveSyncMode: (ProviderXtreamLiveSyncMode) -> Unit,
@@ -120,6 +122,7 @@ internal fun ProviderFormContent(
onToggleM3uVodClassification = onToggleM3uVodClassification,
onSelectEpgSyncMode = onSelectEpgSyncMode,
onSelectStalkerCatalogMode = onSelectStalkerCatalogMode,
+ onSelectStalkerCatalogLoadOrder = onSelectStalkerCatalogLoadOrder,
onSelectXtreamLiveSyncMode = onSelectXtreamLiveSyncMode,
onSelectGuideSourcePolicy = onSelectGuideSourcePolicy,
onSelectChannelLogoSourcePolicy = onSelectChannelLogoSourcePolicy,
diff --git a/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderSetupScreen.kt b/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderSetupScreen.kt
index cb6ed3a2..913b20ce 100644
--- a/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderSetupScreen.kt
+++ b/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderSetupScreen.kt
@@ -323,6 +323,7 @@ fun ProviderSetupScreen(
fun buildStalkerAdvancedOptionsJson(): String =
ProviderStalkerAdvancedOptionsCodec.encode(
ProviderStalkerAdvancedOptions(
+ catalogLoadOrder = uiState.stalkerCatalogLoadOrder,
hwVersion = stalkerHwVersion.trim(),
apiUserAgent = stalkerApiUserAgent.trim(),
playerUserAgent = stalkerPlayerUserAgent.trim(),
@@ -484,6 +485,7 @@ fun ProviderSetupScreen(
onToggleM3uVodClassification = { viewModel.updateM3uVodClassificationEnabled(!uiState.m3uVodClassificationEnabled) },
onSelectEpgSyncMode = viewModel::updateEpgSyncMode,
onSelectStalkerCatalogMode = viewModel::updateStalkerCatalogMode,
+ onSelectStalkerCatalogLoadOrder = viewModel::updateStalkerCatalogLoadOrder,
onSelectStalkerProtocolPreference = viewModel::updateStalkerProtocolPreference,
onSelectStalkerProfile = viewModel::updateStalkerRequestedProfile,
onSelectXtreamLiveSyncMode = viewModel::updateXtreamLiveSyncMode,
@@ -549,6 +551,7 @@ fun ProviderSetupScreen(
onToggleM3uVodClassification = { viewModel.updateM3uVodClassificationEnabled(!uiState.m3uVodClassificationEnabled) },
onSelectEpgSyncMode = viewModel::updateEpgSyncMode,
onSelectStalkerCatalogMode = viewModel::updateStalkerCatalogMode,
+ onSelectStalkerCatalogLoadOrder = viewModel::updateStalkerCatalogLoadOrder,
onSelectStalkerProtocolPreference = viewModel::updateStalkerProtocolPreference,
onSelectStalkerProfile = viewModel::updateStalkerRequestedProfile,
onSelectXtreamLiveSyncMode = viewModel::updateXtreamLiveSyncMode,
diff --git a/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderSetupViewModel.kt b/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderSetupViewModel.kt
index d0732cbe..29575f23 100644
--- a/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderSetupViewModel.kt
+++ b/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderSetupViewModel.kt
@@ -21,6 +21,7 @@ import com.streamvault.domain.model.ProviderXtreamLiveSyncMode
import com.streamvault.domain.model.ProviderType
import com.streamvault.domain.model.StalkerAuthMode
import com.streamvault.domain.model.StalkerCatalogMode
+import com.streamvault.domain.model.StalkerCatalogLoadOrder
import com.streamvault.domain.model.StalkerCompatibilityProfileIds
import com.streamvault.domain.model.StalkerProtocolPreference
import com.streamvault.domain.model.StalkerTransportChallenge
@@ -364,6 +365,7 @@ class ProviderSetupViewModel @Inject constructor(
stalkerRequestedProfileId = provider.stalkerRequestedProfileId,
epgSyncMode = provider.epgSyncMode,
stalkerCatalogMode = provider.stalkerCatalogMode,
+ stalkerCatalogLoadOrder = ProviderStalkerAdvancedOptionsCodec.decode(provider.stalkerAdvancedOptionsJson).catalogLoadOrder,
xtreamLiveSyncMode = provider.xtreamLiveSyncMode,
guideSourcePolicy = provider.guideSourcePolicy,
channelLogoSourcePolicy = provider.channelLogoSourcePolicy,
@@ -398,6 +400,10 @@ class ProviderSetupViewModel @Inject constructor(
_uiState.update { it.copy(stalkerCatalogMode = mode) }
}
+ fun updateStalkerCatalogLoadOrder(order: StalkerCatalogLoadOrder) {
+ _uiState.update { it.copy(stalkerCatalogLoadOrder = order) }
+ }
+
fun updateStalkerProtocolPreference(preference: StalkerProtocolPreference) {
if (preference == StalkerProtocolPreference.MINISTRA_API_V3) return
_uiState.update { it.copy(stalkerProtocolPreference = preference) }
@@ -1266,6 +1272,7 @@ data class ProviderSetupState(
val driveBackupOptions: List<DriveBackupSnapshot> = emptyList(),
val epgSyncMode: ProviderEpgSyncMode = ProviderEpgSyncMode.BACKGROUND,
val stalkerCatalogMode: StalkerCatalogMode = StalkerCatalogMode.BACKGROUND_INDEX,
+ val stalkerCatalogLoadOrder: StalkerCatalogLoadOrder = StalkerCatalogLoadOrder.PARALLEL,
val xtreamLiveSyncMode: ProviderXtreamLiveSyncMode = ProviderXtreamLiveSyncMode.AUTO,
val guideSourcePolicy: GuideSourcePolicy = GuideSourcePolicy.AUTO,
val channelLogoSourcePolicy: ChannelLogoSourcePolicy = ChannelLogoSourcePolicy.SUPPLIER_PREFERRED,
diff --git a/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderStalkerAdvancedOptions.kt b/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderStalkerAdvancedOptions.kt
index 268369f1..1e1f9c53 100644
--- a/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderStalkerAdvancedOptions.kt
+++ b/feature/provider/src/main/java/com/streamvault/feature/provider/setup/ProviderStalkerAdvancedOptions.kt
@@ -12,6 +12,7 @@ import kotlinx.serialization.json.jsonArray
import kotlinx.serialization.json.jsonObject
import kotlinx.serialization.json.jsonPrimitive
import kotlinx.serialization.json.put
+import com.streamvault.domain.model.StalkerCatalogLoadOrder
internal data class ProviderStalkerAdvancedOptions(
val hwVersion: String = "",
@@ -23,6 +24,7 @@ internal data class ProviderStalkerAdvancedOptions(
val proxyHost: String = "",
val proxyPort: Int? = null,
val requestRules: List<ProviderStalkerRequestRule> = emptyList(),
+ val catalogLoadOrder: StalkerCatalogLoadOrder = StalkerCatalogLoadOrder.PARALLEL,
) {
val normalizedLink: String
get() = if (xUserAgentLink.equals(LINK_WIFI, ignoreCase = true)) LINK_WIFI else LINK_ETHERNET
@@ -80,6 +82,9 @@ internal object ProviderStalkerAdvancedOptionsCodec {
fun encode(options: ProviderStalkerAdvancedOptions): String {
if (options == ProviderStalkerAdvancedOptions()) return ""
return buildJsonObject {
+ if (options.catalogLoadOrder != StalkerCatalogLoadOrder.PARALLEL) {
+ put("catalogLoadOrder", options.catalogLoadOrder.name)
+ }
put("hwVersion", options.hwVersion)
put("apiUserAgent", options.apiUserAgent)
put("playerUserAgent", options.playerUserAgent)
@@ -132,6 +137,8 @@ internal object ProviderStalkerAdvancedOptionsCodec {
private fun decodeObject(root: JsonObject): ProviderStalkerAdvancedOptions =
ProviderStalkerAdvancedOptions(
+ catalogLoadOrder = runCatching { StalkerCatalogLoadOrder.valueOf(root.string("catalogLoadOrder")) }
+ .getOrDefault(StalkerCatalogLoadOrder.PARALLEL),
hwVersion = root.string("hwVersion"),
apiUserAgent = root.string("apiUserAgent"),
playerUserAgent = root.string("playerUserAgent"),
diff --git a/feature/provider/src/main/res/values-ar/strings.xml b/feature/provider/src/main/res/values-ar/strings.xml
index a7beb9e6..98ccd79e 100644
--- a/feature/provider/src/main/res/values-ar/strings.xml
+++ b/feature/provider/src/main/res/values-ar/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">حمّل الرفوف والفئات عند فتحها. احتفظ بالعناوين المخزنة مؤقتًا.</string>
<string name="setup_stalker_catalog_background_title">فهرسة كاملة في الخلفية (موصى بها)</string>
<string name="setup_stalker_catalog_background_description">أكمل إعداد المزوّد أولًا، ثم افهرس جميع عناوين الأفلام والمسلسلات في الخلفية للبحث.</string>
+ <string name="setup_stalker_load_order_title">ترتيب التحميل في الخلفية</string>
+ <string name="setup_stalker_load_parallel_title">كلاهما معًا (افتراضي)</string>
+ <string name="setup_stalker_load_parallel_description">تحميل الأفلام والمسلسلات معًا.</string>
+ <string name="setup_stalker_load_movies_first_title">الأفلام أولًا</string>
+ <string name="setup_stalker_load_movies_first_description">إبقاء المسلسلات في الانتظار حتى يكتمل تحميل الأفلام.</string>
+ <string name="setup_stalker_load_series_first_title">المسلسلات أولًا</string>
+ <string name="setup_stalker_load_series_first_description">إبقاء الأفلام في الانتظار حتى يكتمل تحميل المسلسلات.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-bg/strings.xml b/feature/provider/src/main/res/values-bg/strings.xml
index ebdf7ba7..7f533ff7 100644
--- a/feature/provider/src/main/res/values-bg/strings.xml
+++ b/feature/provider/src/main/res/values-bg/strings.xml
@@ -129,4 +129,11 @@
<string name="setup_stalker_catalog_on_demand_description">Зареждайте рафтовете и категориите при отваряне. Запазвайте кешираните заглавия.</string>
<string name="setup_stalker_catalog_background_title">Пълно фоново индексиране (препоръчително)</string>
<string name="setup_stalker_catalog_background_description">Първо завършете настройката на доставчика, след което индексирайте всички филми и сериали във фонов режим за търсене.</string>
+ <string name="setup_stalker_load_order_title">Ред на зареждане във фонов режим</string>
+ <string name="setup_stalker_load_parallel_title">Едновременно (по подразбиране)</string>
+ <string name="setup_stalker_load_parallel_description">Зареждане на филми и сериали едновременно.</string>
+ <string name="setup_stalker_load_movies_first_title">Първо филмите</string>
+ <string name="setup_stalker_load_movies_first_description">Сериалите изчакват, докато филмите се заредят.</string>
+ <string name="setup_stalker_load_series_first_title">Първо сериалите</string>
+ <string name="setup_stalker_load_series_first_description">Филмите изчакват, докато сериалите се заредят.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-cs/strings.xml b/feature/provider/src/main/res/values-cs/strings.xml
index adb3b2d3..44a6449f 100644
--- a/feature/provider/src/main/res/values-cs/strings.xml
+++ b/feature/provider/src/main/res/values-cs/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">Police a kategorie načítá při otevření. Uložené tituly ponechá v mezipaměti.</string>
<string name="setup_stalker_catalog_background_title">Úplné indexování na pozadí (doporučeno)</string>
<string name="setup_stalker_catalog_background_description">Nejprve dokončí nastavení poskytovatele a pak na pozadí zaindexuje všechny filmy a seriály pro vyhledávání.</string>
+ <string name="setup_stalker_load_order_title">Pořadí načítání na pozadí</string>
+ <string name="setup_stalker_load_parallel_title">Obojí současně (výchozí)</string>
+ <string name="setup_stalker_load_parallel_description">Načítat filmy a seriály současně.</string>
+ <string name="setup_stalker_load_movies_first_title">Nejprve filmy</string>
+ <string name="setup_stalker_load_movies_first_description">Seriály čekají ve frontě, dokud se nenačtou filmy.</string>
+ <string name="setup_stalker_load_series_first_title">Nejprve seriály</string>
+ <string name="setup_stalker_load_series_first_description">Filmy čekají ve frontě, dokud se nenačtou seriály.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-da/strings.xml b/feature/provider/src/main/res/values-da/strings.xml
index e31044ee..ce63a163 100644
--- a/feature/provider/src/main/res/values-da/strings.xml
+++ b/feature/provider/src/main/res/values-da/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">Indlæs hylder og kategorier, når de åbnes. Behold titler i cachen.</string>
<string name="setup_stalker_catalog_background_title">Komplet baggrundsindeksering (anbefalet)</string>
<string name="setup_stalker_catalog_background_description">Færdiggør først udbyderopsætningen, og indekser derefter alle film og serier i baggrunden, så de kan søges frem.</string>
+ <string name="setup_stalker_load_order_title">Indlæsningsrækkefølge i baggrunden</string>
+ <string name="setup_stalker_load_parallel_title">Begge samtidig (standard)</string>
+ <string name="setup_stalker_load_parallel_description">Indlæs film og serier samtidig.</string>
+ <string name="setup_stalker_load_movies_first_title">Film først</string>
+ <string name="setup_stalker_load_movies_first_description">Lad serier vente i kø, indtil filmene er indlæst.</string>
+ <string name="setup_stalker_load_series_first_title">Serier først</string>
+ <string name="setup_stalker_load_series_first_description">Lad film vente i kø, indtil serierne er indlæst.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-de/strings.xml b/feature/provider/src/main/res/values-de/strings.xml
index a2c369e0..f35384db 100644
--- a/feature/provider/src/main/res/values-de/strings.xml
+++ b/feature/provider/src/main/res/values-de/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">Regale und Kategorien werden beim Öffnen geladen. Zwischengespeicherte Titel bleiben erhalten.</string>
<string name="setup_stalker_catalog_background_title">Vollständige Hintergrundindizierung (empfohlen)</string>
<string name="setup_stalker_catalog_background_description">Schließe zuerst die Anbietereinrichtung ab. Danach werden alle Filme und Serien im Hintergrund für die Suche indiziert.</string>
+ <string name="setup_stalker_load_order_title">Reihenfolge beim Laden im Hintergrund</string>
+ <string name="setup_stalker_load_parallel_title">Beides gleichzeitig (Standard)</string>
+ <string name="setup_stalker_load_parallel_description">Filme und Serien gleichzeitig laden.</string>
+ <string name="setup_stalker_load_movies_first_title">Filme zuerst</string>
+ <string name="setup_stalker_load_movies_first_description">Serien bleiben in der Warteschlange, bis alle Filme geladen sind.</string>
+ <string name="setup_stalker_load_series_first_title">Serien zuerst</string>
+ <string name="setup_stalker_load_series_first_description">Filme bleiben in der Warteschlange, bis alle Serien geladen sind.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-el/strings.xml b/feature/provider/src/main/res/values-el/strings.xml
index 68cf0265..187ea496 100644
--- a/feature/provider/src/main/res/values-el/strings.xml
+++ b/feature/provider/src/main/res/values-el/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">Φόρτωση ραφιών και κατηγοριών όταν ανοίγουν. Διατήρηση των αποθηκευμένων τίτλων.</string>
<string name="setup_stalker_catalog_background_title">Πλήρης ευρετηρίαση στο παρασκήνιο (συνιστάται)</string>
<string name="setup_stalker_catalog_background_description">Ολοκληρώστε πρώτα τη ρύθμιση του παρόχου και έπειτα ευρετηριάστε όλες τις ταινίες και σειρές στο παρασκήνιο για αναζήτηση.</string>
+ <string name="setup_stalker_load_order_title">Σειρά φόρτωσης στο παρασκήνιο</string>
+ <string name="setup_stalker_load_parallel_title">Και τα δύο μαζί (προεπιλογή)</string>
+ <string name="setup_stalker_load_parallel_description">Φόρτωση ταινιών και σειρών ταυτόχρονα.</string>
+ <string name="setup_stalker_load_movies_first_title">Πρώτα οι ταινίες</string>
+ <string name="setup_stalker_load_movies_first_description">Οι σειρές παραμένουν στην ουρά μέχρι να φορτωθούν οι ταινίες.</string>
+ <string name="setup_stalker_load_series_first_title">Πρώτα οι σειρές</string>
+ <string name="setup_stalker_load_series_first_description">Οι ταινίες παραμένουν στην ουρά μέχρι να φορτωθούν οι σειρές.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-es/strings.xml b/feature/provider/src/main/res/values-es/strings.xml
index e34e14c3..7bf717f1 100644
--- a/feature/provider/src/main/res/values-es/strings.xml
+++ b/feature/provider/src/main/res/values-es/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">Carga las secciones y categorías al abrirlas. Conserva los títulos en caché.</string>
<string name="setup_stalker_catalog_background_title">Indexación completa en segundo plano (recomendada)</string>
<string name="setup_stalker_catalog_background_description">Primero termina de configurar el proveedor y luego indexa todas las películas y series en segundo plano para que puedas buscarlas.</string>
+ <string name="setup_stalker_load_order_title">Orden de carga en segundo plano</string>
+ <string name="setup_stalker_load_parallel_title">Ambos a la vez (predeterminado)</string>
+ <string name="setup_stalker_load_parallel_description">Cargar películas y series a la vez.</string>
+ <string name="setup_stalker_load_movies_first_title">Películas primero</string>
+ <string name="setup_stalker_load_movies_first_description">Mantener las series en cola hasta que terminen de cargarse las películas.</string>
+ <string name="setup_stalker_load_series_first_title">Series primero</string>
+ <string name="setup_stalker_load_series_first_description">Mantener las películas en cola hasta que terminen de cargarse las series.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-fa/strings.xml b/feature/provider/src/main/res/values-fa/strings.xml
index e35de63d..24271b19 100644
--- a/feature/provider/src/main/res/values-fa/strings.xml
+++ b/feature/provider/src/main/res/values-fa/strings.xml
@@ -129,4 +129,11 @@
<string name="setup_stalker_catalog_on_demand_description">قفسه‌ها و دسته‌ها را هنگام باز شدن بارگیری می‌کند. عنوان‌های ذخیره‌شده در حافظه موقت حفظ می‌شوند.</string>
<string name="setup_stalker_catalog_background_title">فهرست‌سازی کامل در پس‌زمینه (پیشنهادی)</string>
<string name="setup_stalker_catalog_background_description">ابتدا راه‌اندازی ارائه‌دهنده را کامل کنید، سپس همه فیلم‌ها و سریال‌ها را برای جست‌وجو در پس‌زمینه فهرست کنید.</string>
+ <string name="setup_stalker_load_order_title">ترتیب بارگیری در پس‌زمینه</string>
+ <string name="setup_stalker_load_parallel_title">هر دو با هم (پیش‌فرض)</string>
+ <string name="setup_stalker_load_parallel_description">فیلم‌ها و سریال‌ها هم‌زمان بارگیری شوند.</string>
+ <string name="setup_stalker_load_movies_first_title">ابتدا فیلم‌ها</string>
+ <string name="setup_stalker_load_movies_first_description">سریال‌ها تا پایان بارگیری فیلم‌ها در صف بمانند.</string>
+ <string name="setup_stalker_load_series_first_title">ابتدا سریال‌ها</string>
+ <string name="setup_stalker_load_series_first_description">فیلم‌ها تا پایان بارگیری سریال‌ها در صف بمانند.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-fi/strings.xml b/feature/provider/src/main/res/values-fi/strings.xml
index 1e578530..e9c55bbd 100644
--- a/feature/provider/src/main/res/values-fi/strings.xml
+++ b/feature/provider/src/main/res/values-fi/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">Lataa hyllyt ja kategoriat avattaessa. Säilyttää välimuistissa olevat nimikkeet.</string>
<string name="setup_stalker_catalog_background_title">Täysi taustaindeksointi (suositeltu)</string>
<string name="setup_stalker_catalog_background_description">Viimeistele ensin palveluntarjoajan käyttöönotto. Sen jälkeen kaikki elokuvat ja sarjat indeksoidaan taustalla hakua varten.</string>
+ <string name="setup_stalker_load_order_title">Taustalatauksen järjestys</string>
+ <string name="setup_stalker_load_parallel_title">Molemmat yhdessä (oletus)</string>
+ <string name="setup_stalker_load_parallel_description">Lataa elokuvia ja sarjoja samanaikaisesti.</string>
+ <string name="setup_stalker_load_movies_first_title">Elokuvat ensin</string>
+ <string name="setup_stalker_load_movies_first_description">Pidä sarjat jonossa, kunnes elokuvat on ladattu.</string>
+ <string name="setup_stalker_load_series_first_title">Sarjat ensin</string>
+ <string name="setup_stalker_load_series_first_description">Pidä elokuvat jonossa, kunnes sarjat on ladattu.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-fil/strings.xml b/feature/provider/src/main/res/values-fil/strings.xml
index 6eb396de..18c74da7 100644
--- a/feature/provider/src/main/res/values-fil/strings.xml
+++ b/feature/provider/src/main/res/values-fil/strings.xml
@@ -129,4 +129,11 @@
<string name="setup_stalker_catalog_on_demand_description">Nilo-load ang mga shelf at kategorya kapag binuksan. Pinananatili ang mga naka-cache na pamagat.</string>
<string name="setup_stalker_catalog_background_title">Kumpletong pag-index sa background (inirerekomenda)</string>
<string name="setup_stalker_catalog_background_description">Tapusin muna ang setup ng provider, saka i-index sa background ang lahat ng pelikula at serye para madaling hanapin.</string>
+ <string name="setup_stalker_load_order_title">Pagkakasunod ng pag-load sa background</string>
+ <string name="setup_stalker_load_parallel_title">Sabay pareho (default)</string>
+ <string name="setup_stalker_load_parallel_description">Sabay na i-load ang mga pelikula at serye.</string>
+ <string name="setup_stalker_load_movies_first_title">Mga pelikula muna</string>
+ <string name="setup_stalker_load_movies_first_description">Panatilihing nakapila ang mga serye hanggang matapos ma-load ang mga pelikula.</string>
+ <string name="setup_stalker_load_series_first_title">Mga serye muna</string>
+ <string name="setup_stalker_load_series_first_description">Panatilihing nakapila ang mga pelikula hanggang matapos ma-load ang mga serye.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-fr/strings.xml b/feature/provider/src/main/res/values-fr/strings.xml
index de4b8d64..ca0b778b 100644
--- a/feature/provider/src/main/res/values-fr/strings.xml
+++ b/feature/provider/src/main/res/values-fr/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">Charge les rayons et les catégories à leur ouverture. Conserve les titres en cache.</string>
<string name="setup_stalker_catalog_background_title">Indexation complète en arrière-plan (recommandée)</string>
<string name="setup_stalker_catalog_background_description">Terminez d’abord la configuration du fournisseur, puis indexez tous les films et séries en arrière-plan pour les rendre consultables.</string>
+ <string name="setup_stalker_load_order_title">Ordre de chargement en arrière-plan</string>
+ <string name="setup_stalker_load_parallel_title">Les deux ensemble (par défaut)</string>
+ <string name="setup_stalker_load_parallel_description">Charger les films et les séries simultanément.</string>
+ <string name="setup_stalker_load_movies_first_title">Films d’abord</string>
+ <string name="setup_stalker_load_movies_first_description">Garder les séries en attente jusqu’à la fin du chargement des films.</string>
+ <string name="setup_stalker_load_series_first_title">Séries d’abord</string>
+ <string name="setup_stalker_load_series_first_description">Garder les films en attente jusqu’à la fin du chargement des séries.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-hi/strings.xml b/feature/provider/src/main/res/values-hi/strings.xml
index 97d6d334..113799e8 100644
--- a/feature/provider/src/main/res/values-hi/strings.xml
+++ b/feature/provider/src/main/res/values-hi/strings.xml
@@ -129,4 +129,11 @@
<string name="setup_stalker_catalog_on_demand_description">शेल्फ़ और श्रेणियाँ खोलने पर लोड करें। कैश किए गए शीर्षक रखें।</string>
<string name="setup_stalker_catalog_background_title">पूरा बैकग्राउंड इंडेक्स (अनुशंसित)</string>
<string name="setup_stalker_catalog_background_description">पहले प्रदाता का सेटअप पूरा करें, फिर खोज के लिए सभी फ़िल्मों और सीरीज़ को बैकग्राउंड में इंडेक्स करें।</string>
+ <string name="setup_stalker_load_order_title">बैकग्राउंड में लोड करने का क्रम</string>
+ <string name="setup_stalker_load_parallel_title">दोनों एक साथ (डिफ़ॉल्ट)</string>
+ <string name="setup_stalker_load_parallel_description">फ़िल्में और सीरीज़ एक साथ लोड करें।</string>
+ <string name="setup_stalker_load_movies_first_title">पहले फ़िल्में</string>
+ <string name="setup_stalker_load_movies_first_description">फ़िल्में लोड होने तक सीरीज़ को कतार में रखें।</string>
+ <string name="setup_stalker_load_series_first_title">पहले सीरीज़</string>
+ <string name="setup_stalker_load_series_first_description">सीरीज़ लोड होने तक फ़िल्मों को कतार में रखें।</string>
</resources>
diff --git a/feature/provider/src/main/res/values-hr/strings.xml b/feature/provider/src/main/res/values-hr/strings.xml
index a04516e5..91d8aacc 100644
--- a/feature/provider/src/main/res/values-hr/strings.xml
+++ b/feature/provider/src/main/res/values-hr/strings.xml
@@ -129,4 +129,11 @@
<string name="setup_stalker_catalog_on_demand_description">Police i kategorije učitavaju se pri otvaranju. Predmemorirani naslovi ostaju spremljeni.</string>
<string name="setup_stalker_catalog_background_title">Potpuno indeksiranje u pozadini (preporučeno)</string>
<string name="setup_stalker_catalog_background_description">Najprije dovršite postavljanje pružatelja, a zatim u pozadini indeksirajte sve filmove i serije kako biste ih mogli pretraživati.</string>
+ <string name="setup_stalker_load_order_title">Redoslijed učitavanja u pozadini</string>
+ <string name="setup_stalker_load_parallel_title">Oboje istodobno (zadano)</string>
+ <string name="setup_stalker_load_parallel_description">Istodobno učitavaj filmove i serije.</string>
+ <string name="setup_stalker_load_movies_first_title">Prvo filmovi</string>
+ <string name="setup_stalker_load_movies_first_description">Serije čekaju u redu dok se filmovi ne učitaju.</string>
+ <string name="setup_stalker_load_series_first_title">Prvo serije</string>
+ <string name="setup_stalker_load_series_first_description">Filmovi čekaju u redu dok se serije ne učitaju.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-hu/strings.xml b/feature/provider/src/main/res/values-hu/strings.xml
index b1e48f12..ba078887 100644
--- a/feature/provider/src/main/res/values-hu/strings.xml
+++ b/feature/provider/src/main/res/values-hu/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">A polcok és kategóriák megnyitáskor töltődnek be. A gyorsítótárazott címek megmaradnak.</string>
<string name="setup_stalker_catalog_background_title">Teljes háttérindexelés (ajánlott)</string>
<string name="setup_stalker_catalog_background_description">Először fejezze be a szolgáltató beállítását, majd indexelje a háttérben az összes filmet és sorozatot a kereséshez.</string>
+ <string name="setup_stalker_load_order_title">Háttérbetöltés sorrendje</string>
+ <string name="setup_stalker_load_parallel_title">Mindkettő egyszerre (alapértelmezett)</string>
+ <string name="setup_stalker_load_parallel_description">Filmek és sorozatok egyidejű betöltése.</string>
+ <string name="setup_stalker_load_movies_first_title">Először a filmek</string>
+ <string name="setup_stalker_load_movies_first_description">A sorozatok várakozzanak, amíg a filmek betöltődnek.</string>
+ <string name="setup_stalker_load_series_first_title">Először a sorozatok</string>
+ <string name="setup_stalker_load_series_first_description">A filmek várakozzanak, amíg a sorozatok betöltődnek.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-in/strings.xml b/feature/provider/src/main/res/values-in/strings.xml
index 6b7e6514..ebc894f7 100644
--- a/feature/provider/src/main/res/values-in/strings.xml
+++ b/feature/provider/src/main/res/values-in/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">Muat rak dan kategori saat dibuka. Pertahankan judul yang tersimpan di cache.</string>
<string name="setup_stalker_catalog_background_title">Indeks latar belakang lengkap (disarankan)</string>
<string name="setup_stalker_catalog_background_description">Selesaikan penyiapan penyedia terlebih dahulu, lalu indeks semua film dan serial di latar belakang agar dapat dicari.</string>
+ <string name="setup_stalker_load_order_title">Urutan pemuatan di latar belakang</string>
+ <string name="setup_stalker_load_parallel_title">Keduanya bersamaan (default)</string>
+ <string name="setup_stalker_load_parallel_description">Muat film dan serial secara bersamaan.</string>
+ <string name="setup_stalker_load_movies_first_title">Film dahulu</string>
+ <string name="setup_stalker_load_movies_first_description">Biarkan serial dalam antrean hingga film selesai dimuat.</string>
+ <string name="setup_stalker_load_series_first_title">Serial dahulu</string>
+ <string name="setup_stalker_load_series_first_description">Biarkan film dalam antrean hingga serial selesai dimuat.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-it/strings.xml b/feature/provider/src/main/res/values-it/strings.xml
index 50656653..4128481a 100644
--- a/feature/provider/src/main/res/values-it/strings.xml
+++ b/feature/provider/src/main/res/values-it/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">Carica gli scaffali e le categorie quando vengono aperti. Mantiene i titoli nella cache.</string>
<string name="setup_stalker_catalog_background_title">Indicizzazione completa in background (consigliata)</string>
<string name="setup_stalker_catalog_background_description">Completa prima la configurazione del provider, poi indicizza tutti i film e le serie in background per renderli ricercabili.</string>
+ <string name="setup_stalker_load_order_title">Ordine di caricamento in background</string>
+ <string name="setup_stalker_load_parallel_title">Entrambi insieme (predefinito)</string>
+ <string name="setup_stalker_load_parallel_description">Carica film e serie contemporaneamente.</string>
+ <string name="setup_stalker_load_movies_first_title">Prima i film</string>
+ <string name="setup_stalker_load_movies_first_description">Mantieni le serie in coda fino al termine del caricamento dei film.</string>
+ <string name="setup_stalker_load_series_first_title">Prima le serie</string>
+ <string name="setup_stalker_load_series_first_description">Mantieni i film in coda fino al termine del caricamento delle serie.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-iw/strings.xml b/feature/provider/src/main/res/values-iw/strings.xml
index 0c409bde..2ec136a6 100644
--- a/feature/provider/src/main/res/values-iw/strings.xml
+++ b/feature/provider/src/main/res/values-iw/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">טעינת המדפים והקטגוריות בעת פתיחתם. שמירת הכותרים שבמטמון.</string>
<string name="setup_stalker_catalog_background_title">יצירת אינדקס מלאה ברקע (מומלץ)</string>
<string name="setup_stalker_catalog_background_description">יש להשלים תחילה את הגדרת הספק, ולאחר מכן ליצור ברקע אינדקס לכל הסרטים והסדרות כדי שאפשר יהיה לחפש בהם.</string>
+ <string name="setup_stalker_load_order_title">סדר טעינה ברקע</string>
+ <string name="setup_stalker_load_parallel_title">שניהם יחד (ברירת מחדל)</string>
+ <string name="setup_stalker_load_parallel_description">טעינת סרטים וסדרות במקביל.</string>
+ <string name="setup_stalker_load_movies_first_title">סרטים קודם</string>
+ <string name="setup_stalker_load_movies_first_description">הסדרות ימתינו בתור עד לסיום טעינת הסרטים.</string>
+ <string name="setup_stalker_load_series_first_title">סדרות קודם</string>
+ <string name="setup_stalker_load_series_first_description">הסרטים ימתינו בתור עד לסיום טעינת הסדרות.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-ja/strings.xml b/feature/provider/src/main/res/values-ja/strings.xml
index 6ae7ffea..e55443eb 100644
--- a/feature/provider/src/main/res/values-ja/strings.xml
+++ b/feature/provider/src/main/res/values-ja/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">棚とカテゴリは開いたときに読み込みます。キャッシュ済みのタイトルは保持します。</string>
<string name="setup_stalker_catalog_background_title">バックグラウンドで全件インデックス(おすすめ)</string>
<string name="setup_stalker_catalog_background_description">先にプロバイダーのセットアップを完了し、その後、検索できるようにすべての映画とシリーズをバックグラウンドでインデックスします。</string>
+ <string name="setup_stalker_load_order_title">バックグラウンド読み込み順序</string>
+ <string name="setup_stalker_load_parallel_title">両方同時(デフォルト)</string>
+ <string name="setup_stalker_load_parallel_description">映画とシリーズを同時に読み込みます。</string>
+ <string name="setup_stalker_load_movies_first_title">映画を先に読み込む</string>
+ <string name="setup_stalker_load_movies_first_description">映画の読み込みが完了するまでシリーズを待機させます。</string>
+ <string name="setup_stalker_load_series_first_title">シリーズを先に読み込む</string>
+ <string name="setup_stalker_load_series_first_description">シリーズの読み込みが完了するまで映画を待機させます。</string>
</resources>
diff --git a/feature/provider/src/main/res/values-ko/strings.xml b/feature/provider/src/main/res/values-ko/strings.xml
index 5fb009cb..490f8351 100644
--- a/feature/provider/src/main/res/values-ko/strings.xml
+++ b/feature/provider/src/main/res/values-ko/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">선반과 카테고리를 열 때 로드합니다. 캐시된 제목은 유지합니다.</string>
<string name="setup_stalker_catalog_background_title">백그라운드 전체 색인 (권장)</string>
<string name="setup_stalker_catalog_background_description">먼저 제공업체 설정을 완료한 다음 검색할 수 있도록 모든 영화와 시리즈를 백그라운드에서 색인합니다.</string>
+ <string name="setup_stalker_load_order_title">백그라운드 로딩 순서</string>
+ <string name="setup_stalker_load_parallel_title">둘 다 동시에 (기본값)</string>
+ <string name="setup_stalker_load_parallel_description">영화와 시리즈를 동시에 불러옵니다.</string>
+ <string name="setup_stalker_load_movies_first_title">영화 먼저</string>
+ <string name="setup_stalker_load_movies_first_description">영화 로딩이 끝날 때까지 시리즈를 대기열에 둡니다.</string>
+ <string name="setup_stalker_load_series_first_title">시리즈 먼저</string>
+ <string name="setup_stalker_load_series_first_description">시리즈 로딩이 끝날 때까지 영화를 대기열에 둡니다.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-mk/strings.xml b/feature/provider/src/main/res/values-mk/strings.xml
index 49a5575a..e51d82b1 100644
--- a/feature/provider/src/main/res/values-mk/strings.xml
+++ b/feature/provider/src/main/res/values-mk/strings.xml
@@ -129,4 +129,11 @@
<string name="setup_stalker_catalog_on_demand_description">Полиците и категориите се вчитуваат кога ќе се отворат. Кешираните наслови се задржуваат.</string>
<string name="setup_stalker_catalog_background_title">Целосно индексирање во заднина (препорачано)</string>
<string name="setup_stalker_catalog_background_description">Прво завршете го поставувањето на провајдерот, а потоа индексирајте ги сите филмови и серии во заднина за пребарување.</string>
+ <string name="setup_stalker_load_order_title">Редослед на вчитување во заднина</string>
+ <string name="setup_stalker_load_parallel_title">Двете истовремено (стандардно)</string>
+ <string name="setup_stalker_load_parallel_description">Вчитувај филмови и серии истовремено.</string>
+ <string name="setup_stalker_load_movies_first_title">Прво филмовите</string>
+ <string name="setup_stalker_load_movies_first_description">Сериите чекаат во ред додека не се вчитаат филмовите.</string>
+ <string name="setup_stalker_load_series_first_title">Прво сериите</string>
+ <string name="setup_stalker_load_series_first_description">Филмовите чекаат во ред додека не се вчитаат сериите.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-ms/strings.xml b/feature/provider/src/main/res/values-ms/strings.xml
index fbba1349..6cc1ecc4 100644
--- a/feature/provider/src/main/res/values-ms/strings.xml
+++ b/feature/provider/src/main/res/values-ms/strings.xml
@@ -129,4 +129,11 @@
<string name="setup_stalker_catalog_on_demand_description">Muatkan rak dan kategori apabila dibuka. Kekalkan tajuk yang dicache.</string>
<string name="setup_stalker_catalog_background_title">Indeks latar belakang lengkap (disyorkan)</string>
<string name="setup_stalker_catalog_background_description">Selesaikan persediaan penyedia dahulu, kemudian indeks semua filem dan siri di latar belakang untuk carian.</string>
+ <string name="setup_stalker_load_order_title">Turutan pemuatan latar belakang</string>
+ <string name="setup_stalker_load_parallel_title">Kedua-duanya serentak (lalai)</string>
+ <string name="setup_stalker_load_parallel_description">Muatkan filem dan siri serentak.</string>
+ <string name="setup_stalker_load_movies_first_title">Filem dahulu</string>
+ <string name="setup_stalker_load_movies_first_description">Biarkan siri dalam baris gilir sehingga filem selesai dimuatkan.</string>
+ <string name="setup_stalker_load_series_first_title">Siri dahulu</string>
+ <string name="setup_stalker_load_series_first_description">Biarkan filem dalam baris gilir sehingga siri selesai dimuatkan.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-nb/strings.xml b/feature/provider/src/main/res/values-nb/strings.xml
index 0b59790b..d0ace838 100644
--- a/feature/provider/src/main/res/values-nb/strings.xml
+++ b/feature/provider/src/main/res/values-nb/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">Hyller og kategorier lastes inn når de åpnes. Bufrede titler beholdes.</string>
<string name="setup_stalker_catalog_background_title">Full bakgrunnsindeksering (anbefalt)</string>
<string name="setup_stalker_catalog_background_description">Fullfør først oppsettet av leverandøren, og indekser deretter alle filmer og serier i bakgrunnen slik at de kan søkes opp.</string>
+ <string name="setup_stalker_load_order_title">Innlastingsrekkefølge i bakgrunnen</string>
+ <string name="setup_stalker_load_parallel_title">Begge samtidig (standard)</string>
+ <string name="setup_stalker_load_parallel_description">Last inn filmer og serier samtidig.</string>
+ <string name="setup_stalker_load_movies_first_title">Filmer først</string>
+ <string name="setup_stalker_load_movies_first_description">La serier vente i kø til filmene er lastet inn.</string>
+ <string name="setup_stalker_load_series_first_title">Serier først</string>
+ <string name="setup_stalker_load_series_first_description">La filmer vente i kø til seriene er lastet inn.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-nl/strings.xml b/feature/provider/src/main/res/values-nl/strings.xml
index 52d6dcf1..bb3feb41 100644
--- a/feature/provider/src/main/res/values-nl/strings.xml
+++ b/feature/provider/src/main/res/values-nl/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">Laad planken en categorieën wanneer ze worden geopend. Bewaar titels in de cache.</string>
<string name="setup_stalker_catalog_background_title">Volledige achtergrondindex (aanbevolen)</string>
<string name="setup_stalker_catalog_background_description">Rond eerst de installatie van de provider af en indexeer daarna alle films en series op de achtergrond, zodat je ze kunt zoeken.</string>
+ <string name="setup_stalker_load_order_title">Laadvolgorde op de achtergrond</string>
+ <string name="setup_stalker_load_parallel_title">Beide tegelijk (standaard)</string>
+ <string name="setup_stalker_load_parallel_description">Films en series tegelijk laden.</string>
+ <string name="setup_stalker_load_movies_first_title">Films eerst</string>
+ <string name="setup_stalker_load_movies_first_description">Laat series in de wachtrij staan totdat de films zijn geladen.</string>
+ <string name="setup_stalker_load_series_first_title">Series eerst</string>
+ <string name="setup_stalker_load_series_first_description">Laat films in de wachtrij staan totdat de series zijn geladen.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-pl/strings.xml b/feature/provider/src/main/res/values-pl/strings.xml
index ea3a3c60..b0e52953 100644
--- a/feature/provider/src/main/res/values-pl/strings.xml
+++ b/feature/provider/src/main/res/values-pl/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">Półki i kategorie są wczytywane po otwarciu. Tytuły w pamięci podręcznej są zachowywane.</string>
<string name="setup_stalker_catalog_background_title">Pełne indeksowanie w tle (zalecane)</string>
<string name="setup_stalker_catalog_background_description">Najpierw zakończ konfigurację dostawcy, a następnie indeksuj w tle wszystkie filmy i seriale, aby można je było wyszukiwać.</string>
+ <string name="setup_stalker_load_order_title">Kolejność wczytywania w tle</string>
+ <string name="setup_stalker_load_parallel_title">Oba jednocześnie (domyślnie)</string>
+ <string name="setup_stalker_load_parallel_description">Wczytuj filmy i seriale jednocześnie.</string>
+ <string name="setup_stalker_load_movies_first_title">Najpierw filmy</string>
+ <string name="setup_stalker_load_movies_first_description">Seriale czekają w kolejce do zakończenia wczytywania filmów.</string>
+ <string name="setup_stalker_load_series_first_title">Najpierw seriale</string>
+ <string name="setup_stalker_load_series_first_description">Filmy czekają w kolejce do zakończenia wczytywania seriali.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-pt/strings.xml b/feature/provider/src/main/res/values-pt/strings.xml
index e95b5eb4..8ddfc769 100644
--- a/feature/provider/src/main/res/values-pt/strings.xml
+++ b/feature/provider/src/main/res/values-pt/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">Carrega prateleiras e categorias quando são abertas. Mantém os títulos em cache.</string>
<string name="setup_stalker_catalog_background_title">Indexação completa em segundo plano (recomendada)</string>
<string name="setup_stalker_catalog_background_description">Conclua primeiro a configuração do fornecedor e depois indexe todos os filmes e séries em segundo plano para poder pesquisá-los.</string>
+ <string name="setup_stalker_load_order_title">Ordem de carregamento em segundo plano</string>
+ <string name="setup_stalker_load_parallel_title">Ambos em simultâneo (predefinição)</string>
+ <string name="setup_stalker_load_parallel_description">Carregar filmes e séries em simultâneo.</string>
+ <string name="setup_stalker_load_movies_first_title">Filmes primeiro</string>
+ <string name="setup_stalker_load_movies_first_description">Manter as séries na fila até terminar o carregamento dos filmes.</string>
+ <string name="setup_stalker_load_series_first_title">Séries primeiro</string>
+ <string name="setup_stalker_load_series_first_description">Manter os filmes na fila até terminar o carregamento das séries.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-ro/strings.xml b/feature/provider/src/main/res/values-ro/strings.xml
index 41497fbd..f76b80c0 100644
--- a/feature/provider/src/main/res/values-ro/strings.xml
+++ b/feature/provider/src/main/res/values-ro/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">Încarcă rafturile și categoriile când sunt deschise. Păstrează titlurile din memoria cache.</string>
<string name="setup_stalker_catalog_background_title">Indexare completă în fundal (recomandată)</string>
<string name="setup_stalker_catalog_background_description">Finalizează mai întâi configurarea furnizorului, apoi indexează în fundal toate filmele și serialele pentru a le putea căuta.</string>
+ <string name="setup_stalker_load_order_title">Ordinea încărcării în fundal</string>
+ <string name="setup_stalker_load_parallel_title">Ambele simultan (implicit)</string>
+ <string name="setup_stalker_load_parallel_description">Încarcă filmele și serialele simultan.</string>
+ <string name="setup_stalker_load_movies_first_title">Mai întâi filmele</string>
+ <string name="setup_stalker_load_movies_first_description">Serialele rămân în așteptare până se termină încărcarea filmelor.</string>
+ <string name="setup_stalker_load_series_first_title">Mai întâi serialele</string>
+ <string name="setup_stalker_load_series_first_description">Filmele rămân în așteptare până se termină încărcarea serialelor.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-ru/strings.xml b/feature/provider/src/main/res/values-ru/strings.xml
index 723d4547..896f6011 100644
--- a/feature/provider/src/main/res/values-ru/strings.xml
+++ b/feature/provider/src/main/res/values-ru/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">Полки и категории загружаются при открытии. Загруженные в кэш названия сохраняются.</string>
<string name="setup_stalker_catalog_background_title">Полная фоновая индексация (рекомендуется)</string>
<string name="setup_stalker_catalog_background_description">Сначала завершите настройку провайдера, затем проиндексируйте все фильмы и сериалы в фоне, чтобы их можно было найти через поиск.</string>
+ <string name="setup_stalker_load_order_title">Порядок загрузки в фоне</string>
+ <string name="setup_stalker_load_parallel_title">Одновременно (по умолчанию)</string>
+ <string name="setup_stalker_load_parallel_description">Загружать фильмы и сериалы одновременно.</string>
+ <string name="setup_stalker_load_movies_first_title">Сначала фильмы</string>
+ <string name="setup_stalker_load_movies_first_description">Сериалы остаются в очереди до завершения загрузки фильмов.</string>
+ <string name="setup_stalker_load_series_first_title">Сначала сериалы</string>
+ <string name="setup_stalker_load_series_first_description">Фильмы остаются в очереди до завершения загрузки сериалов.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-sk/strings.xml b/feature/provider/src/main/res/values-sk/strings.xml
index dde10e14..709a951a 100644
--- a/feature/provider/src/main/res/values-sk/strings.xml
+++ b/feature/provider/src/main/res/values-sk/strings.xml
@@ -129,4 +129,11 @@
<string name="setup_stalker_catalog_on_demand_description">Police a kategórie sa načítajú po otvorení. Tituly vo vyrovnávacej pamäti zostanú zachované.</string>
<string name="setup_stalker_catalog_background_title">Úplné indexovanie na pozadí (odporúčané)</string>
<string name="setup_stalker_catalog_background_description">Najprv dokončite nastavenie poskytovateľa a potom na pozadí zaindexujte všetky filmy a seriály, aby sa dali vyhľadávať.</string>
+ <string name="setup_stalker_load_order_title">Poradie načítavania na pozadí</string>
+ <string name="setup_stalker_load_parallel_title">Oboje súčasne (predvolené)</string>
+ <string name="setup_stalker_load_parallel_description">Načítavať filmy a seriály súčasne.</string>
+ <string name="setup_stalker_load_movies_first_title">Najprv filmy</string>
+ <string name="setup_stalker_load_movies_first_description">Seriály čakajú vo fronte, kým sa nenačítajú filmy.</string>
+ <string name="setup_stalker_load_series_first_title">Najprv seriály</string>
+ <string name="setup_stalker_load_series_first_description">Filmy čakajú vo fronte, kým sa nenačítajú seriály.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-sq/strings.xml b/feature/provider/src/main/res/values-sq/strings.xml
index dc9cbd47..0ea77632 100644
--- a/feature/provider/src/main/res/values-sq/strings.xml
+++ b/feature/provider/src/main/res/values-sq/strings.xml
@@ -129,4 +129,11 @@
<string name="setup_stalker_catalog_on_demand_description">Raftet dhe kategoritë ngarkohen kur hapen. Titujt e ruajtur në memorien e përkohshme mbahen.</string>
<string name="setup_stalker_catalog_background_title">Indeksim i plotë në sfond (i rekomanduar)</string>
<string name="setup_stalker_catalog_background_description">Përfundoni fillimisht konfigurimin e ofruesit, pastaj indeksoni në sfond të gjithë filmat dhe serialet për t’i kërkuar.</string>
+ <string name="setup_stalker_load_order_title">Rendi i ngarkimit në sfond</string>
+ <string name="setup_stalker_load_parallel_title">Të dyja bashkë (parazgjedhje)</string>
+ <string name="setup_stalker_load_parallel_description">Ngarko filmat dhe serialet njëkohësisht.</string>
+ <string name="setup_stalker_load_movies_first_title">Filmat së pari</string>
+ <string name="setup_stalker_load_movies_first_description">Mbaji serialet në radhë derisa të përfundojë ngarkimi i filmave.</string>
+ <string name="setup_stalker_load_series_first_title">Serialet së pari</string>
+ <string name="setup_stalker_load_series_first_description">Mbaji filmat në radhë derisa të përfundojë ngarkimi i serialeve.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-sr/strings.xml b/feature/provider/src/main/res/values-sr/strings.xml
index 916651b9..785d2813 100644
--- a/feature/provider/src/main/res/values-sr/strings.xml
+++ b/feature/provider/src/main/res/values-sr/strings.xml
@@ -129,4 +129,11 @@
<string name="setup_stalker_catalog_on_demand_description">Полице и категорије се учитавају када их отворите. Кеширани наслови се чувају.</string>
<string name="setup_stalker_catalog_background_title">Потпуно индексирање у позадини (препоручено)</string>
<string name="setup_stalker_catalog_background_description">Прво довршите подешавање провајдера, а затим у позадини индексирајте све филмове и серије да бисте могли да их претражујете.</string>
+ <string name="setup_stalker_load_order_title">Редослед учитавања у позадини</string>
+ <string name="setup_stalker_load_parallel_title">Оба истовремено (подразумевано)</string>
+ <string name="setup_stalker_load_parallel_description">Учитавај филмове и серије истовремено.</string>
+ <string name="setup_stalker_load_movies_first_title">Прво филмови</string>
+ <string name="setup_stalker_load_movies_first_description">Серије чекају у реду док се филмови не учитају.</string>
+ <string name="setup_stalker_load_series_first_title">Прво серије</string>
+ <string name="setup_stalker_load_series_first_description">Филмови чекају у реду док се серије не учитају.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-sv/strings.xml b/feature/provider/src/main/res/values-sv/strings.xml
index 449a49db..9a097ccc 100644
--- a/feature/provider/src/main/res/values-sv/strings.xml
+++ b/feature/provider/src/main/res/values-sv/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">Läs in hyllor och kategorier när de öppnas. Behåll titlar i cacheminnet.</string>
<string name="setup_stalker_catalog_background_title">Fullständig bakgrundsindexering (rekommenderas)</string>
<string name="setup_stalker_catalog_background_description">Slutför först konfigurationen av leverantören och indexera sedan alla filmer och serier i bakgrunden så att de går att söka efter.</string>
+ <string name="setup_stalker_load_order_title">Inläsningsordning i bakgrunden</string>
+ <string name="setup_stalker_load_parallel_title">Båda samtidigt (standard)</string>
+ <string name="setup_stalker_load_parallel_description">Läs in filmer och serier samtidigt.</string>
+ <string name="setup_stalker_load_movies_first_title">Filmer först</string>
+ <string name="setup_stalker_load_movies_first_description">Låt serier vänta i kön tills filmerna har lästs in.</string>
+ <string name="setup_stalker_load_series_first_title">Serier först</string>
+ <string name="setup_stalker_load_series_first_description">Låt filmer vänta i kön tills serierna har lästs in.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-th/strings.xml b/feature/provider/src/main/res/values-th/strings.xml
index 83b8101c..34cb7105 100644
--- a/feature/provider/src/main/res/values-th/strings.xml
+++ b/feature/provider/src/main/res/values-th/strings.xml
@@ -129,4 +129,11 @@
<string name="setup_stalker_catalog_on_demand_description">โหลดชั้นวางและหมวดหมู่เมื่อเปิด เก็บชื่อเรื่องที่อยู่ในแคชไว้</string>
<string name="setup_stalker_catalog_background_title">จัดทำดัชนีเบื้องหลังทั้งหมด (แนะนำ)</string>
<string name="setup_stalker_catalog_background_description">ตั้งค่าผู้ให้บริการให้เสร็จก่อน จากนั้นจัดทำดัชนีภาพยนตร์และซีรีส์ทั้งหมดเบื้องหลังเพื่อให้ค้นหาได้</string>
+ <string name="setup_stalker_load_order_title">ลำดับการโหลดเบื้องหลัง</string>
+ <string name="setup_stalker_load_parallel_title">ทั้งสองพร้อมกัน (ค่าเริ่มต้น)</string>
+ <string name="setup_stalker_load_parallel_description">โหลดภาพยนตร์และซีรีส์พร้อมกัน</string>
+ <string name="setup_stalker_load_movies_first_title">ภาพยนตร์ก่อน</string>
+ <string name="setup_stalker_load_movies_first_description">ให้ซีรีส์รอในคิวจนกว่าจะโหลดภาพยนตร์เสร็จ</string>
+ <string name="setup_stalker_load_series_first_title">ซีรีส์ก่อน</string>
+ <string name="setup_stalker_load_series_first_description">ให้ภาพยนตร์รอในคิวจนกว่าจะโหลดซีรีส์เสร็จ</string>
</resources>
diff --git a/feature/provider/src/main/res/values-tr/strings.xml b/feature/provider/src/main/res/values-tr/strings.xml
index f96e415e..1434713d 100644
--- a/feature/provider/src/main/res/values-tr/strings.xml
+++ b/feature/provider/src/main/res/values-tr/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">Rafları ve kategorileri açıldıklarında yükler. Önbelleğe alınan başlıkları korur.</string>
<string name="setup_stalker_catalog_background_title">Tam arka plan dizini (önerilen)</string>
<string name="setup_stalker_catalog_background_description">Önce sağlayıcı kurulumunu tamamlayın, ardından aranabilmeleri için tüm filmleri ve dizileri arka planda dizine ekleyin.</string>
+ <string name="setup_stalker_load_order_title">Arka planda yükleme sırası</string>
+ <string name="setup_stalker_load_parallel_title">İkisi birlikte (varsayılan)</string>
+ <string name="setup_stalker_load_parallel_description">Filmleri ve dizileri birlikte yükle.</string>
+ <string name="setup_stalker_load_movies_first_title">Önce filmler</string>
+ <string name="setup_stalker_load_movies_first_description">Filmlerin yüklenmesi bitene kadar dizileri kuyrukta tut.</string>
+ <string name="setup_stalker_load_series_first_title">Önce diziler</string>
+ <string name="setup_stalker_load_series_first_description">Dizilerin yüklenmesi bitene kadar filmleri kuyrukta tut.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-uk/strings.xml b/feature/provider/src/main/res/values-uk/strings.xml
index cab734ac..315a515d 100644
--- a/feature/provider/src/main/res/values-uk/strings.xml
+++ b/feature/provider/src/main/res/values-uk/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">Полиці й категорії завантажуються під час відкриття. Кешовані назви зберігаються.</string>
<string name="setup_stalker_catalog_background_title">Повна фонова індексація (рекомендовано)</string>
<string name="setup_stalker_catalog_background_description">Спочатку завершіть налаштування провайдера, а потім проіндексуйте у фоновому режимі всі фільми й серіали для пошуку.</string>
+ <string name="setup_stalker_load_order_title">Порядок фонового завантаження</string>
+ <string name="setup_stalker_load_parallel_title">Одночасно (типово)</string>
+ <string name="setup_stalker_load_parallel_description">Завантажувати фільми й серіали одночасно.</string>
+ <string name="setup_stalker_load_movies_first_title">Спочатку фільми</string>
+ <string name="setup_stalker_load_movies_first_description">Серіали залишаються в черзі до завершення завантаження фільмів.</string>
+ <string name="setup_stalker_load_series_first_title">Спочатку серіали</string>
+ <string name="setup_stalker_load_series_first_description">Фільми залишаються в черзі до завершення завантаження серіалів.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-vi/strings.xml b/feature/provider/src/main/res/values-vi/strings.xml
index f23c7720..60a7419f 100644
--- a/feature/provider/src/main/res/values-vi/strings.xml
+++ b/feature/provider/src/main/res/values-vi/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">Tải kệ và danh mục khi mở. Giữ lại các tựa đã lưu trong bộ nhớ đệm.</string>
<string name="setup_stalker_catalog_background_title">Lập chỉ mục nền đầy đủ (đề xuất)</string>
<string name="setup_stalker_catalog_background_description">Hoàn tất thiết lập nhà cung cấp trước, sau đó lập chỉ mục tất cả phim và bộ phim trong nền để có thể tìm kiếm.</string>
+ <string name="setup_stalker_load_order_title">Thứ tự tải trong nền</string>
+ <string name="setup_stalker_load_parallel_title">Cả hai cùng lúc (mặc định)</string>
+ <string name="setup_stalker_load_parallel_description">Tải phim và phim bộ cùng lúc.</string>
+ <string name="setup_stalker_load_movies_first_title">Phim trước</string>
+ <string name="setup_stalker_load_movies_first_description">Giữ phim bộ trong hàng đợi cho đến khi tải xong phim.</string>
+ <string name="setup_stalker_load_series_first_title">Phim bộ trước</string>
+ <string name="setup_stalker_load_series_first_description">Giữ phim trong hàng đợi cho đến khi tải xong phim bộ.</string>
</resources>
diff --git a/feature/provider/src/main/res/values-zh-rTW/strings.xml b/feature/provider/src/main/res/values-zh-rTW/strings.xml
index f9de7b55..eb6ae794 100644
--- a/feature/provider/src/main/res/values-zh-rTW/strings.xml
+++ b/feature/provider/src/main/res/values-zh-rTW/strings.xml
@@ -128,4 +128,11 @@
<string name="setup_stalker_catalog_on_demand_description">開啟時載入各區和類別。保留已快取的片名。</string>
<string name="setup_stalker_catalog_background_title">完整背景索引(建議)</string>
<string name="setup_stalker_catalog_background_description">先完成供應商設定,再於背景為所有電影與影集建立索引,方便搜尋。</string>
+ <string name="setup_stalker_load_order_title">背景載入順序</string>
+ <string name="setup_stalker_load_parallel_title">同時載入(預設)</string>
+ <string name="setup_stalker_load_parallel_description">同時載入電影和影集。</string>
+ <string name="setup_stalker_load_movies_first_title">電影優先</string>
+ <string name="setup_stalker_load_movies_first_description">電影載入完成前,影集保持排隊。</string>
+ <string name="setup_stalker_load_series_first_title">影集優先</string>
+ <string name="setup_stalker_load_series_first_description">影集載入完成前,電影保持排隊。</string>
</resources>
diff --git a/feature/provider/src/main/res/values-zh/strings.xml b/feature/provider/src/main/res/values-zh/strings.xml
index cf197410..a66cffdf 100644
--- a/feature/provider/src/main/res/values-zh/strings.xml
+++ b/feature/provider/src/main/res/values-zh/strings.xml
@@ -125,4 +125,11 @@
<string name="setup_stalker_catalog_on_demand_description">打开时加载各栏和类别。保留已缓存的标题。</string>
<string name="setup_stalker_catalog_background_title">完整后台索引(推荐)</string>
<string name="setup_stalker_catalog_background_description">先完成服务商设置,然后在后台为所有电影和剧集建立索引,以便搜索。</string>
+ <string name="setup_stalker_load_order_title">后台加载顺序</string>
+ <string name="setup_stalker_load_parallel_title">同时加载(默认)</string>
+ <string name="setup_stalker_load_parallel_description">同时加载电影和剧集。</string>
+ <string name="setup_stalker_load_movies_first_title">电影优先</string>
+ <string name="setup_stalker_load_movies_first_description">电影加载完成前,剧集保持排队。</string>
+ <string name="setup_stalker_load_series_first_title">剧集优先</string>
+ <string name="setup_stalker_load_series_first_description">剧集加载完成前,电影保持排队。</string>
</resources>
diff --git a/feature/provider/src/main/res/values/strings.xml b/feature/provider/src/main/res/values/strings.xml
index 71622004..73133be1 100644
--- a/feature/provider/src/main/res/values/strings.xml
+++ b/feature/provider/src/main/res/values/strings.xml
@@ -128,4 +128,11 @@
<string name="setup_stalker_catalog_on_demand_description">Load shelves and categories when opened. Keep cached titles.</string>
<string name="setup_stalker_catalog_background_title">Complete background index (recommended)</string>
<string name="setup_stalker_catalog_background_description">Finish provider setup first, then index all movie and series titles in the background so you can search them.</string>
+ <string name="setup_stalker_load_order_title">Background loading order</string>
+ <string name="setup_stalker_load_parallel_title">Both together (default)</string>
+ <string name="setup_stalker_load_parallel_description">Load movies and series together.</string>
+ <string name="setup_stalker_load_movies_first_title">Movies first</string>
+ <string name="setup_stalker_load_movies_first_description">Keep series queued until movies finish.</string>
+ <string name="setup_stalker_load_series_first_title">Series first</string>
+ <string name="setup_stalker_load_series_first_description">Keep movies queued until series finish.</string>
</resources>
diff --git a/feature/provider/src/test/java/com/streamvault/feature/provider/setup/ProviderSetupViewModelTest.kt b/feature/provider/src/test/java/com/streamvault/feature/provider/setup/ProviderSetupViewModelTest.kt
index 935ce85a..ff496850 100644
--- a/feature/provider/src/test/java/com/streamvault/feature/provider/setup/ProviderSetupViewModelTest.kt
+++ b/feature/provider/src/test/java/com/streamvault/feature/provider/setup/ProviderSetupViewModelTest.kt
@@ -73,6 +73,30 @@ class ProviderSetupViewModelTest {
Dispatchers.resetMain()
}
+ @Test
+ fun `editing restores saved Stalker loading order while new providers default to parallel`() = runTest {
+ for (order in com.streamvault.domain.model.StalkerCatalogLoadOrder.entries) {
+ whenever(providerRepository.getProvider(7L)).thenReturn(Provider(
+ id = 7L, name = "Portal", type = ProviderType.STALKER_PORTAL, serverUrl = "https://portal.invalid",
+ stalkerAdvancedOptionsJson = ProviderStalkerAdvancedOptionsCodec.encode(
+ ProviderStalkerAdvancedOptions(hwVersion = "custom", catalogLoadOrder = order))))
+ val viewModel = ProviderSetupViewModel(
+ providerRepository = providerRepository,
+ combinedM3uRepository = combinedM3uRepository,
+ validateAndAddProvider = validateAndAddProvider,
+ importBackup = importBackup,
+ driveBackupSyncManager = driveBackupSyncManager,
+ providerQrPairingManager = providerQrPairingManager)
+ assertThat(viewModel.uiState.value.stalkerCatalogLoadOrder)
+ .isEqualTo(com.streamvault.domain.model.StalkerCatalogLoadOrder.PARALLEL)
+ viewModel.loadProvider(7L)
+ advanceUntilIdle()
+ assertThat(viewModel.uiState.value.stalkerCatalogLoadOrder).isEqualTo(order)
+ assertThat(ProviderStalkerAdvancedOptionsCodec.decode(viewModel.uiState.value.stalkerAdvancedOptionsJson).hwVersion)
+ .isEqualTo("custom")
+ }
+ }
+
@Test
fun `adding m3u while combined source is active prepares attach prompt with names`() = runTest {
val createdProvider = Provider(
diff --git a/feature/provider/src/test/java/com/streamvault/feature/provider/setup/ProviderStalkerAdvancedOptionsCodecTest.kt b/feature/provider/src/test/java/com/streamvault/feature/provider/setup/ProviderStalkerAdvancedOptionsCodecTest.kt
index 4f3fa892..45b4397a 100644
--- a/feature/provider/src/test/java/com/streamvault/feature/provider/setup/ProviderStalkerAdvancedOptionsCodecTest.kt
+++ b/feature/provider/src/test/java/com/streamvault/feature/provider/setup/ProviderStalkerAdvancedOptionsCodecTest.kt
@@ -4,6 +4,18 @@ import com.google.common.truth.Truth.assertThat
import org.junit.Test
class ProviderStalkerAdvancedOptionsCodecTest {
+ @Test
+ fun `loading order defaults to parallel and survives editing alongside portal options`() {
+ assertThat(ProviderStalkerAdvancedOptionsCodec.decode("").catalogLoadOrder)
+ .isEqualTo(com.streamvault.domain.model.StalkerCatalogLoadOrder.PARALLEL)
+ for (order in com.streamvault.domain.model.StalkerCatalogLoadOrder.entries) {
+ val options = ProviderStalkerAdvancedOptions(hwVersion = "custom", proxyHost = "proxy.example.com", catalogLoadOrder = order)
+ val restored = ProviderStalkerAdvancedOptionsCodec.decode(ProviderStalkerAdvancedOptionsCodec.encode(options))
+ assertThat(restored).isEqualTo(options)
+ assertThat(restored.copy(playerUserAgent = "changed").catalogLoadOrder).isEqualTo(order)
+ }
+ }
+
@Test
fun `encode preserves the persisted Stalker options wire format`() {
val encoded = ProviderStalkerAdvancedOptionsCodec.encode(