StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
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.ktnew file mode 100644index 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.ktsindex 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.ktindex 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.Contextimport androidx.test.core.app.ApplicationProviderimport androidx.test.ext.junit.runners.AndroidJUnit4import androidx.work.Configuration+import androidx.work.ExistingWorkPolicy+import androidx.work.OneTimeWorkRequestBuilder+import androidx.work.Worker+import androidx.work.WorkerParametersimport androidx.work.WorkInfoimport androidx.work.WorkManagerimport androidx.work.testing.WorkManagerTestInitHelper@@ -11,8 +15,9 @@ import com.google.common.truth.Truth.assertThatimport com.streamvault.data.sync.BackgroundEpgSyncWorkerimport com.streamvault.data.sync.ProviderSyncWorkerimport com.streamvault.data.sync.StalkerIndexWorker-import com.streamvault.data.sync.XtreamIndexWorkerimport com.streamvault.data.sync.providerWorkUniqueName+import com.streamvault.data.sync.providerEpgWorkUniqueName+import com.streamvault.data.sync.stalkerIndexWorkUniqueNameimport org.junit.Beforeimport org.junit.Testimport org.junit.runner.RunWith@@ -39,28 +44,59 @@ class ProviderWorkManagerSerializationTest {}@Test- fun everyBackgroundPhaseForAProviderIsAppendedToOneSerialChain() {+ fun catalogContinuationIsNotDroppedBehindProviderSetupAndGuide() {val providerId = 71LProviderSyncWorker.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.ktindex 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): Intdiff --git a/data/src/main/java/com/streamvault/data/provider/StalkerLearningMapper.kt b/data/src/main/java/com/streamvault/data/provider/StalkerLearningMapper.ktindex 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.ktindex 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.ktindex 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.booleanOrNullimport kotlinx.serialization.json.intOrNullimport kotlinx.serialization.json.jsonObjectimport kotlinx.serialization.json.jsonPrimitive+import com.streamvault.domain.model.StalkerCatalogLoadOrder@Serializabledata 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: Stringget() = when {@@ -79,6 +81,7 @@ object StalkerAdvancedOptionsCodec {@OptIn(ExperimentalSerializationApi::class)private val json = Json {ignoreUnknownKeys = true+ coerceInputValues = trueencodeDefaults = trueexplicitNulls = 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.ktindex 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.ktindex 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.ktindex 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? = nullprivate 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.dataval 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.ktindex 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.INDEXval 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 0Lval 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.ktindex 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.ktindex 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 requestval current = movieCategoryHydrationDao.get(providerId, categoryId)val requestedPage = if (effectiveRequest == VodCategoryHydrationRequest.NEXT_PAGE) {((current?.lastSuccessfulPage ?: 0) + 1).coerceAtLeast(1)} else nullif (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 falseval now = System.currentTimeMillis()val hasEmptySuccessfulCheckpoint = localCount == 0 &&(hydration?.lastSuccessfulPage ?: hydration?.lastLoadedPage ?: 0) > 0diff --git a/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.kt b/data/src/main/java/com/streamvault/data/repository/SeriesRepositoryImpl.ktindex 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 requestval 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 falseval 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 falseif (detailHydratedAt <= 0L) return falseif (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.ktindex 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.ktnew file mode 100644index 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.ktindex 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.ktindex 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.ktindex 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.ktindex 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.KeyedMutexRegistryimport java.util.concurrent.atomic.AtomicIntegerimport kotlinx.coroutines.sync.Muteximport kotlinx.coroutines.sync.withLock+import kotlinx.coroutines.NonCancellable+import kotlinx.coroutines.withContextimport javax.inject.Injectimport 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.*/@Singletonclass 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.ktindex 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.ktnew file mode 100644index 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.ktindex 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 = trueseriesCategoryCount = 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.ktindex 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.CategoryEntityimport com.streamvault.data.local.entity.StalkerIndexJobEntityimport com.streamvault.data.remote.stalker.StalkerPagedResultimport com.streamvault.data.remote.stalker.StalkerProvider-import com.streamvault.data.remote.stalker.StalkerTelemetry-import com.streamvault.data.remote.stalker.StalkerTrafficCoordinatorimport com.streamvault.data.remote.stalker.StalkerVodCatalogItemimport com.streamvault.domain.model.CatalogLayoutimport com.streamvault.domain.model.ContentType@@ -15,17 +13,6 @@ import com.streamvault.domain.model.Movieimport com.streamvault.domain.model.Resultimport com.streamvault.domain.model.Seriesimport 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.ktindex 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: CatalogSyncRuntimeProfileget() = 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.ktindex 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 = 3const 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.ktindex 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.ProviderEpgSyncModeimport com.streamvault.domain.model.ProviderTypeimport com.streamvault.domain.model.StalkerCatalogModeimport 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).catalogLoadOrderreturn 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.ktindex 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.StalkerVodCatalogItemimport com.streamvault.data.remote.stalker.StalkerPagedResultimport com.streamvault.domain.model.CatalogLayoutimport com.streamvault.domain.model.ContentType+import com.streamvault.domain.model.StalkerCatalogLoadOrderimport com.streamvault.domain.model.Movieimport com.streamvault.domain.model.Seriesimport 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.ktindex 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.ktnew file mode 100644index 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.ktindex 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.StalkerApiServiceimport com.streamvault.data.remote.stalker.StalkerApiErrorimport com.streamvault.data.remote.stalker.StalkerPlaybackModeimport com.streamvault.data.remote.stalker.StalkerProvider+import com.streamvault.data.remote.stalker.StalkerAdvancedOptionsCodecimport com.streamvault.data.remote.stalker.StalkerVodCatalogItemimport com.streamvault.data.remote.stalker.StalkerRemoteIdentityResolverimport 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) returnif (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 0Lif (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.ktindex 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.syncimport com.streamvault.domain.model.ContentType+import com.streamvault.data.local.DatabaseTransactionRunnerimport com.streamvault.domain.model.SyncMetadataimport com.streamvault.domain.model.SyncStateimport com.streamvault.domain.model.VodSyncMode@@ -19,7 +20,8 @@ import java.util.concurrent.ConcurrentHashMapinternal 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.ktnew file mode 100644index 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.ktindex 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.ktnew file mode 100644index 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.ktindex 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.Testimport java.util.Base64class 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")+ }@Testfun `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.ktindex 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.Successval 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() }+ }+@Testfun 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.ktindex 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.ktindex 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.Testclass 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.ktindex 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.stalkerStableHashIdimport com.streamvault.data.remote.dto.XtreamCategoryimport com.streamvault.data.remote.dto.XtreamStreamimport com.streamvault.data.remote.stalker.StalkerApiService+import com.streamvault.data.remote.stalker.delegateSortedPagingToBasicStubsimport com.streamvault.data.remote.xtream.XtreamApiServiceimport com.streamvault.data.remote.xtream.XtreamStreamUrlResolverimport 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.ktindex 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.StalkerSessionimport com.streamvault.data.remote.dto.XtreamCategoryimport com.streamvault.data.remote.dto.XtreamSeriesItemimport com.streamvault.data.remote.stalker.StalkerApiService+import com.streamvault.data.remote.stalker.delegateSortedPagingToBasicStubsimport com.streamvault.data.remote.xtream.XtreamParsingExceptionimport com.streamvault.data.remote.xtream.XtreamApiServiceimport com.streamvault.data.remote.xtream.XtreamStreamUrlResolver@@ -112,6 +113,7 @@ class SeriesRepositoryImplTest {@Beforefun clearStalkerCaches() {+ kotlinx.coroutines.runBlocking { stalkerApiService.delegateSortedPagingToBasicStubs() }StalkerProvider.clearSharedAuthCacheForTests()StalkerProvider.clearResolvedStreamUrlCacheForTests()}@@ -644,6 +646,7 @@ class SeriesRepositoryImplTest {@Testfun `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.ktindex 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.verifyimport org.mockito.kotlin.verifyNoInteractionsimport org.mockito.kotlin.wheneverimport org.mockito.kotlin.timeout+import org.mockito.kotlin.neverclass 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)}@Testdiff --git a/data/src/test/java/com/streamvault/data/sync/BackgroundEpgExecutionTest.kt b/data/src/test/java/com/streamvault/data/sync/BackgroundEpgExecutionTest.ktnew file mode 100644index 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.ktindex 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.Testclass 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)}@Testdiff --git a/data/src/test/java/com/streamvault/data/sync/StalkerCatalogExecutionTest.kt b/data/src/test/java/com/streamvault/data/sync/StalkerCatalogExecutionTest.ktnew file mode 100644index 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.ktindex 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.Testclass 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()}@Testfun 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? = nullval 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 = 0private 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?) = Unitdiff --git a/data/src/test/java/com/streamvault/data/sync/SyncManagerTest.kt b/data/src/test/java/com/streamvault/data/sync/SyncManagerTest.ktindex 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.StalkerRemoteIdentityResolverimport com.streamvault.data.remote.stalker.stalkerStableHashIdimport com.streamvault.data.remote.stalker.StalkerSessionimport com.streamvault.data.remote.stalker.StalkerApiService+import com.streamvault.data.remote.stalker.delegateSortedPagingToBasicStubsimport com.streamvault.data.remote.stalker.StalkerAdvancedOptionsimport com.streamvault.data.remote.stalker.StalkerAdvancedOptionsCodecimport 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())}@Testdiff --git a/data/src/test/java/com/streamvault/data/sync/SyncStatusPublicationCoordinatorTest.kt b/data/src/test/java/com/streamvault/data/sync/SyncStatusPublicationCoordinatorTest.ktindex 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.SyncMetadataRepositoryimport kotlinx.coroutines.flow.Flowimport kotlinx.coroutines.flow.flowOfimport kotlinx.coroutines.test.runTest+import kotlinx.coroutines.launchimport org.junit.Testclass 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)+ }+@Testfun `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.ktindex 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.ktindex 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.ktindex 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 CategorySortModeSeriesCategorySelectionDependencies(+ 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.ktindex 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.ProviderEpgSyncModeimport com.streamvault.domain.model.ProviderXtreamLiveSyncModeimport com.streamvault.domain.model.StalkerAuthModeimport com.streamvault.domain.model.StalkerCatalogMode+import com.streamvault.domain.model.StalkerCatalogLoadOrder@Composableinternal 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.ktindex 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.ProviderEpgSyncModeimport com.streamvault.domain.model.ProviderXtreamLiveSyncModeimport com.streamvault.domain.model.StalkerAuthModeimport 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.ktindex 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.ProviderEpgSyncModeimport com.streamvault.domain.model.ProviderXtreamLiveSyncModeimport com.streamvault.domain.model.StalkerAuthModeimport com.streamvault.domain.model.StalkerCatalogMode+import com.streamvault.domain.model.StalkerCatalogLoadOrderimport 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.ktindex 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.ktindex 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.ProviderXtreamLiveSyncModeimport com.streamvault.domain.model.ProviderTypeimport com.streamvault.domain.model.StalkerAuthModeimport com.streamvault.domain.model.StalkerCatalogMode+import com.streamvault.domain.model.StalkerCatalogLoadOrderimport com.streamvault.domain.model.StalkerCompatibilityProfileIdsimport com.streamvault.domain.model.StalkerProtocolPreferenceimport 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.ktindex 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.jsonArrayimport kotlinx.serialization.json.jsonObjectimport kotlinx.serialization.json.jsonPrimitiveimport kotlinx.serialization.json.put+import com.streamvault.domain.model.StalkerCatalogLoadOrderinternal 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: Stringget() = 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.xmlindex 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.ktindex 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")+ }+ }+@Testfun `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.ktindex 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.assertThatimport org.junit.Testclass 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)+ }+ }+@Testfun `encode preserves the persisted Stalker options wire format`() {val encoded = ProviderStalkerAdvancedOptionsCodec.encode(