Skip to content

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

feat: improve sports provider discovery and event details

David Nashashda6a481e1404
diff --git a/data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt b/data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt
index e8ff5c5d..24bbb93b 100644
--- a/data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt
+++ b/data/src/main/java/com/streamvault/data/preferences/PreferencesRepository.kt
@@ -15,6 +15,7 @@ import androidx.datastore.preferences.core.edit
import androidx.datastore.preferences.core.emptyPreferences
import androidx.datastore.preferences.core.intPreferencesKey
import androidx.datastore.preferences.core.longPreferencesKey
+import androidx.datastore.preferences.core.stringSetPreferencesKey
import androidx.datastore.preferences.core.stringPreferencesKey
import androidx.datastore.preferences.preferencesDataStoreFile
import com.streamvault.data.local.dao.ChannelPreferenceDao
@@ -242,6 +243,35 @@ class PreferencesRepository @Inject constructor(
}.toMap()
}
+ fun getExcludedSports(): Flow<Set<String>> = preferencesDataStore.data.map {
+ it[stringSetPreferencesKey("sports_excluded_sports")].orEmpty()
+ }
+
+ fun getExcludedSportsLeagues(): Flow<Set<String>> = preferencesDataStore.data.map {
+ it[stringSetPreferencesKey("sports_excluded_leagues")].orEmpty()
+ }
+
+ suspend fun setSportsSportIncluded(sport: String, included: Boolean) {
+ preferencesDataStore.edit { values ->
+ val key = stringSetPreferencesKey("sports_excluded_sports")
+ values[key] = if (included) values[key].orEmpty() - sport else values[key].orEmpty() + sport
+ }
+ }
+
+ suspend fun setSportsLeagueIncluded(league: String, included: Boolean) {
+ preferencesDataStore.edit { values ->
+ val key = stringSetPreferencesKey("sports_excluded_leagues")
+ values[key] = if (included) values[key].orEmpty() - league else values[key].orEmpty() + league
+ }
+ }
+
+ suspend fun resetSportsInclusions() {
+ preferencesDataStore.edit { values ->
+ values.remove(stringSetPreferencesKey("sports_excluded_sports"))
+ values.remove(stringSetPreferencesKey("sports_excluded_leagues"))
+ }
+ }
+
override val eventSourcePreference: Flow<SportsEventSourcePreference> = preferencesDataStore.data.map { values ->
val mode = values[PreferencesKeys.SPORTS_EVENT_SOURCE_MODE]
?.let { saved -> SportsEventSourceMode.entries.firstOrNull { it.name == saved } }
diff --git a/data/src/main/java/com/streamvault/data/sports/custom/CustomSportsProvider.kt b/data/src/main/java/com/streamvault/data/sports/custom/CustomSportsProvider.kt
index 96588747..986cd926 100644
--- a/data/src/main/java/com/streamvault/data/sports/custom/CustomSportsProvider.kt
+++ b/data/src/main/java/com/streamvault/data/sports/custom/CustomSportsProvider.kt
@@ -8,8 +8,16 @@ import java.time.Instant
import java.time.LocalDate
import java.time.ZoneOffset
import java.time.format.DateTimeFormatter
+import java.util.concurrent.ConcurrentHashMap
import javax.inject.Inject
import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Semaphore
+import kotlinx.coroutines.sync.withPermit
+import kotlinx.coroutines.withTimeoutOrNull
+import kotlinx.coroutines.withContext
import kotlinx.serialization.json.*
import okhttp3.HttpUrl
import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
@@ -21,7 +29,7 @@ class CustomSportsProviderFactory @Inject constructor(
) : SportsProviderFactory {
override val descriptor = SportsProviderDescriptor(
typeId = CUSTOM_SPORTS_PROVIDER_TYPE_ID,
- capabilities = setOf(SportsCapability.EVENTS, SportsCapability.LIVE_SCORES),
+ capabilities = SportsCapability.entries.toSet(),
auth = SportsProviderAuth.None,
displayName = null,
configurationVersion = 1,
@@ -51,7 +59,10 @@ internal class CustomSportsProvider(
private val definition: CustomSportsProviderDefinition,
private val httpClient: SportsProviderHttpClient,
private val store: SportsProviderStore,
-) : EventProvider, LiveScoreProvider, SportsProviderConnectionTester {
+ private val eventLoadTimeoutMillis: Long = EVENT_LOAD_TIMEOUT_MS,
+) : EventProvider, LiveScoreProvider, GameStatusProvider, StandingsProvider, BroadcastProvider,
+ TeamMetadataProvider, LeagueMetadataProvider, ArtworkProvider, LineupProvider,
+ StatisticsProvider, SportsProviderConnectionTester {
override val instanceId: String = config.instanceId
override suspend fun testConnection(
@@ -59,17 +70,31 @@ internal class CustomSportsProvider(
): SportsProviderResult<Unit> {
val mapping = definition.events
val now = Instant.now()
+ val configuredScope = if (config.eventLeagueIds.isEmpty()) {
+ definition.scopes.firstOrNull()
+ } else {
+ val resolved = resolveScope(null, config.eventLeagueIds.first(), mapping.endpoint)
+ definition.scopes.firstOrNull { it.sport == resolved.sport && it.leagueId == resolved.leagueId }
+ }
+ val request = ProviderEventRequest(
+ now,
+ now.plusSeconds(TEST_WINDOW_SECONDS),
+ sport = configuredScope?.sport,
+ leagueId = config.eventLeagueIds.firstOrNull() ?: configuredScope?.leagueId,
+ )
+ val scope = resolveScope(request.sport, request.leagueId, mapping.endpoint)
return when (val response = fetchJson(
mapping.endpoint,
- eventVariables(
- ProviderEventRequest(now, now.plusSeconds(TEST_WINDOW_SECONDS), config.eventLeagueIds.firstOrNull()),
- ),
+ eventVariables(request, mapping.dateFormat, mapping.endpoint),
credentials,
)) {
is SportsProviderResult.Failure -> response
is SportsProviderResult.Success -> when (val mapped = CustomSportsProviderJsonMapper.events(
mapping,
response.value,
+ sportFallback = scope.sport,
+ leagueIdFallback = scope.leagueId,
+ leagueNameFallback = configuredScope?.leagueName,
)) {
is SportsProviderResult.Failure -> mapped
is SportsProviderResult.Success -> SportsProviderResult.Success(Unit)
@@ -81,14 +106,78 @@ internal class CustomSportsProvider(
request: ProviderEventRequest,
): SportsProviderResult<ProviderBatch<ProviderEvent>> {
val credentials = storedCredentials()
- val response = fetchJson(definition.events.endpoint, eventVariables(request), credentials)
- return when (response) {
- is SportsProviderResult.Failure -> response
- is SportsProviderResult.Success -> CustomSportsProviderJsonMapper.events(
- definition.events,
- response.value,
- )
+ val scopes = if (request.sport != null || request.leagueId != null) {
+ val resolved = resolveScope(request.sport, request.leagueId, definition.events.endpoint)
+ listOf(definition.scopes.firstOrNull {
+ it.sport == resolved.sport && it.leagueId == resolved.leagueId
+ } ?: CustomSportsProviderScope(sport = resolved.sport, leagueId = resolved.leagueId))
+ } else {
+ definition.scopes.ifEmpty { listOf(CustomSportsProviderScope()) }
}
+ // Keep completed scopes when another route stalls. Indexing results preserves the
+ // definition's precedence (specific leagues before aggregate routes).
+ val requests = if (definition.events.dailyRequests) {
+ val first = LocalDate.ofInstant(request.from, ZoneOffset.UTC)
+ val last = LocalDate.ofInstant(request.until.minusNanos(1), ZoneOffset.UTC)
+ val days = java.time.temporal.ChronoUnit.DAYS.between(first, last) + 1
+ if (days !in 1..MAX_EVENT_DAYS) {
+ return SportsProviderResult.Failure(SportsProviderError.INVALID_CONFIGURATION)
+ }
+ (0 until days).flatMap { offset ->
+ scopes.map { scope -> scope to first.plusDays(offset).atStartOfDay().toInstant(ZoneOffset.UTC) }
+ }
+ } else scopes.map { it to request.from }
+ val results = ConcurrentHashMap<Int, SportsProviderResult<ProviderBatch<ProviderEvent>>>()
+ val permits = Semaphore(MAX_CONCURRENT_EVENT_REQUESTS)
+ withContext(Dispatchers.IO) { withTimeoutOrNull(eventLoadTimeoutMillis) {
+ coroutineScope {
+ requests.forEachIndexed { index, (scope, date) ->
+ launch {
+ permits.withPermit {
+ val scopedRequest = request.copy(from = date, sport = scope.sport, leagueId = scope.leagueId)
+ results[index] = when (val response = fetchJson(
+ definition.events.endpoint,
+ eventVariables(scopedRequest, definition.events.dateFormat, definition.events.endpoint),
+ credentials,
+ )) {
+ is SportsProviderResult.Failure -> response
+ is SportsProviderResult.Success -> CustomSportsProviderJsonMapper.events(
+ definition.events,
+ response.value,
+ sportFallback = scope.sport,
+ leagueIdFallback = scope.leagueId,
+ leagueNameFallback = scope.leagueName,
+ )
+ }
+ }
+ }
+ }
+ }
+ } }
+ val events = mutableListOf<ProviderEvent>()
+ var rejected = 0
+ var lastFailure: SportsProviderResult.Failure? = null
+ var succeeded = false
+ for ((_, mapped) in results.toSortedMap()) {
+ when (mapped) {
+ is SportsProviderResult.Failure -> lastFailure = mapped
+ is SportsProviderResult.Success -> {
+ succeeded = true
+ rejected += mapped.value.rejectedItemCount
+ events += mapped.value.items
+ if (events.size > MAX_COMBINED_EVENT_ROWS) {
+ return SportsProviderResult.Failure(SportsProviderError.RESPONSE_TOO_LARGE)
+ }
+ }
+ }
+ }
+ if (!succeeded) return lastFailure ?: SportsProviderResult.Failure(
+ SportsProviderError.NETWORK,
+ )
+ return SportsProviderResult.Success(ProviderBatch(
+ items = events.distinctBy(ProviderEvent::providerEventId),
+ rejectedItemCount = rejected,
+ ))
}
override suspend fun liveScores(
@@ -101,46 +190,312 @@ internal class CustomSportsProvider(
return SportsProviderResult.Failure(SportsProviderError.RESPONSE_TOO_LARGE)
}
val credentials = storedCredentials()
- val sortedIds = request.eventIds.sorted()
+ // Preserve the caller's live/nearest-game priority within the time budget.
+ val prioritizedIds = request.eventIds.toList()
if (mapping.endpoint.contains("{eventId}")) {
val combined = mutableListOf<ProviderScore>()
var rejected = 0
- for (eventId in sortedIds) {
- val response = fetchJson(mapping.endpoint, mapOf("eventId" to eventId), credentials)
- when (response) {
- is SportsProviderResult.Failure -> return response
- is SportsProviderResult.Success -> when (
- val mapped = CustomSportsProviderJsonMapper.scores(mapping, response.value)
- ) {
- is SportsProviderResult.Failure -> return mapped
- is SportsProviderResult.Success -> {
- combined += mapped.value.items.filter { it.providerEventId == eventId }
- rejected += mapped.value.rejectedItemCount
- if (combined.size > MAX_SCORE_ROWS) {
- return SportsProviderResult.Failure(SportsProviderError.RESPONSE_TOO_LARGE)
+ val results = ConcurrentHashMap<String, SportsProviderResult<ProviderBatch<ProviderScore>>>()
+ val permits = Semaphore(MAX_CONCURRENT_EVENT_REQUESTS)
+ withContext(Dispatchers.IO) { withTimeoutOrNull(SCORE_LOAD_TIMEOUT_MS) {
+ coroutineScope {
+ prioritizedIds.forEach { eventId -> launch {
+ permits.withPermit {
+ val scope = request.eventScopes[eventId] ?: ProviderEventScope()
+ results[eventId] = when (val response = fetchJson(
+ mapping.endpoint,
+ mapOf("eventId" to eventId) + scopedVariables(scope),
+ credentials,
+ )) {
+ is SportsProviderResult.Failure -> response
+ is SportsProviderResult.Success ->
+ CustomSportsProviderJsonMapper.scores(mapping, response.value)
}
}
+ } }
+ }
+ } }
+ var succeeded = false
+ var lastFailure: SportsProviderResult.Failure? = null
+ for ((eventId, mapped) in results.toSortedMap()) {
+ when (mapped) {
+ is SportsProviderResult.Failure -> lastFailure = mapped
+ is SportsProviderResult.Success -> {
+ succeeded = true
+ combined += mapped.value.items.filter { it.providerEventId == eventId }
+ rejected += mapped.value.rejectedItemCount
+ if (combined.size > MAX_SCORE_ROWS) {
+ return SportsProviderResult.Failure(SportsProviderError.RESPONSE_TOO_LARGE)
+ }
}
}
}
+ if (!succeeded) {
+ return lastFailure ?: SportsProviderResult.Failure(SportsProviderError.NETWORK)
+ }
return SportsProviderResult.Success(ProviderBatch(combined, rejected))
}
- val response = fetchJson(
- mapping.endpoint,
- mapOf("eventIds" to sortedIds.joinToString(",")),
- credentials,
+ val groups = if (hasScopePlaceholders(mapping.endpoint)) {
+ prioritizedIds.groupBy { request.eventScopes[it] ?: ProviderEventScope() }
+ } else {
+ mapOf(ProviderEventScope() to prioritizedIds)
+ }
+ val combined = mutableListOf<ProviderScore>()
+ var rejected = 0
+ for ((scope, ids) in groups) {
+ when (val response = fetchJson(
+ mapping.endpoint,
+ mapOf("eventIds" to ids.joinToString(",")) + scopedVariables(scope),
+ credentials,
+ )) {
+ is SportsProviderResult.Failure -> return response
+ is SportsProviderResult.Success -> when (
+ val mapped = CustomSportsProviderJsonMapper.scores(mapping, response.value, ids.toSet())
+ ) {
+ is SportsProviderResult.Failure -> return mapped
+ is SportsProviderResult.Success -> {
+ combined += mapped.value.items
+ rejected += mapped.value.rejectedItemCount
+ if (combined.size > MAX_SCORE_ROWS) {
+ return SportsProviderResult.Failure(SportsProviderError.RESPONSE_TOO_LARGE)
+ }
+ }
+ }
+ }
+ }
+ return SportsProviderResult.Success(ProviderBatch(combined, rejected))
+ }
+
+ override suspend fun gameStatuses(
+ request: ProviderScoreRequest,
+ ): SportsProviderResult<ProviderBatch<ProviderEventStatus>> {
+ val mapping = definition.statuses
+ ?: return SportsProviderResult.Failure(SportsProviderError.INVALID_CONFIGURATION)
+ return fetchEventBatch(mapping.endpoint, request.eventIds, request.eventScopes) { body, requestedIds ->
+ CustomSportsProviderJsonMapper.statuses(mapping, body, requestedIds)
+ }
+ }
+
+ override suspend fun standings(
+ request: ProviderStandingsRequest,
+ ): SportsProviderResult<ProviderStandings> {
+ val mapping = definition.standings
+ ?: return SportsProviderResult.Failure(SportsProviderError.INVALID_CONFIGURATION)
+ val requestedName = request.leagueName?.let(::normalizeScopeName)
+ val namedScope = requestedName?.let { name ->
+ definition.scopes.firstOrNull { scope ->
+ scope.leagueName?.let(::normalizeScopeName) == name &&
+ (request.sport == null || scope.sport == request.sport)
+ }
+ }
+ val scope = namedScope?.let { ProviderEventScope(it.sport, it.leagueId) }
+ ?: resolveScope(request.sport, request.leagueId, mapping.endpoint)
+ val scopeName = namedScope?.leagueName
+ val scopedRequest = request.copy(
+ leagueId = scope.leagueId.orEmpty(),
+ sport = scope.sport,
+ leagueName = scopeName ?: request.leagueName,
)
- return when (response) {
+ return when (val response = fetchJson(
+ mapping.endpoint,
+ mapOf("leagueId" to scope.leagueId.orEmpty(), "season" to request.season.orEmpty()) +
+ scopedVariables(scope),
+ storedCredentials(),
+ )) {
is SportsProviderResult.Failure -> response
- is SportsProviderResult.Success -> CustomSportsProviderJsonMapper.scores(
+ is SportsProviderResult.Success -> CustomSportsProviderJsonMapper.standings(
mapping,
response.value,
- request.eventIds,
+ scopedRequest,
+ leagueNameFallback = scopeName,
)
}
}
+ override suspend fun broadcasters(
+ request: ProviderEventDetailRequest,
+ ): SportsProviderResult<ProviderBatch<ProviderBroadcaster>> {
+ val mapping = definition.broadcasters
+ ?: return SportsProviderResult.Failure(SportsProviderError.INVALID_CONFIGURATION)
+ return fetchDetailBatch(mapping.endpoint, request) { body ->
+ CustomSportsProviderJsonMapper.broadcasters(mapping, body)
+ }
+ }
+
+ override suspend fun teamMetadata(
+ request: ProviderTeamMetadataRequest,
+ ): SportsProviderResult<ProviderTeamMetadata> {
+ val mapping = definition.team
+ ?: return SportsProviderResult.Failure(SportsProviderError.INVALID_CONFIGURATION)
+ return when (val response = fetchJson(
+ mapping.endpoint,
+ mapOf("teamId" to request.teamId) + scopedVariables(
+ resolveScope(request.sport, request.leagueId, mapping.endpoint),
+ ),
+ storedCredentials(),
+ )) {
+ is SportsProviderResult.Failure -> response
+ is SportsProviderResult.Success -> CustomSportsProviderJsonMapper.teamMetadata(
+ mapping,
+ response.value,
+ request,
+ )
+ }
+ }
+
+ override suspend fun leagueMetadata(
+ request: ProviderLeagueMetadataRequest,
+ ): SportsProviderResult<ProviderLeagueMetadata> {
+ val mapping = definition.league
+ ?: return SportsProviderResult.Failure(SportsProviderError.INVALID_CONFIGURATION)
+ return when (val response = fetchJson(
+ mapping.endpoint,
+ mapOf("leagueId" to request.leagueId) + scopedVariables(
+ resolveScope(request.sport, request.leagueId, mapping.endpoint),
+ ),
+ storedCredentials(),
+ )) {
+ is SportsProviderResult.Failure -> response
+ is SportsProviderResult.Success -> CustomSportsProviderJsonMapper.leagueMetadata(
+ mapping,
+ response.value,
+ request,
+ )
+ }
+ }
+
+ override suspend fun artwork(
+ request: ProviderEntityRef,
+ ): SportsProviderResult<ProviderBatch<ProviderArtwork>> {
+ val mapping = definition.artwork
+ ?: return SportsProviderResult.Failure(SportsProviderError.INVALID_CONFIGURATION)
+ return when (val response = fetchJson(
+ mapping.endpoint,
+ mapOf("entityId" to request.id, "entityType" to request.type.name.lowercase()) +
+ scopedVariables(resolveScope(request.sport, request.leagueId, mapping.endpoint)),
+ storedCredentials(),
+ )) {
+ is SportsProviderResult.Failure -> response
+ is SportsProviderResult.Success -> CustomSportsProviderJsonMapper.artwork(
+ mapping,
+ response.value,
+ request,
+ )
+ }
+ }
+
+ override suspend fun lineups(
+ request: ProviderEventDetailRequest,
+ ): SportsProviderResult<ProviderBatch<ProviderLineup>> {
+ val mapping = definition.lineups
+ ?: return SportsProviderResult.Failure(SportsProviderError.INVALID_CONFIGURATION)
+ return fetchDetailBatch(mapping.endpoint, request) { body ->
+ CustomSportsProviderJsonMapper.lineups(mapping, body, request.eventId)
+ }
+ }
+
+ override suspend fun statistics(
+ request: ProviderEventDetailRequest,
+ ): SportsProviderResult<ProviderEventStatistics> {
+ val mapping = definition.statistics
+ ?: return SportsProviderResult.Failure(SportsProviderError.INVALID_CONFIGURATION)
+ return when (val response = fetchJson(
+ mapping.endpoint,
+ mapOf("eventId" to request.eventId) + scopedVariables(
+ resolveScope(request.sport, request.leagueId, mapping.endpoint),
+ ),
+ storedCredentials(),
+ )) {
+ is SportsProviderResult.Failure -> response
+ is SportsProviderResult.Success -> CustomSportsProviderJsonMapper.statistics(
+ mapping,
+ response.value,
+ request.eventId,
+ )
+ }
+ }
+
+ private suspend fun <T : Any> fetchEventBatch(
+ endpoint: String,
+ eventIds: Set<String>,
+ eventScopes: Map<String, ProviderEventScope> = emptyMap(),
+ map: (JsonElement, Set<String>) -> SportsProviderResult<ProviderBatch<T>>,
+ ): SportsProviderResult<ProviderBatch<T>> {
+ if (eventIds.isEmpty()) return SportsProviderResult.Success(ProviderBatch(emptyList()))
+ if (eventIds.size > MAX_DETAIL_EVENT_IDS) {
+ return SportsProviderResult.Failure(SportsProviderError.RESPONSE_TOO_LARGE)
+ }
+ val credentials = storedCredentials()
+ if ("{eventId}" in endpoint) {
+ val combined = mutableListOf<T>()
+ var rejected = 0
+ for (eventId in eventIds.sorted()) {
+ val scope = eventScopes[eventId] ?: ProviderEventScope()
+ when (val response = fetchJson(
+ endpoint,
+ mapOf("eventId" to eventId) + scopedVariables(scope),
+ credentials,
+ )) {
+ is SportsProviderResult.Failure -> return response
+ is SportsProviderResult.Success -> when (val mapped = map(response.value, setOf(eventId))) {
+ is SportsProviderResult.Failure -> return mapped
+ is SportsProviderResult.Success -> {
+ combined += mapped.value.items
+ rejected += mapped.value.rejectedItemCount
+ if (combined.size > MAX_DETAIL_ROWS) {
+ return SportsProviderResult.Failure(SportsProviderError.RESPONSE_TOO_LARGE)
+ }
+ }
+ }
+ }
+ }
+ return SportsProviderResult.Success(ProviderBatch(combined, rejected))
+ }
+ val groups = if (hasScopePlaceholders(endpoint)) {
+ eventIds.sorted().groupBy { eventScopes[it] ?: ProviderEventScope() }
+ } else {
+ mapOf(ProviderEventScope() to eventIds.sorted())
+ }
+ val combined = mutableListOf<T>()
+ var rejected = 0
+ for ((scope, ids) in groups) {
+ when (val response = fetchJson(
+ endpoint,
+ mapOf("eventIds" to ids.joinToString(",")) + scopedVariables(scope),
+ credentials,
+ )) {
+ is SportsProviderResult.Failure -> return response
+ is SportsProviderResult.Success -> when (val mapped = map(response.value, ids.toSet())) {
+ is SportsProviderResult.Failure -> return mapped
+ is SportsProviderResult.Success -> {
+ combined += mapped.value.items
+ rejected += mapped.value.rejectedItemCount
+ if (combined.size > MAX_DETAIL_ROWS) {
+ return SportsProviderResult.Failure(SportsProviderError.RESPONSE_TOO_LARGE)
+ }
+ }
+ }
+ }
+ }
+ return SportsProviderResult.Success(ProviderBatch(combined, rejected))
+ }
+
+ private suspend fun <T : Any> fetchDetailBatch(
+ endpoint: String,
+ request: ProviderEventDetailRequest,
+ map: (JsonElement) -> SportsProviderResult<ProviderBatch<T>>,
+ ): SportsProviderResult<ProviderBatch<T>> = when (val response = fetchJson(
+ endpoint,
+ mapOf("eventId" to request.eventId) + scopedVariables(
+ resolveScope(request.sport, request.leagueId, endpoint),
+ ),
+ storedCredentials(),
+ )) {
+ is SportsProviderResult.Failure -> response
+ is SportsProviderResult.Success -> map(response.value)
+ }
+
private suspend fun storedCredentials(): SportsProviderCredentials? =
try {
store.credentials(config.instanceId)
@@ -164,18 +519,60 @@ internal class CustomSportsProvider(
}
}
- private fun eventVariables(request: ProviderEventRequest): Map<String, String> = mapOf(
+ private fun eventVariables(
+ request: ProviderEventRequest,
+ dateFormat: CustomEventDateFormat,
+ endpoint: String,
+ ): Map<String, String> = mapOf(
"fromDate" to request.from.toString(),
"toDate" to request.until.toString(),
- "date" to LocalDate.ofInstant(request.from, ZoneOffset.UTC).format(DateTimeFormatter.ISO_LOCAL_DATE),
- "leagueId" to request.leagueId.orEmpty(),
- "sport" to request.sport.orEmpty(),
+ "date" to LocalDate.ofInstant(request.from, ZoneOffset.UTC).format(dateFormat.formatter),
+ "fromDateFormatted" to LocalDate.ofInstant(request.from, ZoneOffset.UTC).format(dateFormat.formatter),
+ "toDateFormatted" to LocalDate.ofInstant(request.until.minusNanos(1), ZoneOffset.UTC)
+ .format(dateFormat.formatter),
+ ) + scopedVariables(resolveScope(request.sport, request.leagueId, endpoint))
+
+ private fun resolveScope(
+ sport: String?,
+ leagueId: String?,
+ endpoint: String? = null,
+ ): ProviderEventScope {
+ val rawSport = sport?.trim()?.takeIf(String::isNotEmpty)
+ val rawLeagueId = leagueId?.trim()?.takeIf(String::isNotEmpty)
+ if (endpoint?.contains("{sport}") == true && rawLeagueId != null) {
+ val separator = rawLeagueId.indexOf('/')
+ if (separator > 0 && separator < rawLeagueId.lastIndex) {
+ return ProviderEventScope(
+ sport = rawLeagueId.substring(0, separator),
+ leagueId = rawLeagueId.substring(separator + 1),
+ )
+ }
+ }
+ return ProviderEventScope(rawSport, rawLeagueId)
+ }
+
+ private fun scopedVariables(scope: ProviderEventScope): Map<String, String> = mapOf(
+ "sport" to scope.sport.orEmpty(),
+ "leagueId" to scope.leagueId.orEmpty(),
)
+ private fun hasScopePlaceholders(endpoint: String): Boolean =
+ "{sport}" in endpoint || "{leagueId}" in endpoint
+
+ private fun normalizeScopeName(value: String): String =
+ value.lowercase().filter(Char::isLetterOrDigit)
+
private companion object {
+ const val MAX_CONCURRENT_EVENT_REQUESTS = 4
+ const val EVENT_LOAD_TIMEOUT_MS = 15_000L
+ const val MAX_EVENT_DAYS = 14L
+ const val SCORE_LOAD_TIMEOUT_MS = 4_000L
const val TEST_WINDOW_SECONDS = 24 * 60 * 60L
+ const val MAX_COMBINED_EVENT_ROWS = 10_000
const val MAX_SCORE_EVENT_IDS = 50
const val MAX_SCORE_ROWS = 1_000
+ const val MAX_DETAIL_EVENT_IDS = 50
+ const val MAX_DETAIL_ROWS = 1_000
}
}
@@ -183,12 +580,31 @@ internal data class CustomSportsProviderDefinition(
val name: String,
val auth: SportsProviderAuth,
val events: CustomEventMapping,
+ val scopes: List<CustomSportsProviderScope>,
val scores: CustomScoreMapping?,
+ val statuses: CustomStatusMapping?,
+ val standings: CustomStandingsMapping?,
+ val team: CustomTeamMetadataMapping?,
+ val league: CustomLeagueMetadataMapping?,
+ val artwork: CustomArtworkMapping?,
+ val broadcasters: CustomBroadcasterMapping?,
+ val lineups: CustomLineupMapping?,
+ val statistics: CustomStatisticsMapping?,
) {
val capabilities: Set<SportsCapability>
get() = buildSet {
add(SportsCapability.EVENTS)
if (scores != null) add(SportsCapability.LIVE_SCORES)
+ if (events.status != null || scores?.status != null || statuses != null) {
+ add(SportsCapability.GAME_STATUS)
+ }
+ if (standings != null) add(SportsCapability.STANDINGS)
+ if (team != null) add(SportsCapability.TEAM_METADATA)
+ if (league != null) add(SportsCapability.LEAGUE_METADATA)
+ if (artwork != null) add(SportsCapability.ARTWORK)
+ if (broadcasters != null || events.broadcasters != null) add(SportsCapability.BROADCASTERS)
+ if (lineups != null) add(SportsCapability.LINEUPS)
+ if (statistics != null) add(SportsCapability.STATISTICS)
}
companion object {
@@ -198,14 +614,47 @@ internal data class CustomSportsProviderDefinition(
source.length <= CUSTOM_SPORTS_PROVIDER_MAX_CONFIGURATION_CHARS,
)
val root = Json.parseToJsonElement(source).jsonObject
- requireKeys(root, setOf("name", "auth", "events", "scores"))
+ requireKeys(root, setOf(
+ "name", "auth", "events", "scores", "statuses", "standings", "team", "league",
+ "artwork", "broadcasters", "lineups", "statistics", "scopes",
+ ))
val name = root.requiredString("name", maxLength = 64)
require(name.none { Character.isISOControl(it) })
val auth = root["auth"]?.jsonObject?.let(::parseAuth) ?: SportsProviderAuth.None
val events = root["events"]?.jsonObject?.let(::parseEvents)
?: throw IllegalArgumentException()
+ val scopes = root["scopes"]?.takeUnless { it is JsonNull }?.jsonArray?.let { values ->
+ require(values.size <= MAX_DECLARED_SCOPES)
+ values.map { element ->
+ val value = element.jsonObject
+ requireKeys(value, setOf("sport", "leagueId", "leagueName"))
+ val sport = value.optionalLiteral("sport")
+ val leagueId = value.optionalLiteral("leagueId")
+ require(sport != null || leagueId != null)
+ CustomSportsProviderScope(
+ sport = sport,
+ leagueId = leagueId,
+ leagueName = value.optionalLiteral("leagueName"),
+ )
+ }.also { parsed ->
+ require(parsed.map { it.sport to it.leagueId }.distinct().size == parsed.size)
+ if ("{sport}" in events.endpoint) require(parsed.all { !it.sport.isNullOrBlank() })
+ if ("{leagueId}" in events.endpoint) require(parsed.all { !it.leagueId.isNullOrBlank() })
+ }
+ }.orEmpty()
val scores = root["scores"]?.takeUnless { it is JsonNull }?.jsonObject?.let(::parseScores)
- CustomSportsProviderDefinition(name, auth, events, scores)
+ val statuses = root.optionalObject("statuses")?.let(::parseStatuses)
+ val standings = root.optionalObject("standings")?.let(::parseStandings)
+ val team = root.optionalObject("team")?.let(::parseTeamMetadata)
+ val league = root.optionalObject("league")?.let(::parseLeagueMetadata)
+ val artwork = root.optionalObject("artwork")?.let(::parseArtwork)
+ val broadcasters = root.optionalObject("broadcasters")?.let(::parseBroadcasters)
+ val lineups = root.optionalObject("lineups")?.let(::parseLineups)
+ val statistics = root.optionalObject("statistics")?.let(::parseStatistics)
+ CustomSportsProviderDefinition(
+ name, auth, events, scopes, scores, statuses, standings, team, league, artwork,
+ broadcasters, lineups, statistics,
+ )
} catch (error: IllegalArgumentException) {
throw error
} catch (_: Exception) {
@@ -228,46 +677,96 @@ internal data class CustomSportsProviderDefinition(
private fun parseEvents(value: JsonObject): CustomEventMapping {
requireKeys(value, setOf(
- "endpoint", "items", "id", "sport", "leagueName", "leagueId", "title", "start",
- "startFormat", "homeName", "homeId", "awayName", "awayId", "competitorKind",
- "status", "clock", "period",
+ "endpoint", "items", "id", "sport", "sportValue", "leagueName", "leagueNameValue",
+ "leagueId", "leagueIdValue", "title", "start", "startFormat", "dateFormat",
+ "homeName", "homeId", "awayName", "awayId", "competitors", "competitorKind",
+ "status", "clock", "period", "broadcasters", "dailyRequests",
))
+ val competitors = value["competitors"]?.jsonObject?.let(::parseEventCompetitors)
+ val homeName = value.optionalSelector("homeName")
+ val homeId = value.optionalSelector("homeId")
+ val awayName = value.optionalSelector("awayName")
+ val awayId = value.optionalSelector("awayId")
+ require(
+ if (competitors == null) homeName != null && awayName != null
+ else homeName == null && homeId == null && awayName == null && awayId == null,
+ )
+ val sport = value.optionalSelector("sport")
+ val sportValue = value.optionalLiteral("sportValue")
+ val leagueName = value.optionalSelector("leagueName")
+ val leagueNameValue = value.optionalLiteral("leagueNameValue")
+ val leagueId = value.optionalSelector("leagueId")
+ val leagueIdValue = value.optionalLiteral("leagueIdValue")
+ require((sport == null || sportValue == null) &&
+ (leagueName == null || leagueNameValue == null) &&
+ (leagueId == null || leagueIdValue == null))
+ val endpoint = value.requiredEndpoint("endpoint", EVENT_PLACEHOLDERS)
+ val dailyRequests = value["dailyRequests"]?.let {
+ it.jsonPrimitive.booleanOrNull ?: throw IllegalArgumentException()
+ } ?: false
+ require(!dailyRequests || "{date}" in endpoint)
return CustomEventMapping(
- endpoint = value.requiredEndpoint("endpoint", EVENT_PLACEHOLDERS),
+ endpoint = endpoint,
+ dailyRequests = dailyRequests,
items = value.requiredSelector("items", allowRoot = true),
id = value.requiredSelector("id"),
- sport = value.optionalSelector("sport"),
- leagueName = value.optionalSelector("leagueName"),
- leagueId = value.optionalSelector("leagueId"),
+ sport = sport,
+ sportValue = sportValue,
+ leagueName = leagueName,
+ leagueNameValue = leagueNameValue,
+ leagueId = leagueId,
+ leagueIdValue = leagueIdValue,
title = value.optionalSelector("title"),
start = value.requiredSelector("start"),
startFormat = value.requiredTimestampFormat("startFormat"),
- homeName = value.requiredSelector("homeName"),
- homeId = value.optionalSelector("homeId"),
- awayName = value.requiredSelector("awayName"),
- awayId = value.optionalSelector("awayId"),
+ dateFormat = value.optionalEventDateFormat("dateFormat") ?: CustomEventDateFormat.ISO_LOCAL_DATE,
+ homeName = homeName,
+ homeId = homeId,
+ awayName = awayName,
+ awayId = awayId,
+ competitors = competitors,
competitorKind = value.optionalCompetitorKind("competitorKind")
?: ProviderCompetitorKind.TEAM,
status = value.optionalSelector("status"),
clock = value.optionalSelector("clock"),
period = value.optionalSelector("period"),
+ broadcasters = value.optionalObject("broadcasters")?.let(::parseBroadcasterItems),
+ )
+ }
+
+ private fun parseEventCompetitors(value: JsonObject): CustomEventCompetitorMapping {
+ requireKeys(value, setOf("items", "name", "id", "role", "homeValue", "awayValue", "logo"))
+ return CustomEventCompetitorMapping(
+ items = value.requiredSelector("items", allowRoot = true),
+ name = value.requiredSelector("name"),
+ logo = value.optionalSelector("logo"),
+ id = value.optionalSelector("id"),
+ role = value.optionalSelector("role"),
+ homeValue = value.optionalLiteral("homeValue") ?: "home",
+ awayValue = value.optionalLiteral("awayValue") ?: "away",
)
}
private fun parseScores(value: JsonObject): CustomScoreMapping {
requireKeys(value, setOf(
"endpoint", "items", "eventId", "homeName", "homeScore", "awayName", "awayScore",
- "status", "clock", "period", "updatedAt", "updatedAtFormat",
+ "competitors", "status", "clock", "period", "updatedAt", "updatedAtFormat",
))
val endpoint = value.requiredEndpoint("endpoint", SCORE_PLACEHOLDERS)
require(("{eventId}" in endpoint) xor ("{eventIds}" in endpoint))
+ val competitors = value["competitors"]?.jsonObject?.let(::parseScoreCompetitors)
val homeScore = value.optionalSelector("homeScore")
val awayScore = value.optionalSelector("awayScore")
val status = value.optionalSelector("status")
- require(homeScore != null || awayScore != null || status != null)
val homeName = value.optionalSelector("homeName")
val awayName = value.optionalSelector("awayName")
- require((homeScore == null || homeName != null) && (awayScore == null || awayName != null))
+ if (competitors == null) {
+ require((homeScore != null || awayScore != null || status != null) &&
+ (homeScore == null || homeName != null) && (awayScore == null || awayName != null))
+ } else {
+ require(homeName == null && homeScore == null && awayName == null && awayScore == null)
+ require(competitors.score != null || status != null)
+ }
return CustomScoreMapping(
endpoint = endpoint,
items = value.requiredSelector("items", allowRoot = true),
@@ -276,6 +775,7 @@ internal data class CustomSportsProviderDefinition(
homeScore = homeScore,
awayName = awayName,
awayScore = awayScore,
+ competitors = competitors,
status = status,
clock = value.optionalSelector("clock"),
period = value.optionalSelector("period"),
@@ -285,6 +785,245 @@ internal data class CustomSportsProviderDefinition(
)
}
+ private fun parseStatuses(value: JsonObject): CustomStatusMapping {
+ requireKeys(value, setOf(
+ "endpoint", "items", "eventId", "status", "clock", "period", "detail",
+ "updatedAt", "updatedAtFormat",
+ ))
+ val endpoint = value.requiredEndpoint("endpoint", SCORE_PLACEHOLDERS)
+ require(("{eventId}" in endpoint) xor ("{eventIds}" in endpoint))
+ return CustomStatusMapping(
+ endpoint = endpoint,
+ items = value.requiredSelector("items", allowRoot = true),
+ eventId = value.requiredSelector("eventId"),
+ status = value.requiredSelector("status"),
+ clock = value.optionalSelector("clock"),
+ period = value.optionalSelector("period"),
+ detail = value.optionalSelector("detail"),
+ updatedAt = value.optionalSelector("updatedAt"),
+ updatedAtFormat = value.optionalTimestampFormat("updatedAtFormat")
+ ?: ProviderTimestampFormat.ISO_OFFSET,
+ )
+ }
+
+ private fun parseStandings(value: JsonObject): CustomStandingsMapping {
+ requireKeys(value, setOf(
+ "endpoint", "leagueName", "leagueNameValue", "leagueId", "leagueIdValue",
+ "sport", "sportValue", "season", "seasonValue", "updatedAt", "updatedAtFormat",
+ "groups",
+ ))
+ val leagueName = value.optionalSelector("leagueName")
+ val leagueNameValue = value.optionalLiteral("leagueNameValue")
+ val leagueId = value.optionalSelector("leagueId")
+ val leagueIdValue = value.optionalLiteral("leagueIdValue")
+ val sport = value.optionalSelector("sport")
+ val sportValue = value.optionalLiteral("sportValue")
+ val season = value.optionalSelector("season")
+ val seasonValue = value.optionalLiteral("seasonValue")
+ require((leagueName == null || leagueNameValue == null) &&
+ (leagueId == null || leagueIdValue == null) && (sport == null || sportValue == null) &&
+ (season == null || seasonValue == null))
+ return CustomStandingsMapping(
+ endpoint = value.requiredEndpoint("endpoint", STANDINGS_PLACEHOLDERS),
+ leagueName = leagueName,
+ leagueNameValue = leagueNameValue,
+ leagueId = leagueId,
+ leagueIdValue = leagueIdValue,
+ sport = sport,
+ sportValue = sportValue,
+ season = season,
+ seasonValue = seasonValue,
+ updatedAt = value.optionalSelector("updatedAt"),
+ updatedAtFormat = value.optionalTimestampFormat("updatedAtFormat")
+ ?: ProviderTimestampFormat.ISO_OFFSET,
+ groups = value.optionalObject("groups")?.let(::parseStandingGroups)
+ ?: throw IllegalArgumentException(),
+ )
+ }
+
+ private fun parseStandingGroups(value: JsonObject): CustomStandingGroupsMapping {
+ requireKeys(value, setOf("items", "name", "nameValue", "rows"))
+ val name = value.optionalSelector("name")
+ val nameValue = value.optionalLiteral("nameValue")
+ require(name == null || nameValue == null)
+ return CustomStandingGroupsMapping(
+ items = value.requiredSelector("items", allowRoot = true),
+ name = name,
+ nameValue = nameValue,
+ rows = value.optionalObject("rows")?.let(::parseStandingRows)
+ ?: throw IllegalArgumentException(),
+ )
+ }
+
+ private fun parseStandingRows(value: JsonObject): CustomStandingRowsMapping {
+ requireKeys(value, setOf("items", "teamName", "teamId", "kind", "rank", "statistics"))
+ return CustomStandingRowsMapping(
+ items = value.requiredSelector("items", allowRoot = true),
+ teamName = value.requiredSelector("teamName"),
+ teamId = value.optionalSelector("teamId"),
+ kind = value.optionalCompetitorKind("kind") ?: ProviderCompetitorKind.TEAM,
+ rank = value.optionalSelector("rank"),
+ statistics = value.optionalObject("statistics")?.let(::parseStandingStatistics),
+ )
+ }
+
+ private fun parseStandingStatistics(value: JsonObject): CustomStandingStatisticsMapping {
+ requireKeys(value, setOf("items", "key", "label", "value"))
+ return CustomStandingStatisticsMapping(
+ items = value.requiredSelector("items", allowRoot = true),
+ key = value.requiredSelector("key"),
+ label = value.optionalSelector("label"),
+ value = value.requiredSelector("value"),
+ )
+ }
+
+ private fun parseTeamMetadata(value: JsonObject): CustomTeamMetadataMapping {
+ requireKeys(value, setOf(
+ "endpoint", "items", "id", "name", "shortName", "country", "kind", "updatedAt",
+ "updatedAtFormat",
+ ))
+ return CustomTeamMetadataMapping(
+ endpoint = value.requiredEndpoint("endpoint", TEAM_PLACEHOLDERS),
+ items = value.requiredSelector("items", allowRoot = true),
+ id = value.optionalSelector("id"),
+ name = value.requiredSelector("name"),
+ shortName = value.optionalSelector("shortName"),
+ country = value.optionalSelector("country"),
+ kind = value.optionalCompetitorKind("kind") ?: ProviderCompetitorKind.TEAM,
+ updatedAt = value.optionalSelector("updatedAt"),
+ updatedAtFormat = value.optionalTimestampFormat("updatedAtFormat")
+ ?: ProviderTimestampFormat.ISO_OFFSET,
+ )
+ }
+
+ private fun parseLeagueMetadata(value: JsonObject): CustomLeagueMetadataMapping {
+ requireKeys(value, setOf(
+ "endpoint", "items", "id", "name", "sport", "country", "season", "updatedAt",
+ "updatedAtFormat",
+ ))
+ return CustomLeagueMetadataMapping(
+ endpoint = value.requiredEndpoint("endpoint", LEAGUE_PLACEHOLDERS),
+ items = value.requiredSelector("items", allowRoot = true),
+ id = value.optionalSelector("id"),
+ name = value.optionalSelector("name"),
+ sport = value.optionalSelector("sport"),
+ country = value.optionalSelector("country"),
+ season = value.optionalSelector("season"),
+ updatedAt = value.optionalSelector("updatedAt"),
+ updatedAtFormat = value.optionalTimestampFormat("updatedAtFormat")
+ ?: ProviderTimestampFormat.ISO_OFFSET,
+ )
+ }
+
+ private fun parseArtwork(value: JsonObject): CustomArtworkMapping {
+ requireKeys(value, setOf("endpoint", "items", "uri", "kind", "kindValue"))
+ val kind = value.optionalSelector("kind")
+ val kindValue = value.optionalLiteral("kindValue")?.let(::parseArtworkKind)
+ require(kind == null || kindValue == null)
+ return CustomArtworkMapping(
+ endpoint = value.requiredEndpoint("endpoint", ARTWORK_PLACEHOLDERS),
+ items = value.requiredSelector("items", allowRoot = true),
+ uri = value.requiredSelector("uri"),
+ kind = kind,
+ kindValue = kindValue ?: ProviderArtworkKind.OTHER,
+ )
+ }
+
+ private fun parseBroadcasters(value: JsonObject): CustomBroadcasterMapping {
+ requireKeys(value, setOf("endpoint", "items", "name", "country", "language", "type", "typeValue"))
+ return CustomBroadcasterMapping(
+ endpoint = value.requiredEndpoint("endpoint", DETAIL_PLACEHOLDERS),
+ fields = parseBroadcasterItems(JsonObject(value.filterKeys { it != "endpoint" })),
+ )
+ }
+
+ private fun parseBroadcasterItems(value: JsonObject): CustomBroadcasterFieldsMapping {
+ requireKeys(value, setOf("items", "name", "country", "language", "type", "typeValue"))
+ val type = value.optionalSelector("type")
+ val typeValue = value.optionalLiteral("typeValue")?.let(::parseBroadcastType)
+ require(type == null || typeValue == null)
+ return CustomBroadcasterFieldsMapping(
+ items = value.requiredSelector("items", allowRoot = true),
+ name = value.requiredSelector("name"),
+ country = value.optionalSelector("country"),
+ language = value.optionalSelector("language"),
+ type = type,
+ typeValue = typeValue ?: ProviderBroadcastType.UNKNOWN,
+ )
+ }
+
+ private fun parseLineups(value: JsonObject): CustomLineupMapping {
+ requireKeys(value, setOf("endpoint", "items", "teamName", "teamId", "members", "updatedAt", "updatedAtFormat"))
+ return CustomLineupMapping(
+ endpoint = value.requiredEndpoint("endpoint", DETAIL_PLACEHOLDERS),
+ items = value.requiredSelector("items", allowRoot = true),
+ teamName = value.optionalSelector("teamName"),
+ teamId = value.optionalSelector("teamId"),
+ members = value.optionalObject("members")?.let(::parseLineupMembers)
+ ?: throw IllegalArgumentException(),
+ updatedAt = value.optionalSelector("updatedAt"),
+ updatedAtFormat = value.optionalTimestampFormat("updatedAtFormat")
+ ?: ProviderTimestampFormat.ISO_OFFSET,
+ )
+ }
+
+ private fun parseLineupMembers(value: JsonObject): CustomLineupMembersMapping {
+ requireKeys(value, setOf("items", "name", "id", "kind", "position", "shirtNumber", "starter"))
+ return CustomLineupMembersMapping(
+ items = value.requiredSelector("items", allowRoot = true),
+ name = value.requiredSelector("name"),
+ id = value.optionalSelector("id"),
+ kind = value.optionalCompetitorKind("kind") ?: ProviderCompetitorKind.PERSON,
+ position = value.optionalSelector("position"),
+ shirtNumber = value.optionalSelector("shirtNumber"),
+ starter = value.optionalSelector("starter"),
+ )
+ }
+
+ private fun parseStatistics(value: JsonObject): CustomStatisticsMapping {
+ requireKeys(value, setOf("endpoint", "groups", "updatedAt", "updatedAtFormat"))
+ val groups = value.optionalObject("groups") ?: throw IllegalArgumentException()
+ requireKeys(groups, setOf("items", "teamName", "teamId", "statistics"))
+ return CustomStatisticsMapping(
+ endpoint = value.requiredEndpoint("endpoint", DETAIL_PLACEHOLDERS),
+ groups = CustomStatisticGroupsMapping(
+ items = groups.requiredSelector("items", allowRoot = true),
+ teamName = groups.optionalSelector("teamName"),
+ teamId = groups.optionalSelector("teamId"),
+ statistics = groups.optionalObject("statistics")?.let(::parseStatisticsItems)
+ ?: throw IllegalArgumentException(),
+ ),
+ updatedAt = value.optionalSelector("updatedAt"),
+ updatedAtFormat = value.optionalTimestampFormat("updatedAtFormat")
+ ?: ProviderTimestampFormat.ISO_OFFSET,
+ )
+ }
+
+ private fun parseStatisticsItems(value: JsonObject): CustomStatisticsItemsMapping {
+ requireKeys(value, setOf("items", "key", "label", "value", "period"))
+ return CustomStatisticsItemsMapping(
+ items = value.requiredSelector("items", allowRoot = true),
+ key = value.requiredSelector("key"),
+ label = value.optionalSelector("label"),
+ value = value.requiredSelector("value"),
+ period = value.optionalSelector("period"),
+ )
+ }
+
+ private fun parseScoreCompetitors(value: JsonObject): CustomScoreCompetitorMapping {
+ requireKeys(value, setOf("items", "name", "id", "score", "role", "homeValue", "awayValue", "kind"))
+ return CustomScoreCompetitorMapping(
+ items = value.requiredSelector("items", allowRoot = true),
+ name = value.requiredSelector("name"),
+ id = value.optionalSelector("id"),
+ score = value.optionalSelector("score"),
+ role = value.optionalSelector("role"),
+ homeValue = value.optionalLiteral("homeValue") ?: "home",
+ awayValue = value.optionalLiteral("awayValue") ?: "away",
+ kind = value.optionalCompetitorKind("kind") ?: ProviderCompetitorKind.UNKNOWN,
+ )
+ }
+
private fun JsonObject.requiredEndpoint(key: String, allowedPlaceholders: Set<String>): String {
val endpoint = requiredString(key, maxLength = 512)
require(endpoint.startsWith('/') && !endpoint.startsWith("//"))
@@ -303,11 +1042,12 @@ internal data class CustomSportsProviderDefinition(
if (element is JsonNull) null else element.jsonPrimitive.content.also { requireSelector(it) }
}
+ private fun JsonObject.optionalObject(key: String): JsonObject? = this[key]?.let { element ->
+ if (element is JsonNull) null else element.jsonObject
+ }
+
private fun requireSelector(value: String, allowRoot: Boolean = false) {
- if (allowRoot && value == "$") return
- val path = value.removePrefix("$.")
- require(path.isNotBlank() && path.split('.').size <= MAX_SELECTOR_DEPTH)
- require(path.split('.').all { SELECTOR_SEGMENT.matches(it) })
+ parseJsonSelector(value, allowRoot)
}
private fun JsonObject.requiredTimestampFormat(key: String): ProviderTimestampFormat =
@@ -320,12 +1060,26 @@ internal data class CustomSportsProviderDefinition(
?: throw IllegalArgumentException()
}
+ private fun JsonObject.optionalEventDateFormat(key: String): CustomEventDateFormat? {
+ val value = this[key]?.jsonPrimitive?.content ?: return null
+ return CustomEventDateFormat.entries.firstOrNull { it.name == value }
+ ?: throw IllegalArgumentException()
+ }
+
private fun JsonObject.optionalCompetitorKind(key: String): ProviderCompetitorKind? {
val value = this[key]?.jsonPrimitive?.content ?: return null
return ProviderCompetitorKind.entries.firstOrNull { it.name == value }
?: throw IllegalArgumentException()
}
+ private fun parseArtworkKind(value: String): ProviderArtworkKind =
+ ProviderArtworkKind.entries.firstOrNull { it.name == value.uppercase() }
+ ?: throw IllegalArgumentException()
+
+ private fun parseBroadcastType(value: String): ProviderBroadcastType =
+ ProviderBroadcastType.entries.firstOrNull { it.name == value.uppercase() }
+ ?: throw IllegalArgumentException()
+
private fun JsonObject.requiredString(key: String, maxLength: Int): String {
val value = this[key]?.jsonPrimitive?.takeIf(JsonPrimitive::isString)?.content?.trim()
?: throw IllegalArgumentException()
@@ -333,36 +1087,79 @@ internal data class CustomSportsProviderDefinition(
return value
}
+ private fun JsonObject.optionalLiteral(key: String): String? {
+ val element = this[key] ?: return null
+ if (element is JsonNull) return null
+ val value = element.jsonPrimitive.takeIf(JsonPrimitive::isString)?.content?.trim()
+ ?: throw IllegalArgumentException()
+ require(value.isNotEmpty() && value.length <= 128 && value.none(Character::isISOControl))
+ return value
+ }
+
private fun requireKeys(value: JsonObject, allowed: Set<String>) {
require(value.keys.all(allowed::contains))
}
- private val PLACEHOLDER = Regex("\\{([A-Za-z][A-Za-z0-9]*)}")
- private val SELECTOR_SEGMENT = Regex("[A-Za-z0-9_-]{1,64}")
- private const val MAX_SELECTOR_DEPTH = 16
- private val EVENT_PLACEHOLDERS = setOf("date", "fromDate", "toDate", "leagueId", "sport")
- private val SCORE_PLACEHOLDERS = setOf("eventId", "eventIds")
+ private val PLACEHOLDER = Regex("\\{([A-Za-z][A-Za-z0-9]*)\\}")
+ private val EVENT_PLACEHOLDERS = setOf(
+ "date", "fromDate", "toDate", "fromDateFormatted", "toDateFormatted", "leagueId", "sport",
+ )
+ private val SCORE_PLACEHOLDERS = setOf("eventId", "eventIds", "sport", "leagueId")
+ private val STANDINGS_PLACEHOLDERS = setOf("leagueId", "season", "sport")
+ private val TEAM_PLACEHOLDERS = setOf("teamId", "sport", "leagueId")
+ private val LEAGUE_PLACEHOLDERS = setOf("leagueId", "sport")
+ private val ARTWORK_PLACEHOLDERS = setOf("entityId", "entityType", "sport", "leagueId")
+ private val DETAIL_PLACEHOLDERS = setOf("eventId", "sport", "leagueId")
+ private const val MAX_DECLARED_SCOPES = 50
}
}
+internal data class CustomSportsProviderScope(
+ val sport: String? = null,
+ val leagueId: String? = null,
+ val leagueName: String? = null,
+)
+
internal data class CustomEventMapping(
val endpoint: String,
+ val dailyRequests: Boolean,
val items: String,
val id: String,
val sport: String?,
+ val sportValue: String?,
val leagueName: String?,
+ val leagueNameValue: String?,
val leagueId: String?,
+ val leagueIdValue: String?,
val title: String?,
val start: String,
val startFormat: ProviderTimestampFormat,
- val homeName: String,
+ val dateFormat: CustomEventDateFormat,
+ val homeName: String?,
val homeId: String?,
- val awayName: String,
+ val awayName: String?,
val awayId: String?,
+ val competitors: CustomEventCompetitorMapping?,
val competitorKind: ProviderCompetitorKind,
val status: String?,
val clock: String?,
val period: String?,
+ val broadcasters: CustomBroadcasterFieldsMapping?,
+)
+
+internal enum class CustomEventDateFormat(val formatter: DateTimeFormatter) {
+ ISO_LOCAL_DATE(DateTimeFormatter.ISO_LOCAL_DATE),
+ YYYYMMDD(DateTimeFormatter.BASIC_ISO_DATE),
+}
+
+internal data class CustomEventCompetitorMapping(
+ val items: String,
+ val name: String,
+ val logo: String?,
+ val id: String?,
+ val role: String?,
+ val homeValue: String,
+ val awayValue: String,
)
internal data class CustomScoreMapping(
@@ -373,6 +1170,7 @@ internal data class CustomScoreMapping(
val homeScore: String?,
val awayName: String?,
val awayScore: String?,
+ val competitors: CustomScoreCompetitorMapping?,
val status: String?,
val clock: String?,
val period: String?,
@@ -380,40 +1178,197 @@ internal data class CustomScoreMapping(
val updatedAtFormat: ProviderTimestampFormat,
)
+internal data class CustomScoreCompetitorMapping(
+ val items: String,
+ val name: String,
+ val id: String?,
+ val score: String?,
+ val role: String?,
+ val homeValue: String,
+ val awayValue: String,
+ val kind: ProviderCompetitorKind,
+)
+
+internal data class CustomStatusMapping(
+ val endpoint: String,
+ val items: String,
+ val eventId: String,
+ val status: String,
+ val clock: String?,
+ val period: String?,
+ val detail: String?,
+ val updatedAt: String?,
+ val updatedAtFormat: ProviderTimestampFormat,
+)
+
+internal data class CustomStandingsMapping(
+ val endpoint: String,
+ val leagueName: String?,
+ val leagueNameValue: String?,
+ val leagueId: String?,
+ val leagueIdValue: String?,
+ val sport: String?,
+ val sportValue: String?,
+ val season: String?,
+ val seasonValue: String?,
+ val updatedAt: String?,
+ val updatedAtFormat: ProviderTimestampFormat,
+ val groups: CustomStandingGroupsMapping,
+)
+
+internal data class CustomStandingGroupsMapping(
+ val items: String,
+ val name: String?,
+ val nameValue: String?,
+ val rows: CustomStandingRowsMapping,
+)
+
+internal data class CustomStandingRowsMapping(
+ val items: String,
+ val teamName: String,
+ val teamId: String?,
+ val kind: ProviderCompetitorKind,
+ val rank: String?,
+ val statistics: CustomStandingStatisticsMapping?,
+)
+
+internal data class CustomStandingStatisticsMapping(
+ val items: String,
+ val key: String,
+ val label: String?,
+ val value: String,
+)
+
+internal data class CustomTeamMetadataMapping(
+ val endpoint: String,
+ val items: String,
+ val id: String?,
+ val name: String,
+ val shortName: String?,
+ val country: String?,
+ val kind: ProviderCompetitorKind,
+ val updatedAt: String?,
+ val updatedAtFormat: ProviderTimestampFormat,
+)
+
+internal data class CustomLeagueMetadataMapping(
+ val endpoint: String,
+ val items: String,
+ val id: String?,
+ val name: String?,
+ val sport: String?,
+ val country: String?,
+ val season: String?,
+ val updatedAt: String?,
+ val updatedAtFormat: ProviderTimestampFormat,
+)
+
+internal data class CustomArtworkMapping(
+ val endpoint: String,
+ val items: String,
+ val uri: String,
+ val kind: String?,
+ val kindValue: ProviderArtworkKind,
+)
+
+internal data class CustomBroadcasterMapping(
+ val endpoint: String,
+ val fields: CustomBroadcasterFieldsMapping,
+)
+
+internal data class CustomBroadcasterFieldsMapping(
+ val items: String,
+ val name: String,
+ val country: String?,
+ val language: String?,
+ val type: String?,
+ val typeValue: ProviderBroadcastType,
+)
+
+internal data class CustomLineupMapping(
+ val endpoint: String,
+ val items: String,
+ val teamName: String?,
+ val teamId: String?,
+ val members: CustomLineupMembersMapping,
+ val updatedAt: String?,
+ val updatedAtFormat: ProviderTimestampFormat,
+)
+
+internal data class CustomLineupMembersMapping(
+ val items: String,
+ val name: String,
+ val id: String?,
+ val kind: ProviderCompetitorKind,
+ val position: String?,
+ val shirtNumber: String?,
+ val starter: String?,
+)
+
+internal data class CustomStatisticsMapping(
+ val endpoint: String,
+ val groups: CustomStatisticGroupsMapping,
+ val updatedAt: String?,
+ val updatedAtFormat: ProviderTimestampFormat,
+)
+
+internal data class CustomStatisticGroupsMapping(
+ val items: String,
+ val teamName: String?,
+ val teamId: String?,
+ val statistics: CustomStatisticsItemsMapping,
+)
+
+internal data class CustomStatisticsItemsMapping(
+ val items: String,
+ val key: String,
+ val label: String?,
+ val value: String,
+ val period: String?,
+)
+
internal object CustomSportsProviderJsonMapper {
fun events(
mapping: CustomEventMapping,
body: JsonElement,
+ sportFallback: String? = null,
+ leagueIdFallback: String? = null,
+ leagueNameFallback: String? = null,
): SportsProviderResult<ProviderBatch<ProviderEvent>> =
mapItems(body, mapping.items, MAX_EVENT_ROWS) { record ->
val eventId = record.scalar(mapping.id) ?: throw IllegalArgumentException()
val start = record.scalar(mapping.start)?.let { parseProviderTimestamp(it, mapping.startFormat) }
?: throw IllegalArgumentException()
- val competitors = buildList {
- record.scalar(mapping.homeName)?.let { name ->
+ val competitors = mapping.competitors?.let { competitorMapping ->
+ eventCompetitors(record, competitorMapping, mapping.competitorKind)
+ } ?: buildList {
+ mapping.homeName?.let { record.scalar(it) }?.let { name ->
add(ProviderCompetitor(
name = name,
- id = mapping.homeId?.let { selector -> record.scalar(selector) },
+ id = mapping.homeId?.let { record.scalar(it) },
kind = mapping.competitorKind,
role = ProviderCompetitorRole.HOME,
))
}
- record.scalar(mapping.awayName)?.let { name ->
+ mapping.awayName?.let { record.scalar(it) }?.let { name ->
add(ProviderCompetitor(
name = name,
- id = mapping.awayId?.let { selector -> record.scalar(selector) },
+ id = mapping.awayId?.let { record.scalar(it) },
kind = mapping.competitorKind,
role = ProviderCompetitorRole.AWAY,
))
}
}
if (competitors.isEmpty()) throw IllegalArgumentException()
+ val leagueName = mapping.leagueName?.let { record.scalar(it) }
+ ?: mapping.leagueNameValue
+ ?: leagueNameFallback
+ val leagueId = mapping.leagueId?.let { record.scalar(it) } ?: mapping.leagueIdValue ?: leagueIdFallback
+ val sport = mapping.sport?.let { record.scalar(it) } ?: mapping.sportValue ?: sportFallback
ProviderEvent(
providerEventId = eventId,
- sport = mapping.sport?.let { selector -> record.scalar(selector) },
- league = mapping.leagueName?.let { selector -> record.scalar(selector) }?.let { name ->
- ProviderLeague(name, mapping.leagueId?.let { selector -> record.scalar(selector) })
- },
+ sport = sport,
+ league = if (leagueName != null || leagueId != null) ProviderLeague(leagueName, leagueId, sport) else null,
title = mapping.title?.let { selector -> record.scalar(selector) },
competitors = competitors,
eventStart = start,
@@ -424,6 +1379,9 @@ internal object CustomSportsProviderJsonMapper {
mapping.period?.let { selector -> record.scalar(selector) },
)
},
+ broadcasters = mapping.broadcasters?.let { broadcasterFields ->
+ mapBroadcasterItems(record, broadcasterFields)
+ }.orEmpty(),
)
}
@@ -442,13 +1400,14 @@ internal object CustomSportsProviderJsonMapper {
val gameStatus = mapping.status?.let { selector -> record.scalar(selector) }
?.let { status(it, clock, period, updatedAt) }
val values = buildList {
+ mapping.competitors?.let { competitorMapping ->
+ addAll(scoreCompetitors(record, competitorMapping))
+ }
mapping.homeScore?.let { selector ->
record.scalar(selector)?.let { score ->
add(ProviderCompetitorScore(
ProviderCompetitor(
- name = requireNotNull(mapping.homeName?.let { nameSelector ->
- record.scalar(nameSelector)
- }),
+ name = requireNotNull(mapping.homeName?.let { record.scalar(it) }),
role = ProviderCompetitorRole.HOME,
),
score,
@@ -459,9 +1418,7 @@ internal object CustomSportsProviderJsonMapper {
record.scalar(selector)?.let { score ->
add(ProviderCompetitorScore(
ProviderCompetitor(
- name = requireNotNull(mapping.awayName?.let { nameSelector ->
- record.scalar(nameSelector)
- }),
+ name = requireNotNull(mapping.awayName?.let { record.scalar(it) }),
role = ProviderCompetitorRole.AWAY,
),
score,
@@ -470,7 +1427,289 @@ internal object CustomSportsProviderJsonMapper {
}
}
ProviderScore(eventId, values, gameStatus, updatedAt)
- }.filterIds(requestedIds)
+ }.filterIds(requestedIds, ProviderScore::providerEventId)
+
+ fun statuses(
+ mapping: CustomStatusMapping,
+ body: JsonElement,
+ requestedIds: Set<String>? = null,
+ ): SportsProviderResult<ProviderBatch<ProviderEventStatus>> =
+ mapItems(body, mapping.items, MAX_DETAIL_ROWS) { record ->
+ val eventId = record.scalar(mapping.eventId) ?: throw IllegalArgumentException()
+ val updatedAt = mapping.updatedAt?.let { record.scalar(it) }?.let {
+ parseProviderTimestamp(it, mapping.updatedAtFormat)
+ }
+ val rawStatus = record.scalar(mapping.status) ?: throw IllegalArgumentException()
+ val clock = mapping.clock?.let { record.scalar(it) }
+ val period = mapping.period?.let { record.scalar(it) }
+ ProviderEventStatus(
+ eventId,
+ status(rawStatus, clock, period, updatedAt, mapping.detail?.let { record.scalar(it) }),
+ )
+ }.filterIds(requestedIds, ProviderEventStatus::providerEventId)
+
+ fun standings(
+ mapping: CustomStandingsMapping,
+ body: JsonElement,
+ request: ProviderStandingsRequest,
+ leagueNameFallback: String? = null,
+ ): SportsProviderResult<ProviderStandings> {
+ val groups = body.select(mapping.groups.items)?.records()
+ ?: return SportsProviderResult.Failure(SportsProviderError.INVALID_RESPONSE)
+ if (groups.size > MAX_STANDING_GROUPS) {
+ return SportsProviderResult.Failure(SportsProviderError.RESPONSE_TOO_LARGE)
+ }
+ val mappedGroups = mutableListOf<ProviderStandingGroup>()
+ for (group in groups) {
+ val labelByKey = linkedMapOf<String, String?>()
+ val rowsResult = mapItems(group, mapping.groups.rows.items, MAX_STANDING_ROWS) { row ->
+ val competitorName = row.scalar(mapping.groups.rows.teamName) ?: throw IllegalArgumentException()
+ val values = linkedMapOf<String, String?>()
+ mapping.groups.rows.statistics?.let { statsMapping ->
+ row.select(statsMapping.items).records().take(MAX_STANDING_COLUMNS).forEach { stat ->
+ val key = stat.scalar(statsMapping.key) ?: return@forEach
+ val value = stat.scalar(statsMapping.value)
+ values.putIfAbsent(key, value)
+ labelByKey.putIfAbsent(key, statsMapping.label?.let { stat.scalar(it) })
+ }
+ }
+ ProviderStandingRow(
+ competitor = ProviderCompetitor(
+ name = competitorName,
+ id = mapping.groups.rows.teamId?.let { row.scalar(it) },
+ kind = mapping.groups.rows.kind,
+ ),
+ rank = mapping.groups.rows.rank?.let { row.scalar(it) }?.toIntOrNull()?.takeIf { it > 0 },
+ values = values,
+ )
+ }
+ when (rowsResult) {
+ is SportsProviderResult.Failure -> return rowsResult
+ is SportsProviderResult.Success -> {
+ if (mappedGroups.sumOf { it.rows.size } + rowsResult.value.items.size > MAX_STANDING_TOTAL_ROWS) {
+ return SportsProviderResult.Failure(SportsProviderError.RESPONSE_TOO_LARGE)
+ }
+ val columns = rowsResult.value.items.flatMap { it.values.keys }
+ .distinct().map { key -> ProviderStandingColumn(key, labelByKey[key]) }
+ mappedGroups += ProviderStandingGroup(
+ name = mapping.groups.name?.let { group.scalar(it) } ?: mapping.groups.nameValue,
+ columns = columns,
+ rows = rowsResult.value.items,
+ )
+ }
+ }
+ }
+ val leagueName = mapping.leagueName?.let { body.scalar(it) }
+ ?: mapping.leagueNameValue
+ ?: leagueNameFallback
+ val leagueId = mapping.leagueId?.let { body.scalar(it) } ?: mapping.leagueIdValue ?: request.leagueId
+ val sport = mapping.sport?.let { body.scalar(it) } ?: mapping.sportValue ?: request.sport
+ val season = mapping.season?.let { body.scalar(it) } ?: mapping.seasonValue ?: request.season
+ val updatedAt = mapping.updatedAt?.let { body.scalar(it) }?.let { parseProviderTimestamp(it, mapping.updatedAtFormat) }
+ return SportsProviderResult.Success(
+ ProviderStandings(
+ league = ProviderLeague(leagueName, leagueId, sport),
+ groups = mappedGroups,
+ season = season,
+ updatedAt = updatedAt,
+ ),
+ )
+ }
+
+ fun teamMetadata(
+ mapping: CustomTeamMetadataMapping,
+ body: JsonElement,
+ request: ProviderTeamMetadataRequest,
+ ): SportsProviderResult<ProviderTeamMetadata> {
+ val item = body.singleObject(mapping.items)
+ ?: return SportsProviderResult.Failure(SportsProviderError.INVALID_RESPONSE)
+ val name = item.scalar(mapping.name)
+ ?: return SportsProviderResult.Failure(SportsProviderError.INVALID_RESPONSE)
+ val updatedAt = mapping.updatedAt?.let { item.scalar(it) }?.let { parseProviderTimestamp(it, mapping.updatedAtFormat) }
+ return SportsProviderResult.Success(
+ ProviderTeamMetadata(
+ team = ProviderCompetitor(name, mapping.id?.let { item.scalar(it) } ?: request.teamId, mapping.kind),
+ shortName = mapping.shortName?.let { item.scalar(it) },
+ country = mapping.country?.let { item.scalar(it) },
+ updatedAt = updatedAt,
+ ),
+ )
+ }
+
+ fun leagueMetadata(
+ mapping: CustomLeagueMetadataMapping,
+ body: JsonElement,
+ request: ProviderLeagueMetadataRequest,
+ ): SportsProviderResult<ProviderLeagueMetadata> {
+ val item = body.singleObject(mapping.items)
+ ?: return SportsProviderResult.Failure(SportsProviderError.INVALID_RESPONSE)
+ val updatedAt = mapping.updatedAt?.let { item.scalar(it) }?.let { parseProviderTimestamp(it, mapping.updatedAtFormat) }
+ return SportsProviderResult.Success(
+ ProviderLeagueMetadata(
+ league = ProviderLeague(
+ mapping.name?.let { item.scalar(it) },
+ mapping.id?.let { item.scalar(it) } ?: request.leagueId,
+ mapping.sport?.let { item.scalar(it) } ?: request.sport,
+ ),
+ country = mapping.country?.let { item.scalar(it) },
+ season = mapping.season?.let { item.scalar(it) },
+ updatedAt = updatedAt,
+ ),
+ )
+ }
+
+ fun broadcasters(
+ mapping: CustomBroadcasterMapping,
+ body: JsonElement,
+ ): SportsProviderResult<ProviderBatch<ProviderBroadcaster>> =
+ mapItems(body, mapping.fields.items, MAX_DETAIL_ROWS) { item ->
+ mapBroadcaster(item, mapping.fields)
+ }
+
+ fun artwork(
+ mapping: CustomArtworkMapping,
+ body: JsonElement,
+ entity: ProviderEntityRef,
+ ): SportsProviderResult<ProviderBatch<ProviderArtwork>> =
+ mapItems(body, mapping.items, MAX_DETAIL_ROWS) { item ->
+ val rawUri = item.scalar(mapping.uri) ?: throw IllegalArgumentException()
+ val kind = mapping.kind?.let { item.scalar(it) }?.let(::artworkKind) ?: mapping.kindValue
+ ProviderArtwork(entity, java.net.URI(rawUri), kind)
+ }
+
+ fun lineups(
+ mapping: CustomLineupMapping,
+ body: JsonElement,
+ eventId: String,
+ ): SportsProviderResult<ProviderBatch<ProviderLineup>> {
+ val groups = body.select(mapping.items)?.records()
+ ?: return SportsProviderResult.Failure(SportsProviderError.INVALID_RESPONSE)
+ if (groups.size > MAX_LINEUP_ROWS) return SportsProviderResult.Failure(SportsProviderError.RESPONSE_TOO_LARGE)
+ val result = mutableListOf<ProviderLineup>()
+ var rejected = 0
+ for (group in groups) {
+ val membersResult = mapItems(group, mapping.members.items, MAX_LINEUP_MEMBERS) { member ->
+ val name = member.scalar(mapping.members.name) ?: throw IllegalArgumentException()
+ ProviderLineupMember(
+ competitor = ProviderCompetitor(
+ name = name,
+ id = mapping.members.id?.let { member.scalar(it) },
+ kind = mapping.members.kind,
+ ),
+ position = mapping.members.position?.let { member.scalar(it) },
+ shirtNumber = mapping.members.shirtNumber?.let { member.scalar(it) },
+ starter = mapping.members.starter?.let { member.scalar(it) }?.let(::parseBoolean),
+ )
+ }
+ when (membersResult) {
+ is SportsProviderResult.Failure -> return membersResult
+ is SportsProviderResult.Success -> {
+ rejected += membersResult.value.rejectedItemCount
+ if (result.sumOf { it.members.size } + membersResult.value.items.size > MAX_LINEUP_TOTAL_MEMBERS) {
+ return SportsProviderResult.Failure(SportsProviderError.RESPONSE_TOO_LARGE)
+ }
+ val teamName = mapping.teamName?.let { group.scalar(it) }
+ val team = teamName?.let {
+ ProviderCompetitor(it, mapping.teamId?.let { group.scalar(it) }, ProviderCompetitorKind.TEAM)
+ }
+ result += ProviderLineup(
+ providerEventId = eventId,
+ team = team,
+ members = membersResult.value.items,
+ updatedAt = mapping.updatedAt?.let { group.scalar(it) }?.let {
+ parseProviderTimestamp(it, mapping.updatedAtFormat)
+ },
+ )
+ }
+ }
+ }
+ return SportsProviderResult.Success(ProviderBatch(result, rejected))
+ }
+
+ fun statistics(
+ mapping: CustomStatisticsMapping,
+ body: JsonElement,
+ eventId: String,
+ ): SportsProviderResult<ProviderEventStatistics> {
+ val groups = body.select(mapping.groups.items)?.records()
+ ?: return SportsProviderResult.Failure(SportsProviderError.INVALID_RESPONSE)
+ if (groups.size > MAX_STATISTIC_GROUPS) {
+ return SportsProviderResult.Failure(SportsProviderError.RESPONSE_TOO_LARGE)
+ }
+ val statistics = mutableListOf<ProviderStatistic>()
+ for (group in groups) {
+ val team = mapping.groups.teamName?.let { group.scalar(it) }?.let { name ->
+ ProviderCompetitor(
+ name = name,
+ id = mapping.groups.teamId?.let { group.scalar(it) },
+ kind = ProviderCompetitorKind.TEAM,
+ )
+ }
+ val statRecords = group.select(mapping.groups.statistics.items)?.records()
+ ?: continue
+ if (statistics.size + statRecords.size > MAX_STATISTIC_ROWS) {
+ return SportsProviderResult.Failure(SportsProviderError.RESPONSE_TOO_LARGE)
+ }
+ statRecords.forEach { record ->
+ val key = record.scalar(mapping.groups.statistics.key) ?: return@forEach
+ statistics += ProviderStatistic(
+ key = key,
+ value = mapping.groups.statistics.value.let { record.scalar(it) },
+ competitor = team,
+ label = mapping.groups.statistics.label?.let { record.scalar(it) },
+ period = mapping.groups.statistics.period?.let { record.scalar(it) },
+ )
+ }
+ }
+ val updatedAt = mapping.updatedAt?.let { body.scalar(it) }?.let { parseProviderTimestamp(it, mapping.updatedAtFormat) }
+ return SportsProviderResult.Success(ProviderEventStatistics(eventId, statistics, updatedAt))
+ }
+
+ private fun mapBroadcasterItems(
+ record: JsonObject,
+ mapping: CustomBroadcasterFieldsMapping,
+ ): List<ProviderBroadcaster> = record.select(mapping.items).records().mapNotNull { item ->
+ runCatching { mapBroadcaster(item, mapping) }.getOrNull()
+ }
+
+ private fun mapBroadcaster(
+ item: JsonObject,
+ mapping: CustomBroadcasterFieldsMapping,
+ ): ProviderBroadcaster {
+ val name = item.scalar(mapping.name) ?: throw IllegalArgumentException()
+ val type = mapping.type?.let { item.scalar(it) }?.let(::broadcastType) ?: mapping.typeValue
+ return ProviderBroadcaster(
+ name = name,
+ country = mapping.country?.let { item.scalar(it) },
+ language = mapping.language?.let { item.scalar(it) },
+ type = type,
+ )
+ }
+
+ private fun JsonElement.singleObject(selector: String): JsonObject? = when (val selected = select(selector)) {
+ is JsonObject -> selected
+ is JsonArray -> selected.singleOrNull() as? JsonObject
+ else -> null
+ }
+
+ private fun broadcastType(value: String): ProviderBroadcastType = when (
+ value.trim().lowercase().replace('-', '_').replace(' ', '_')
+ ) {
+ "tv", "television", "linear", "linear_tv", "broadcast" -> ProviderBroadcastType.LINEAR_TV
+ "stream", "streaming", "streaming_service", "ott" -> ProviderBroadcastType.STREAMING_SERVICE
+ "radio", "audio" -> ProviderBroadcastType.RADIO
+ else -> ProviderBroadcastType.UNKNOWN
+ }
+
+ private fun artworkKind(value: String): ProviderArtworkKind =
+ ProviderArtworkKind.entries.firstOrNull { it.name == value.trim().uppercase() }
+ ?: ProviderArtworkKind.OTHER
+
+ private fun parseBoolean(value: String): Boolean? = when (value.trim().lowercase()) {
+ "true", "1", "yes", "starter" -> true
+ "false", "0", "no", "bench" -> false
+ else -> null
+ }
private fun <T : Any> mapItems(
body: JsonElement,
@@ -492,25 +1731,87 @@ internal object CustomSportsProviderJsonMapper {
}
}
- private fun SportsProviderResult<ProviderBatch<ProviderScore>>.filterIds(
+ private fun <T : Any> SportsProviderResult<ProviderBatch<T>>.filterIds(
requestedIds: Set<String>?,
- ): SportsProviderResult<ProviderBatch<ProviderScore>> = when (this) {
+ id: (T) -> String,
+ ): SportsProviderResult<ProviderBatch<T>> = when (this) {
is SportsProviderResult.Failure -> this
is SportsProviderResult.Success -> if (requestedIds == null) this else SportsProviderResult.Success(
- ProviderBatch(value.items.filter { it.providerEventId in requestedIds }, value.rejectedItemCount),
+ ProviderBatch(value.items.filter { id(it) in requestedIds }, value.rejectedItemCount),
+ )
+ }
+
+ private fun eventCompetitors(
+ record: JsonObject,
+ mapping: CustomEventCompetitorMapping,
+ kind: ProviderCompetitorKind,
+ ): List<ProviderCompetitor> = record.select(mapping.items).records().mapNotNull { competitor ->
+ val name = competitor.scalar(mapping.name) ?: return@mapNotNull null
+ ProviderCompetitor(
+ name = name,
+ id = mapping.id?.let { competitor.scalar(it) },
+ kind = kind,
+ role = role(mapping.role?.let { competitor.scalar(it) }, mapping.homeValue, mapping.awayValue),
+ logoUrl = mapping.logo?.let { competitor.scalar(it) }?.takeIf { raw ->
+ runCatching {
+ val uri = java.net.URI(raw)
+ uri.scheme == "https" && !uri.host.isNullOrBlank() && uri.userInfo == null && uri.fragment == null
+ }.getOrDefault(false)
+ },
)
}
+ private fun scoreCompetitors(
+ record: JsonObject,
+ mapping: CustomScoreCompetitorMapping,
+ ): List<ProviderCompetitorScore> {
+ if (mapping.score == null) return emptyList()
+ return record.select(mapping.items).records().mapNotNull { competitor ->
+ val name = competitor.scalar(mapping.name) ?: return@mapNotNull null
+ ProviderCompetitorScore(
+ competitor = ProviderCompetitor(
+ name = name,
+ id = mapping.id?.let { competitor.scalar(it) },
+ kind = mapping.kind,
+ role = role(mapping.role?.let { competitor.scalar(it) }, mapping.homeValue, mapping.awayValue),
+ ),
+ value = competitor.scalar(mapping.score),
+ )
+ }
+ }
+
+ private fun role(value: String?, homeValue: String, awayValue: String): ProviderCompetitorRole = when {
+ value.equals(homeValue, ignoreCase = true) -> ProviderCompetitorRole.HOME
+ value.equals(awayValue, ignoreCase = true) -> ProviderCompetitorRole.AWAY
+ else -> ProviderCompetitorRole.PARTICIPANT
+ }
+
+ private fun JsonElement?.records(): List<JsonObject> = when (this) {
+ is JsonArray -> mapNotNull { it as? JsonObject }
+ is JsonObject -> listOf(this)
+ else -> emptyList()
+ }
+
private fun JsonElement.select(selector: String): JsonElement? {
if (selector == "$") return this
- var current: JsonElement = this
- for (part in selector.removePrefix("$.").split('.')) {
- current = (current as? JsonObject)?.get(part) ?: return null
+ val segments = parseJsonSelector(selector, allowRoot = false)
+ var current = listOf(this)
+ for (segment in segments) {
+ val next = mutableListOf<JsonElement>()
+ current.forEach { value ->
+ when (segment) {
+ is JsonSelectorSegment.Key -> (value as? JsonObject)?.get(segment.value)?.let(next::add)
+ is JsonSelectorSegment.Index -> (value as? JsonArray)?.getOrNull(segment.value)?.let(next::add)
+ JsonSelectorSegment.All -> (value as? JsonArray)?.forEach(next::add)
+ }
+ }
+ if (next.isEmpty()) return null
+ current = next
}
- return current
+ return if (segments.any { it == JsonSelectorSegment.All }) JsonArray(current) else current.singleOrNull()
}
- private fun JsonObject.scalar(selector: String): String? =
+ private fun JsonElement.scalar(selector: String): String? =
select(selector)?.let { value ->
val primitive = value as? JsonPrimitive ?: return@let null
if (primitive is JsonNull || primitive.content.isBlank() || primitive.content.length > MAX_SCALAR_CHARS) {
@@ -525,25 +1826,67 @@ internal object CustomSportsProviderJsonMapper {
clock: String?,
period: String?,
updatedAt: Instant? = null,
+ detail: String? = null,
): ProviderGameStatus {
val state = when (value.trim().lowercase().replace('-', '_').replace(' ', '_')) {
- "scheduled", "not_started", "pending", "pre_game" -> ProviderGameState.SCHEDULED
- "live", "in_play", "in_progress", "inprogress", "halftime", "half_time" -> ProviderGameState.LIVE
+ "scheduled", "not_started", "pending", "pre_game", "pre" -> ProviderGameState.SCHEDULED
+ "live", "in", "in_play", "in_progress", "inprogress", "halftime", "half_time" -> ProviderGameState.LIVE
"suspended" -> ProviderGameState.SUSPENDED
"delayed", "delay" -> ProviderGameState.DELAYED
"postponed" -> ProviderGameState.POSTPONED
"cancelled", "canceled" -> ProviderGameState.CANCELLED
- "final", "finished", "complete", "completed" -> ProviderGameState.FINAL
+ "final", "finished", "complete", "completed", "post" -> ProviderGameState.FINAL
else -> ProviderGameState.UNKNOWN
}
- return ProviderGameStatus(state, clock, period, detail = value.takeIf { state == ProviderGameState.UNKNOWN }, updatedAt)
+ return ProviderGameStatus(
+ state, clock, period,
+ detail = detail ?: value.takeIf { state == ProviderGameState.UNKNOWN },
+ updatedAt = updatedAt,
+ )
}
private const val MAX_EVENT_ROWS = 2_000
private const val MAX_SCORE_ROWS = 1_000
+ private const val MAX_DETAIL_ROWS = 1_000
+ private const val MAX_STANDING_ROWS = 1_000
+ private const val MAX_STANDING_TOTAL_ROWS = 5_000
+ private const val MAX_STANDING_GROUPS = 100
+ private const val MAX_STANDING_COLUMNS = 100
+ private const val MAX_LINEUP_ROWS = 100
+ private const val MAX_LINEUP_MEMBERS = 2_000
+ private const val MAX_LINEUP_TOTAL_MEMBERS = 5_000
+ private const val MAX_STATISTIC_GROUPS = 100
+ private const val MAX_STATISTIC_ROWS = 5_000
private const val MAX_SCALAR_CHARS = 512
}
+private sealed interface JsonSelectorSegment {
+ data class Key(val value: String) : JsonSelectorSegment
+ data class Index(val value: Int) : JsonSelectorSegment
+ data object All : JsonSelectorSegment
+}
+
+private fun parseJsonSelector(selector: String, allowRoot: Boolean): List<JsonSelectorSegment> {
+ if (allowRoot && selector == "$") return emptyList()
+ val path = selector.removePrefix("$.")
+ require(path.isNotBlank())
+ val pathPart = Regex("([A-Za-z0-9_-]{1,64})(?:\\[(\\*|\\d{1,4})\\])?")
+ val segments = mutableListOf<JsonSelectorSegment>()
+ for (part in path.split('.')) {
+ val match = pathPart.matchEntire(part) ?: throw IllegalArgumentException()
+ segments += JsonSelectorSegment.Key(match.groupValues[1])
+ when (val index = match.groupValues[2]) {
+ "*" -> segments += JsonSelectorSegment.All
+ "" -> Unit
+ else -> segments += JsonSelectorSegment.Index(index.toInt())
+ }
+ require(segments.size <= MAX_SELECTOR_DEPTH)
+ }
+ return segments
+}
+
+private const val MAX_SELECTOR_DEPTH = 16
+
/** Resolve paths beneath the configured API base path; dynamic values are percent encoded. */
internal fun buildCustomSportsProviderUrl(
baseUrl: HttpUrl,
@@ -553,7 +1896,13 @@ internal fun buildCustomSportsProviderUrl(
require(baseUrl.isHttps && baseUrl.username.isEmpty() && baseUrl.password.isEmpty())
require(endpointTemplate.startsWith('/') && !endpointTemplate.startsWith("//"))
require('#' !in endpointTemplate && '\\' !in endpointTemplate && '\r' !in endpointTemplate && '\n' !in endpointTemplate)
- val expanded = Regex("\\{([A-Za-z][A-Za-z0-9]*)}").replace(endpointTemplate) { match ->
+ val pathTemplate = endpointTemplate.substringBefore('?')
+ for (requiredPathVariable in listOf("sport", "leagueId")) {
+ if ("{$requiredPathVariable}" in pathTemplate) {
+ require(!variables[requiredPathVariable].isNullOrBlank())
+ }
+ }
+ val expanded = Regex("\\{([A-Za-z][A-Za-z0-9]*)\\}").replace(endpointTemplate) { match ->
val value = requireNotNull(variables[match.groupValues[1]])
URLEncoder.encode(value, StandardCharsets.UTF_8.name()).replace("+", "%20")
}
diff --git a/data/src/main/java/com/streamvault/data/sports/provider/EncryptedSportsProviderStore.kt b/data/src/main/java/com/streamvault/data/sports/provider/EncryptedSportsProviderStore.kt
index ce0f048f..9ca3ce44 100644
--- a/data/src/main/java/com/streamvault/data/sports/provider/EncryptedSportsProviderStore.kt
+++ b/data/src/main/java/com/streamvault/data/sports/provider/EncryptedSportsProviderStore.kt
@@ -15,6 +15,9 @@ import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.withContext
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
import kotlinx.serialization.json.*
/** One atomic encrypted envelope in noBackupFilesDir, outside Room/preferences exports. */
@@ -31,6 +34,8 @@ class EncryptedSportsProviderStore internal constructor(
private val file = AtomicFile(file)
private val mutex = Mutex()
private val json = Json
+ private val revision = MutableStateFlow(0L)
+ override val configurationChanges = revision.asStateFlow()
override suspend fun configurations(): List<SportsProviderConfig> = access {
read().map { it.config }
@@ -54,11 +59,15 @@ class EncryptedSportsProviderStore internal constructor(
val record = Record(config, credentials ?: previous?.credentials)
if (index < 0) records.add(record) else records[index] = record
write(records)
+ revision.update { it + 1 }
}
}
override suspend fun remove(instanceId: String) {
- access { write(read().filterNot { it.config.instanceId == instanceId }) }
+ access {
+ write(read().filterNot { it.config.instanceId == instanceId })
+ revision.update { it + 1 }
+ }
}
private suspend fun <T> access(block: () -> T): T = withContext(Dispatchers.IO) {
diff --git a/data/src/test/java/com/streamvault/data/sports/custom/CustomSportsProviderTest.kt b/data/src/test/java/com/streamvault/data/sports/custom/CustomSportsProviderTest.kt
index f6395e74..8a19baa8 100644
--- a/data/src/test/java/com/streamvault/data/sports/custom/CustomSportsProviderTest.kt
+++ b/data/src/test/java/com/streamvault/data/sports/custom/CustomSportsProviderTest.kt
@@ -6,6 +6,7 @@ import com.streamvault.domain.sports.provider.*
import java.time.Instant
import java.util.concurrent.TimeUnit
import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.runBlocking
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonArray
import kotlinx.serialization.json.JsonObject
@@ -15,6 +16,8 @@ import okhttp3.OkHttpClient
import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
import okhttp3.mockwebserver.MockResponse
import okhttp3.mockwebserver.MockWebServer
+import okhttp3.mockwebserver.Dispatcher
+import okhttp3.mockwebserver.RecordedRequest
import okhttp3.tls.HandshakeCertificates
import okhttp3.tls.HeldCertificate
import org.junit.After
@@ -26,6 +29,128 @@ class CustomSportsProviderTest {
private lateinit var httpClient: SportsProviderHttpClient
private lateinit var store: TestProviderStore
+ @Test
+ fun `daily requests cover UTC dates and respect the exclusive end bound`() = runTest {
+ val definition = eventOnlyDefinition("\"mode\":\"none\"")
+ .replace("/events?from={fromDate}&to={toDate}&leagueId={leagueId}", "/events?date={date}")
+ .replace("\"events\":{", "\"events\":{\"dailyRequests\":true,\"dateFormat\":\"YYYYMMDD\",")
+ repeat(2) { server.enqueue(MockResponse().setBody(eventPayload())) }
+ val provider = CustomSportsProviderFactory(httpClient, store).create(config(definition)) as EventProvider
+
+ val result = provider.events(ProviderEventRequest(
+ Instant.parse("2026-10-17T21:00:00Z"), Instant.parse("2026-10-19T00:00:00Z"),
+ )) as SportsProviderResult.Success
+
+ val dates = List(2) { server.takeRequest(5, TimeUnit.SECONDS)!!.requestUrl!!.queryParameter("date") }
+ assertThat(dates).containsExactly("20261017", "20261018")
+ assertThat(result.value.items).hasSize(1)
+ }
+
+ @Test
+ fun `successful scope survives another stalled scope`() = runBlocking {
+ val definition = eventOnlyDefinition("\"mode\":\"none\"")
+ .replace("\"events\":{", "\"scopes\":[{\"leagueId\":\"fast\"},{\"leagueId\":\"slow\"}],\"events\":{")
+ server.dispatcher = object : Dispatcher() {
+ override fun dispatch(request: RecordedRequest): MockResponse =
+ if (request.requestUrl!!.queryParameter("leagueId") == "slow") {
+ MockResponse().setHeadersDelay(4, TimeUnit.SECONDS).setBody(eventPayload())
+ } else MockResponse().setBody(eventPayload())
+ }
+ val factory = CustomSportsProviderFactory(httpClient, store)
+ val provider = CustomSportsProvider(
+ config(definition), factory.descriptor, CustomSportsProviderDefinition.parse(definition),
+ httpClient, store, eventLoadTimeoutMillis = 1_000L,
+ )
+
+ val result = provider.events(ProviderEventRequest(
+ Instant.parse("2026-10-17T00:00:00Z"), Instant.parse("2026-10-18T00:00:00Z"),
+ )) as SportsProviderResult.Success
+
+ assertThat(result.value.items.single().providerEventId).isEqualTo("event-1")
+ assertThat(server.requestCount).isEqualTo(2)
+ }
+
+ @Test
+ fun `scopes load concurrently while duplicate IDs keep definition order`() = runBlocking {
+ val definition = eventOnlyDefinition("\"mode\":\"none\"")
+ .replace("\"leagueName\":\"league.name\",\"leagueId\":\"league.id\",", "")
+ .replace("\"events\":{", "\"scopes\":[{\"leagueId\":\"first\",\"leagueName\":\"Specific\"},{\"leagueId\":\"second\",\"leagueName\":\"Aggregate\"}],\"events\":{")
+ val arrived = java.util.concurrent.CountDownLatch(2)
+ val concurrent = java.util.concurrent.atomic.AtomicBoolean(true)
+ server.dispatcher = object : Dispatcher() {
+ override fun dispatch(request: RecordedRequest): MockResponse {
+ arrived.countDown()
+ if (!arrived.await(2, TimeUnit.SECONDS)) concurrent.set(false)
+ return MockResponse().setBody(eventPayload())
+ }
+ }
+ val provider = CustomSportsProviderFactory(httpClient, store).create(config(definition)) as EventProvider
+ val result = provider.events(ProviderEventRequest(
+ Instant.parse("2026-10-17T00:00:00Z"), Instant.parse("2026-10-18T00:00:00Z"),
+ )) as SportsProviderResult.Success
+
+ assertThat(concurrent.get()).isTrue()
+ assertThat(result.value.items.single().league?.name).isEqualTo("Specific")
+ assertThat(result.value.items.single().league?.id).isEqualTo("first")
+ }
+
+ @Test
+ fun `custom mapping parses nested competitors status broadcasters and scoped metadata`() {
+ val definition = CustomSportsProviderDefinition.parse(
+ """
+ {
+ "name": "Custom Multi-Sport",
+ "auth": { "mode": "none" },
+ "scopes": [{ "sport": "soccer", "leagueId": "league-1", "leagueName": "Premier League" }],
+ "events": {
+ "endpoint": "/events",
+ "items": "events",
+ "id": "id",
+ "title": "name",
+ "start": "date",
+ "startFormat": "ISO_OFFSET",
+ "competitors": {
+ "items": "competitions[0].competitors[*]",
+ "id": "team.id",
+ "name": "team.displayName",
+ "role": "homeAway",
+ "logo": "team.logo"
+ },
+ "competitorKind": "TEAM",
+ "status": "status.type.state",
+ "clock": "status.displayClock",
+ "period": "status.period",
+ "broadcasters": {
+ "items": "competitions[0].geoBroadcasts[*]",
+ "name": "media.shortName",
+ "country": "region",
+ "language": "lang",
+ "type": "type.shortName"
+ },
+ "dailyRequests": true
+ }
+ }
+ """.trimIndent(),
+ )
+ val payload = Json.parseToJsonElement(
+ """{"events":[{"id":"match","name":"River City at Harbor Town","date":"2026-10-17T11:30Z","status":{"type":{"state":"in"},"displayClock":"64:00","period":2},"competitions":[{"competitors":[{"homeAway":"away","team":{"id":"river-city","displayName":"River City","logo":"https://images.example/river-city.png"}},{"homeAway":"home","team":{"id":"harbor-town","displayName":"Harbor Town","logo":"http://unsafe.example/logo.png"}}],"geoBroadcasts":[{"media":{"shortName":"National Sports Network"},"region":"us","lang":"en","type":{"shortName":"TV"}}]}]}]}""",
+ )
+ val result = CustomSportsProviderJsonMapper.events(
+ definition.events, payload, sportFallback = "soccer", leagueIdFallback = "league-1",
+ leagueNameFallback = "Premier League",
+ ) as SportsProviderResult.Success
+ val event = result.value.items.single()
+ assertThat(definition.scopes).hasSize(1)
+ assertThat(definition.events.dailyRequests).isTrue()
+ assertThat(event.league?.id).isEqualTo("league-1")
+ assertThat(event.competitors.first { it.role == ProviderCompetitorRole.HOME }.name).isEqualTo("Harbor Town")
+ assertThat(event.competitors.first { it.role == ProviderCompetitorRole.AWAY }.logoUrl)
+ .isEqualTo("https://images.example/river-city.png")
+ assertThat(event.competitors.first { it.role == ProviderCompetitorRole.HOME }.logoUrl).isNull()
+ assertThat(event.status?.state).isEqualTo(ProviderGameState.LIVE)
+ assertThat(event.broadcasters.single().name).isEqualTo("National Sports Network")
+ }
+
@Before
fun start() {
val certificate = HeldCertificate.Builder()
@@ -77,8 +202,9 @@ class CustomSportsProviderTest {
assertThat(event.providerEventId).isEqualTo("event-1")
assertThat(event.eventStart).isEqualTo(Instant.parse("2026-10-17T19:30:00Z"))
assertThat(event.sport).isEqualTo("Football")
- assertThat(event.league).isEqualTo(ProviderLeague("Premier", "league-1"))
+ assertThat(event.league).isEqualTo(ProviderLeague("Premier", "league-1", "Football"))
assertThat(event.competitors.map { it.name }).containsExactly("North", "South").inOrder()
+ assertThat(event.competitors.map { it.logoUrl }).containsExactly(null, null)
assertThat(event.status?.state).isEqualTo(ProviderGameState.LIVE)
}
@@ -113,12 +239,12 @@ class CustomSportsProviderTest {
val eventsOnly = config(eventOnlyDefinition())
val eventsAndScores = config(withScoresDefinition(), id = "custom-with-scores")
- assertThat(registry.capabilities(eventsOnly)).containsExactly(SportsCapability.EVENTS)
+ assertThat(registry.capabilities(eventsOnly)).containsExactly(SportsCapability.EVENTS, SportsCapability.GAME_STATUS)
assertThat(registry.eligible(listOf(eventsOnly), SportsCapability.LIVE_SCORES)).isEmpty()
assertThat(registry.eligible(listOf(eventsOnly), SportsCapability.EVENTS))
.containsExactly(eventsOnly)
assertThat(registry.capabilities(eventsAndScores))
- .containsExactly(SportsCapability.EVENTS, SportsCapability.LIVE_SCORES)
+ .containsExactly(SportsCapability.EVENTS, SportsCapability.LIVE_SCORES, SportsCapability.GAME_STATUS)
}
@Test
diff --git a/data/src/test/java/com/streamvault/data/sports/provider/EncryptedSportsProviderStoreTest.kt b/data/src/test/java/com/streamvault/data/sports/provider/EncryptedSportsProviderStoreTest.kt
index 24e9c531..a70aeec9 100644
--- a/data/src/test/java/com/streamvault/data/sports/provider/EncryptedSportsProviderStoreTest.kt
+++ b/data/src/test/java/com/streamvault/data/sports/provider/EncryptedSportsProviderStoreTest.kt
@@ -18,6 +18,17 @@ import org.robolectric.annotation.Config
@RunWith(RobolectricTestRunner::class)
@Config(sdk = [28], manifest = Config.NONE)
class EncryptedSportsProviderStoreTest {
+ @Test fun `successful saves and removals invalidate sports consumers`() = runTest {
+ val store = store()
+ assertThat(store.configurationChanges.value).isEqualTo(0L)
+ store.save(config("account"))
+ assertThat(store.configurationChanges.value).isEqualTo(1L)
+ store.save(config("account"), SportsProviderCredentials("rotated"))
+ assertThat(store.configurationChanges.value).isEqualTo(2L)
+ store.remove("account")
+ assertThat(store.configurationChanges.value).isEqualTo(3L)
+ }
+
@get:Rule val temporary = TemporaryFolder()
// Fake crypto verifies the storage boundary, not the platform cipher.
private val crypto = object : CredentialCrypto {
diff --git a/data/src/test/java/com/streamvault/data/sports/provider/SportsDiscoveryPreferencesTest.kt b/data/src/test/java/com/streamvault/data/sports/provider/SportsDiscoveryPreferencesTest.kt
new file mode 100644
index 00000000..201dddb5
--- /dev/null
+++ b/data/src/test/java/com/streamvault/data/sports/provider/SportsDiscoveryPreferencesTest.kt
@@ -0,0 +1,33 @@
+package com.streamvault.data.sports.provider
+
+import androidx.datastore.preferences.preferencesDataStoreFile
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.data.preferences.PreferencesRepository
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.kotlin.mock
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [28], manifest = Config.NONE)
+class SportsDiscoveryPreferencesTest {
+ @Test fun `sports and leagues are independently persisted and can be included again`() = runBlocking {
+ val context = RuntimeEnvironment.getApplication()
+ context.preferencesDataStoreFile("user_preferences").delete()
+ val repository = PreferencesRepository(context, mock(), mock(), mock(), mock())
+ assertThat(repository.getExcludedSports().first()).isEmpty()
+ repository.setSportsSportIncluded("HOCKEY", false)
+ repository.setSportsLeagueIncluded("wnba", false)
+ assertThat(repository.getExcludedSports().first()).containsExactly("HOCKEY")
+ assertThat(repository.getExcludedSportsLeagues().first()).containsExactly("wnba")
+ repository.setSportsSportIncluded("HOCKEY", true)
+ assertThat(repository.getExcludedSports().first()).isEmpty()
+ assertThat(repository.getExcludedSportsLeagues().first()).containsExactly("wnba")
+ repository.resetSportsInclusions()
+ assertThat(repository.getExcludedSportsLeagues().first()).isEmpty()
+ }
+}
diff --git a/docs/images/Sports.png b/docs/images/Sports.png
index 64262697..2f654c28 100644
Binary files a/docs/images/Sports.png and b/docs/images/Sports.png differ
diff --git a/docs/sports/custom-provider.md b/docs/sports/custom-provider.md
index 76199af3..bfc2c08b 100644
--- a/docs/sports/custom-provider.md
+++ b/docs/sports/custom-provider.md
@@ -1,10 +1,10 @@
# Custom JSON sports provider
-The Custom JSON provider connects one HTTPS JSON API account to sports events and, optionally, live scores. Its mapping is declarative: the app selects fields from JSON and never runs scripts or follows provider-supplied URLs.
+The Custom JSON provider connects one HTTPS JSON API account to the app's provider-neutral sports models. It can map events, scores/status, standings, team and league metadata, broadcasters, artwork references, lineups, and statistics. Its mapping is declarative: the app selects fields from JSON and never runs scripts or follows provider-supplied URLs.
## Setup
-In Settings, add **Custom JSON provider**, enter the API base URL, then paste a definition like this into **Configuration (JSON)**:
+In Settings, add **Custom JSON provider**, enter the API base URL, then paste a definition like this into **Configuration (JSON)** or import a JSON file:
```json
{
@@ -49,9 +49,9 @@ In Settings, add **Custom JSON provider**, enter the API base URL, then paste a
}
```
-The event mapping is required. The score mapping is optional; its presence enables the Live scores capability. The `name` is shown in Settings so separately configured custom APIs are easy to tell apart.
+The event mapping is required. The score mapping is optional; its presence enables the Live scores capability. The `name` is shown in Settings so separately configured custom APIs are easy to tell apart. Use a shared API root as the base URL when endpoint templates include sport and league path placeholders.
-After entering the definition and any required credentials, use **Test** to call the configured events endpoint for a 24-hour UTC window and validate the response mapping. Then save the account.
+After entering the definition and any required credentials, use **Test** to call the first configured event scope for a 24-hour UTC window and validate the event mapping. Then save the account. Optional data mappings are enabled only when their sections are present in the JSON.
## Authentication
@@ -69,11 +69,11 @@ Credentials are stored separately from the definition in the encrypted provider
## Endpoints and selectors
-Endpoint templates must start with `/`. They are appended to the base URL path, so base URL `https://example.com/api` and endpoint `/events` request `https://example.com/api/events`. The final request must remain HTTPS on the same host and port. Placeholder values are percent-encoded. Event endpoints accept `{date}`, `{fromDate}`, `{toDate}`, `{leagueId}`, and `{sport}`. `{date}` is the UTC date at the start of the requested window. Score endpoints must use exactly one of `{eventId}` or `{eventIds}`; `{eventIds}` sends a comma-separated, sorted ID list, with at most 50 requested IDs.
+Endpoint templates must start with `/`. They are appended to the base URL path, so base URL `https://example.com/api` and endpoint `/events` request `https://example.com/api/events`. The final request must remain HTTPS on the same host and port. Placeholder values are percent-encoded. Event endpoints accept `{date}`, `{fromDate}`, `{toDate}`, `{fromDateFormatted}`, `{toDateFormatted}`, `{leagueId}`, and `{sport}`. The formatted bounds use the configured `dateFormat`, are UTC, and account for the request's exclusive end boundary; use them for APIs that accept date ranges. A top-level `scopes` array can declare multiple `{sport}`/`{leagueId}` routes in the JSON; when present and the provider's league IDs setting is empty, the app queries each declared scope and combines results. Each scope can also have a `leagueName` fallback. Specific leagues should come before broad scopes because the first copy of a duplicate event ID is retained. A non-empty provider league IDs setting takes precedence over JSON scopes; for endpoints with both `{sport}` and `{leagueId}`, enter those settings as `sport/league`. `{date}` is the UTC date at the start of the requested window. Score endpoints must use exactly one of `{eventId}` or `{eventIds}`; `{eventIds}` sends a comma-separated, sorted ID list, with at most 50 requested IDs.
-`items` selects the array of records, or one object record, from the response. It may use `$` for the whole response. Other selectors are dot-separated object keys such as `data.events` or `home.name`; an optional `$.` prefix is accepted. Array indexes, wildcards, general JSONPath expressions, and scripts are not supported.
+`items` selects the array of records, or one object record, from the response. It may use `$` for the whole response. Other selectors are dot-separated object keys such as `data.events` or `home.name`; an optional `$.` prefix is accepted. Explicit array indexes and wildcards are supported, for example `competitions[0].competitors[*]`. General JSONPath expressions and scripts are not supported.
-Every event needs an ID, start timestamp, and at least one competitor name. Event timestamps require `startFormat`; score `updatedAtFormat` defaults to `ISO_OFFSET` when `updatedAt` is mapped. Supported formats are:
+Every event needs an ID, start timestamp, and at least one competitor name. Competitors can be mapped from a nested list by setting `events.competitors.items`, `name`, and optionally `id` and `role`; `homeValue` and `awayValue` default to `home` and `away`. Existing `homeName`/`awayName` configurations remain supported. `sportValue`, `leagueNameValue`, and `leagueIdValue` let an endpoint provide fixed metadata. Event timestamps require `startFormat`; `dateFormat` optionally controls `{date}` and supports `ISO_LOCAL_DATE` (default) or `YYYYMMDD`. Score `updatedAtFormat` defaults to `ISO_OFFSET` when `updatedAt` is mapped. Timestamp formats are:
- `ISO_OFFSET`: ISO-8601 timestamp containing its UTC offset, such as `2026-10-17T19:30:00Z`.
- `UNIX_SECONDS`: Unix epoch seconds.
@@ -81,8 +81,12 @@ Every event needs an ID, start timestamp, and at least one competitor name. Even
Competitor kinds are `TEAM`, `PERSON`, and `PLAYER`. Common status values such as `scheduled`, `in_progress`, `halftime`, `postponed`, `cancelled`, and `finished` map to provider-neutral game states; unrecognized values are retained as status detail.
-## Limits and current scope
+## Optional sports data mappings
-Definitions are limited to 32 KiB, endpoint templates to 512 characters, selectors to 256 characters and 16 path segments, and mapped scalar values to 512 characters. HTTP responses are capped at 2 MiB by the shared provider client. Event feeds are capped at 2,000 records and score feeds at 1,000 records.
+The schema also accepts `statuses`, `standings`, `team`, `league`, `artwork`, `broadcasters`, `lineups`, and `statistics` blocks. Grouped standings and statistics use nested collection selectors. Artwork references must be absolute HTTPS URLs. Inline `events.broadcasters` can map broadcaster data from the event response itself. These blocks activate their matching provider capabilities; omit them when the API does not offer that data.
-This version supports events and live scores only. It does not follow pagination links, execute scripts, support OAuth, or map generic standings tables. Use a reviewed built-in adapter when an API needs pagination, richer authentication, metadata, or provider-specific behavior.
+## Limits
+
+Definitions are limited to 32 KiB, endpoint templates to 512 characters, selectors to 256 characters and 16 path segments, and mapped scalar values to 512 characters. HTTP responses are capped at 2 MiB by the shared provider client, event feeds at 2,000 rows, and score and detail batches at 1,000 rows. ID-based detail batches are limited to 50 event IDs.
+
+The adapter does not follow pagination links, execute scripts, or support OAuth. See [the provider guide](providers/custom-json.md) for selectors and capability-specific mappings.
diff --git a/docs/sports/providers/custom-json.md b/docs/sports/providers/custom-json.md
index c84784ea..86cfd1c5 100644
--- a/docs/sports/providers/custom-json.md
+++ b/docs/sports/providers/custom-json.md
@@ -1,8 +1,8 @@
# Custom REST/JSON sports provider
-Use this advanced option when you have an HTTPS sports API that is not covered by a built-in provider. It makes ordinary GET requests and maps the API's JSON response into StreamVault events and optional live scores. It does not run scripts or provide standings, artwork, or playback links.
+Use this advanced option when you have an HTTPS sports API that is not covered by a built-in provider. It makes ordinary GET requests and maps JSON into provider-neutral sports data: events, scores and status, standings, team and league metadata, broadcasters, artwork references, lineups, and statistics. Every section beyond `events` is optional. The adapter never runs scripts or supplies playback links.
-In Settings > Sports data providers, choose **Custom JSON provider**. Enter the API's HTTPS base URL, select **Insert example**, then edit the endpoint paths and field selectors to match the API documentation. Put the API key or token in the credential field, choose **Test**, and save only after the test succeeds. The inserted configuration is a template, not a working account.
+In Settings > Sports data providers, choose **Custom JSON provider**. Enter the API's HTTPS base URL, then paste a definition or use **Load JSON file** to import one. Put the API key or token in the credential field, choose **Test**, and save only after the test succeeds. The inserted generic configuration is a template, not a working account.
## Starter configuration
@@ -39,17 +39,31 @@ In Settings > Sports data providers, choose **Custom JSON provider**. Enter the
}
```
-The API base URL is entered separately. Endpoint paths must begin with `/` and stay on that HTTPS host. The sample assumes fixture rows like `data.events[0]` and score rows like `data.scores[0]`; replace those assumptions with the exact response structure documented by your API.
+The API base URL is entered separately. Endpoint paths must begin with `/` and stay on that HTTPS host. The sample assumes fixture rows like `data.events[0]` and score rows like `data.scores[0]`; replace those assumptions with the exact response structure documented by your API. If endpoint paths include both `{sport}` and `{leagueId}`, configure scopes either in the JSON `scopes` array or the provider's league IDs setting as `sport/league` pairs.
+
+Custom discovery runs at most four requests concurrently, with a 15-second discovery budget; completed scopes are retained when another scope stalls. Duplicate IDs retain the earliest scope in definition order. Event-scoped score calls also use four concurrent requests and retain completed results within four seconds. Guide and API discovery run concurrently, so either can supply visible events while the other finishes. Automatic clock refresh waits for an in-flight scan rather than canceling it. Optional broadcaster, score, and metadata enrichment cannot keep the Sports tab on its initial loading screen. Saving, editing, disabling, or removing an account invalidates the retained Sports tab.
## Configuration fields
- `name` is the label shown in provider settings.
- `auth.mode` is `none`, `api_key_header`, `api_key_query`, `bearer`, or `basic`. Header/query key modes require `parameterName`. Enter the key or bearer token in the secret field; Basic auth uses the username and password fields. Credentials are stored separately from the mapping.
-- `events.endpoint` is a relative path. It may use `{date}`, `{fromDate}`, `{toDate}`, `{leagueId}`, and `{sport}`. These values come from the sports request; the date bounds are UTC.
-- `events.items` selects the array of event records. `id`, `start`, `homeName`, and `awayName` are required selectors. Other event selectors are optional.
-- Selectors are dot-separated object paths such as `data.events`, `home.name`, or `league.id`. Array indexes, wildcards, and executable expressions are not supported. Use `$.` before a path or `$` only when the entire response is the array.
-- `startFormat` and `updatedAtFormat` accept `ISO_OFFSET`, `UNIX_SECONDS`, or `UNIX_MILLISECONDS`. Use the format that matches the API response.
-- `scores` is optional. Its endpoint must include exactly one of `{eventId}` or `{eventIds}`. The batch form `{eventIds}` receives a comma-separated list. `items` selects score records, and `eventId` must map back to the event ID. At least one score or status selector is required. Each score selector requires its corresponding `homeName` or `awayName` selector.
+- `events.endpoint` is a relative path. It may use `{date}`, `{fromDate}`, `{toDate}`, `{fromDateFormatted}`, `{toDateFormatted}`, `{leagueId}`, and `{sport}`. The raw date bounds are ISO timestamps; the formatted bounds use `events.dateFormat` and are UTC. `{toDateFormatted}` is the last date in the request interval, since the end bound is exclusive. For APIs that accept a range, place the separator in the endpoint template, for example `?dates={fromDateFormatted}-{toDateFormatted}`.
+- Optional `events.dailyRequests: true` queries every UTC calendar date touched by the requested interval (exclusive end), using `{date}` and `events.dateFormat`. It requires `{date}` in the endpoint, accepts at most 14 calendar dates, and shares the same concurrency and time budget across dates and leagues. Leave it absent or `false` for APIs that accept a whole interval in one request.
+- Optional top-level `scopes` declares the sport/league routes the adapter should query when the provider's **League IDs** setting is empty. Each entry may contain `sport`, `leagueId`, and `leagueName`; at least `sport` or `leagueId` is required. The adapter queries each declared scope, combines the events, and removes duplicate event IDs. If both a sport and league placeholder are used, every declared scope needs both values. Up to 50 scopes are accepted. Put specific league routes before broad aggregate routes so a duplicated event keeps its league-specific ID. `leagueName` is also used as fallback metadata and to select the matching league-specific standings route.
+- If **League IDs** contains values, those settings take precedence and the adapter queries those scopes instead. For endpoints with both `{sport}` and `{leagueId}`, enter values as `sport/league` (for example `soccer/eng.1`).
+- `events.items` selects the array of event records. `id` and `start` are required. Competitors can use the legacy `homeName`/`awayName` selectors or a `competitors` collection mapping with `items`, `name`, optional `id` and `role`, and optional `homeValue`/`awayValue` strings. When role is mapped, its values default to `home` and `away`.
+- A collection mapping can traverse nested arrays, and maps each selected object as a competitor. For example, `competitions[0].competitors[*]` selects competitors from the first competition. Use `[0]` for an array index or `[*]` to select every element.
+- Add an optional `events.competitors.logo` selector for inline team logos (for example, `team.logo`). Only absolute HTTPS image URLs without credentials or fragments are accepted; missing or invalid logos use the team's initial.
+- `sportValue`, `leagueNameValue`, and `leagueIdValue` can provide fixed event metadata when it is identified by the configured endpoint rather than returned on every event. Each fixed value is mutually exclusive with its corresponding selector.
+- Selectors are dot-separated object paths such as `data.events`, `home.name`, or `league.id`, with explicit array indexes (`[0]`) and wildcards (`[*]`) such as `competitions[0].competitors[*]`. Use `$.` before a path or `$` only when the entire response is the array. General JSONPath expressions and scripts are not supported.
+- `startFormat` and `updatedAtFormat` accept `ISO_OFFSET`, `UNIX_SECONDS`, or `UNIX_MILLISECONDS`. Use the format that matches the API response. `dateFormat` controls `{date}`, `{fromDateFormatted}`, and `{toDateFormatted}` endpoint values; it accepts `ISO_LOCAL_DATE` (the default) or `YYYYMMDD`.
+- `scores` is optional. Its endpoint must include exactly one of `{eventId}` or `{eventIds}`. The batch form `{eventIds}` receives a comma-separated list. Event-scoped endpoints can also use `{sport}` and `{leagueId}`; score requests inherit those values from the event's configured scope. `items` selects score records, and `eventId` must map back to the event ID. At least one score or status selector is required. Scores can use legacy `homeName`/`homeScore` and `awayName`/`awayScore` selectors, or a nested `competitors` mapping with `items`, `name`, optional `id`, `score`, `role`, role values, and `kind`.
- Score timestamps are optional. When present, set `updatedAtFormat` to match their representation.
+- `statuses` is an optional event status endpoint. It accepts `{eventId}` or `{eventIds}`, plus optional `{sport}` and `{leagueId}` scope values, and maps `eventId`, `status`, and optional clock, period, detail, and update time. `scores.status` or `events.status` also enables the game-status capability.
+- `standings` maps grouped tables. Its `groups.items` selects conference/division objects, and `groups.rows` maps team names, optional IDs and ranks, plus optional `statistics` arrays into table columns. Use `leagueIdValue` when the response does not include an ID.
+- `team` and `league` map one metadata record each. Their endpoints may use `{teamId}` or `{leagueId}`, plus optional `{sport}` and `{leagueId}` scope values where applicable. `artwork` maps HTTPS artwork URLs for a requested `{entityId}` and `{entityType}`; it can also use the event's `{sport}` and `{leagueId}` scope. Relative URLs and non-HTTPS URLs are rejected.
+- `broadcasters` maps a per-event detail response and may use `{eventId}`, `{sport}`, and `{leagueId}`. The same `items`, `name`, `country`, `language`, `type`, or `typeValue` fields may be nested under `events.broadcasters` to map broadcast data already included in the event response.
+- `lineups` maps team groups and nested member records from an event detail endpoint. `statistics` maps team groups and their nested statistic rows into typed provider models. Both inherit `{sport}` and `{leagueId}` from the matching event.
+- Optional endpoint placeholders include `{sport}` and `{leagueId}` for sport/league-scoped routes, `{eventId}`/`{eventIds}` for event details and status, `{leagueId}`/`{season}` for standings, `{teamId}` for team metadata, and `{entityId}`/`{entityType}` for artwork.
The app bounds request sizes and only follows endpoint paths on the configured HTTPS host. You remain responsible for having the rights to use the chosen API and data in your setup.
diff --git a/domain/src/main/java/com/streamvault/domain/sports/provider/SportsEventProvenance.kt b/domain/src/main/java/com/streamvault/domain/sports/provider/SportsEventProvenance.kt
index 6d508483..045ba79c 100644
--- a/domain/src/main/java/com/streamvault/domain/sports/provider/SportsEventProvenance.kt
+++ b/domain/src/main/java/com/streamvault/domain/sports/provider/SportsEventProvenance.kt
@@ -16,6 +16,8 @@ sealed interface SportsSourceRef {
val instanceId: String,
val typeId: String,
val externalEventId: String,
+ val sport: String? = null,
+ val leagueId: String? = null,
) : SportsSourceRef {
init {
require(instanceId.isNotBlank() && typeId.isNotBlank() && externalEventId.isNotBlank())
diff --git a/domain/src/main/java/com/streamvault/domain/sports/provider/SportsProvider.kt b/domain/src/main/java/com/streamvault/domain/sports/provider/SportsProvider.kt
index dd2e41d9..929dd400 100644
--- a/domain/src/main/java/com/streamvault/domain/sports/provider/SportsProvider.kt
+++ b/domain/src/main/java/com/streamvault/domain/sports/provider/SportsProvider.kt
@@ -89,7 +89,7 @@ data class SportsProviderConfig(
private companion object {
const val MAX_EVENT_LEAGUE_IDS = 50
- val EVENT_LEAGUE_ID = Regex("[A-Za-z0-9._:-]{1,128}")
+ val EVENT_LEAGUE_ID = Regex("(?=.{1,128}$)[A-Za-z0-9._:-]+(?:/[A-Za-z0-9._:-]+)?")
}
}
@@ -152,6 +152,9 @@ data class SportsProviderHealth(
/** Provider configurations stay separate from preferences and use dedicated portable backup records. */
interface SportsProviderStore {
+ /** Invalidates consumers after a persisted configuration or credential change. */
+ val configurationChanges: kotlinx.coroutines.flow.Flow<Long>
+ get() = kotlinx.coroutines.flow.flowOf(0L)
suspend fun configurations(): List<SportsProviderConfig>
suspend fun credentials(instanceId: String): SportsProviderCredentials?
suspend fun credentialedInstanceIds(): Set<String> = configurations().mapNotNull { config ->
diff --git a/domain/src/main/java/com/streamvault/domain/sports/provider/SportsProviderCapabilities.kt b/domain/src/main/java/com/streamvault/domain/sports/provider/SportsProviderCapabilities.kt
index 53be0acc..fd3e2d08 100644
--- a/domain/src/main/java/com/streamvault/domain/sports/provider/SportsProviderCapabilities.kt
+++ b/domain/src/main/java/com/streamvault/domain/sports/provider/SportsProviderCapabilities.kt
@@ -12,24 +12,46 @@ data class ProviderEventRequest(
init { require(from.isBefore(until)) }
}
+/** Identifies a provider event's sport/league path when detail APIs require scoped URLs. */
+data class ProviderEventScope(val sport: String? = null, val leagueId: String? = null)
+
/** IDs belong to the receiving provider instance. Adapters own API batch/pagination limits. */
-data class ProviderScoreRequest(val eventIds: Set<String>) {
+data class ProviderScoreRequest(
+ val eventIds: Set<String>,
+ val eventScopes: Map<String, ProviderEventScope> = emptyMap(),
+) {
init { require(eventIds.isNotEmpty() && eventIds.none { it.isBlank() }) }
}
-data class ProviderEventDetailRequest(val eventId: String) {
+data class ProviderEventDetailRequest(
+ val eventId: String,
+ val sport: String? = null,
+ val leagueId: String? = null,
+) {
init { require(eventId.isNotBlank()) }
}
-data class ProviderStandingsRequest(val leagueId: String, val season: String? = null) {
+data class ProviderStandingsRequest(
+ val leagueId: String,
+ val season: String? = null,
+ val sport: String? = null,
+ val leagueName: String? = null,
+) {
init { require(leagueId.isNotBlank()) }
}
-data class ProviderTeamMetadataRequest(val teamId: String) {
+data class ProviderTeamMetadataRequest(
+ val teamId: String,
+ val sport: String? = null,
+ val leagueId: String? = null,
+) {
init { require(teamId.isNotBlank()) }
}
-data class ProviderLeagueMetadataRequest(val leagueId: String) {
+data class ProviderLeagueMetadataRequest(
+ val leagueId: String,
+ val sport: String? = null,
+) {
init { require(leagueId.isNotBlank()) }
}
diff --git a/domain/src/main/java/com/streamvault/domain/sports/provider/SportsProviderModels.kt b/domain/src/main/java/com/streamvault/domain/sports/provider/SportsProviderModels.kt
index 3136ad92..49094b7a 100644
--- a/domain/src/main/java/com/streamvault/domain/sports/provider/SportsProviderModels.kt
+++ b/domain/src/main/java/com/streamvault/domain/sports/provider/SportsProviderModels.kt
@@ -15,8 +15,15 @@ data class ProviderCompetitor(
val id: String? = null,
val kind: ProviderCompetitorKind = ProviderCompetitorKind.UNKNOWN,
val role: ProviderCompetitorRole = ProviderCompetitorRole.PARTICIPANT,
+ val logoUrl: String? = null,
) {
- init { require(name.isNotBlank()) }
+ init {
+ require(name.isNotBlank())
+ require(logoUrl == null || runCatching {
+ val uri = URI(logoUrl)
+ uri.scheme == "https" && !uri.host.isNullOrBlank() && uri.userInfo == null && uri.fragment == null
+ }.getOrDefault(false))
+ }
}
enum class ProviderGameState { SCHEDULED, LIVE, SUSPENDED, DELAYED, POSTPONED, CANCELLED, FINAL, UNKNOWN }
@@ -126,7 +133,12 @@ data class ProviderLeagueMetadata(
enum class ProviderEntityType { EVENT, TEAM, LEAGUE, COMPETITOR }
-data class ProviderEntityRef(val type: ProviderEntityType, val id: String) {
+data class ProviderEntityRef(
+ val type: ProviderEntityType,
+ val id: String,
+ val sport: String? = null,
+ val leagueId: String? = null,
+) {
init { require(id.isNotBlank()) }
}
diff --git a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsChannelFallbackMatcher.kt b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsChannelFallbackMatcher.kt
index 6f3b32e8..04ea137f 100644
--- a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsChannelFallbackMatcher.kt
+++ b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsChannelFallbackMatcher.kt
@@ -9,6 +9,7 @@ import java.time.LocalTime
import java.time.Month
import java.time.ZoneId
import java.util.Locale
+import java.util.concurrent.ConcurrentHashMap
private val CHANNEL_NAME_DECORATION = setOf(
"4k", "alt", "backup", "feed", "fhd", "h265", "hd", "hevc", "raw", "uhd", "vip",
@@ -44,6 +45,15 @@ internal class SportsChannelIndex private constructor(
private val tokensByIndex: List<Set<String>>,
private val tokenToIndices: Map<String, Set<Int>>,
) {
+ private val broadcasterNamesByIndex = ConcurrentHashMap<Int, Set<String>>()
+
+ fun broadcasterNames(index: Int): Set<String> = broadcasterNamesByIndex.getOrPut(index) {
+ val channel = entries[index].channel
+ setOf(channel.name, channel.canonicalName).filter(String::isNotBlank).mapTo(mutableSetOf()) { name ->
+ SportsTextNormalizer.normalize(ChannelNormalizer.classify(name, channel.providerId).canonicalName)
+ }
+ }
+
val byCanonicalName: Map<String, List<Int>> by lazy {
entries.indices.groupBy { index ->
val channel = entries[index].channel
@@ -194,9 +204,10 @@ internal object SportsChannelFallbackMatcher {
add(surname)
}
}
- }
+ }.mapTo(mutableSetOf(), SportsTextNormalizer::normalize)
}
val leagueAliases = SportsLeagueRegistry.aliasesFor(event.league)
+ .mapTo(mutableSetOf(), SportsTextNormalizer::normalize)
val eventTokens = eventSpecificTokens(event, leagueAliases)
val broadcasterNames = event.provenance.broadcasters?.value.orEmpty()
.filter { it.type != com.streamvault.domain.sports.provider.ProviderBroadcastType.RADIO }
@@ -208,9 +219,7 @@ internal object SportsChannelFallbackMatcher {
addAll(SportsTextNormalizer.normalize(alias).split(' ').filter(String::isNotBlank))
}
addAll(eventTokens)
- leagueAliases.forEach { alias ->
- addAll(SportsTextNormalizer.normalize(alias).split(' ').filter(String::isNotBlank))
- }
+ // League-only candidates cannot establish event or broadcaster identity.
broadcasterNames.forEach { broadcaster ->
addAll(broadcaster.split(' ').filter(String::isNotBlank))
}
@@ -230,6 +239,7 @@ internal object SportsChannelFallbackMatcher {
leagueAliases = leagueAliases,
eventTokens = eventTokens,
broadcasterNames = broadcasterNames,
+ channelBroadcasterNames = if (broadcasterNames.isEmpty()) emptySet() else index.broadcasterNames(candidateIndex),
dateSource = index.dateSource(candidateIndex),
zoneId = zoneId,
) ?: continue
@@ -309,6 +319,7 @@ internal object SportsChannelFallbackMatcher {
leagueAliases: Set<String>,
eventTokens: Set<String>,
broadcasterNames: Set<String>,
+ channelBroadcasterNames: Set<String>,
dateSource: String,
zoneId: ZoneId,
): SportsChannelMatch? {
@@ -316,10 +327,7 @@ internal object SportsChannelFallbackMatcher {
val hasCompetitorPair = competitorAliases.size >= 2 && competitorAliases
.take(2)
.all { aliases -> aliases.any { alias -> containsPhrase(channelName, alias) } }
- val hasBroadcasterMatch = broadcasterNames.any { broadcaster ->
- broadcaster == normalizedBroadcasterName(entry.channel.name, entry.channel.providerId) ||
- broadcaster == normalizedBroadcasterName(entry.channel.canonicalName, entry.channel.providerId)
- }
+ val hasBroadcasterMatch = broadcasterNames.any(channelBroadcasterNames::contains)
val reasons = linkedSetOf<SportsChannelMatchReason>()
var score = 0
var hasEventIdentityMatch = false
@@ -395,9 +403,8 @@ internal object SportsChannelFallbackMatcher {
SportsTextNormalizer.normalize(ChannelNormalizer.classify(name, providerId).canonicalName)
private fun containsPhrase(normalizedText: String, phrase: String): Boolean {
- val normalizedPhrase = SportsTextNormalizer.normalize(phrase)
- if (normalizedPhrase.isBlank()) return false
- return " $normalizedText ".contains(" $normalizedPhrase ")
+ if (phrase.isBlank()) return false
+ return " $normalizedText ".contains(" $phrase ")
}
private fun manualQueryScore(
diff --git a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsDiagnostics.kt b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsDiagnostics.kt
index 074682d0..e052b1ca 100644
--- a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsDiagnostics.kt
+++ b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsDiagnostics.kt
@@ -2,6 +2,7 @@ package com.streamvault.feature.live.sports
import android.util.Log
import com.streamvault.domain.model.Program
+import com.streamvault.domain.sports.provider.SportsProviderError
internal object SportsDiagnostics {
private const val TAG = "SportsHub"
@@ -10,6 +11,13 @@ internal object SportsDiagnostics {
fun isEnabled(): Boolean = Log.isLoggable(TAG, Log.DEBUG)
+ fun providerFailure(stage: String, category: SportsProviderError, httpStatus: Int? = null) {
+ // Diagnostics must never interrupt provider fallback (including host-side tests).
+ runCatching {
+ if (isEnabled()) Log.d(TAG, "provider-stage=$stage category=$category httpStatus=$httpStatus")
+ }
+ }
+
fun classificationCache(hits: Long, misses: Long, entries: Int, estimatedBytes: Long) {
if (!Log.isLoggable(PERFORMANCE_TAG, Log.DEBUG)) return
Log.d(PERFORMANCE_TAG, "stage=classification-cache hits=$hits misses=$misses entries=$entries estimatedBytes=$estimatedBytes")
diff --git a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsDiscoveryControls.kt b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsDiscoveryControls.kt
new file mode 100644
index 00000000..ccc88032
--- /dev/null
+++ b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsDiscoveryControls.kt
@@ -0,0 +1,200 @@
+package com.streamvault.feature.live.sports
+
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.BorderStroke
+import androidx.compose.material3.Checkbox
+import androidx.compose.material3.CheckboxDefaults
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.OutlinedTextFieldDefaults
+import androidx.compose.runtime.*
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusProperties
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.focus.onFocusChanged
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalSoftwareKeyboardController
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.semantics.toggleableState
+import androidx.compose.ui.state.ToggleableState
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.compose.ui.window.Dialog
+import androidx.compose.ui.window.DialogProperties
+import androidx.tv.material3.Border
+import androidx.tv.material3.ClickableSurfaceDefaults
+import androidx.tv.material3.Surface
+import androidx.tv.material3.SurfaceDefaults
+import androidx.tv.material3.Text
+import com.streamvault.core.ui.design.BrowseColors
+import com.streamvault.core.ui.design.BrowseShapes
+import com.streamvault.core.ui.interaction.TvButton
+import com.streamvault.core.ui.interaction.TvClickableSurface
+import com.streamvault.feature.live.R
+
+@Composable
+internal fun SportsDiscoverySearch(query: String, onQuery: (String) -> Unit, onOpenInclusions: () -> Unit) {
+ var acceptsInput by remember { mutableStateOf(false) }
+ val inputFocusRequester = remember { FocusRequester() }
+ val keyboardController = LocalSoftwareKeyboardController.current
+ val searchLabel = stringResource(R.string.live_sports_search_events)
+ LaunchedEffect(acceptsInput) {
+ if (acceptsInput) {
+ withFrameNanos { }
+ inputFocusRequester.requestFocus()
+ keyboardController?.show()
+ }
+ }
+ Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(12.dp), verticalAlignment = Alignment.CenterVertically) {
+ Box(Modifier.weight(1f)) {
+ OutlinedTextField(
+ value = query, onValueChange = onQuery, singleLine = true,
+ label = { Text(searchLabel, color = BrowseColors.TextSecondary) },
+ modifier = Modifier
+ .fillMaxWidth()
+ .focusRequester(inputFocusRequester)
+ .focusProperties { canFocus = acceptsInput }
+ .onFocusChanged { focusState ->
+ if (acceptsInput && !focusState.isFocused) {
+ acceptsInput = false
+ keyboardController?.hide()
+ }
+ },
+ readOnly = !acceptsInput,
+ colors = sportsSearchColors(),
+ )
+ if (!acceptsInput) {
+ TvClickableSurface(
+ onClick = { acceptsInput = true },
+ modifier = Modifier
+ .matchParentSize()
+ .semantics {
+ contentDescription = searchLabel
+ },
+ shape = ClickableSurfaceDefaults.shape(BrowseShapes.Control),
+ colors = ClickableSurfaceDefaults.colors(
+ containerColor = Color.Transparent,
+ focusedContainerColor = Color.Transparent,
+ contentColor = Color.Transparent,
+ focusedContentColor = Color.Transparent,
+ ),
+ border = ClickableSurfaceDefaults.border(
+ border = Border(BorderStroke(0.dp, Color.Transparent), shape = BrowseShapes.Control),
+ focusedBorder = Border(BorderStroke(2.dp, BrowseColors.Focus), shape = BrowseShapes.Control),
+ ),
+ scale = ClickableSurfaceDefaults.scale(focusedScale = 1f),
+ ) { }
+ }
+ }
+ if (query.isNotEmpty()) TvButton(onClick = { onQuery("") }) { Text(stringResource(R.string.epg_clear_search)) }
+ TvButton(onClick = onOpenInclusions) { Text(stringResource(R.string.live_sports_inclusions)) }
+ }
+}
+
+@Composable
+internal fun SportsInclusionsDialog(
+ state: SportsHubUiState,
+ onSport: (SportType, Boolean) -> Unit,
+ onLeague: (String, Boolean) -> Unit,
+ onReset: () -> Unit,
+ onDismiss: () -> Unit,
+) {
+ var leagueQuery by remember { mutableStateOf("") }
+ val leagues = (state.excludedLeagues.associateWith { it } + state.knownLeagues).entries
+ .filter { SportsTextNormalizer.normalize(it.value).contains(SportsTextNormalizer.normalize(leagueQuery)) }
+ .sortedBy { it.value }
+ Dialog(onDismissRequest = onDismiss, properties = DialogProperties(usePlatformDefaultWidth = false)) {
+ Surface(
+ modifier = Modifier.widthIn(max = 880.dp).height(580.dp),
+ colors = SurfaceDefaults.colors(containerColor = BrowseColors.SurfaceElevated),
+ shape = BrowseShapes.Panel,
+ ) {
+ Column(Modifier.fillMaxSize().padding(20.dp), verticalArrangement = Arrangement.spacedBy(12.dp)) {
+ Text(stringResource(R.string.live_sports_inclusions), fontSize = 22.sp, color = BrowseColors.TextPrimary)
+ Text(stringResource(R.string.live_sports_inclusions_hint), fontSize = 12.sp, color = BrowseColors.TextSecondary)
+ Row(Modifier.weight(1f), horizontalArrangement = Arrangement.spacedBy(20.dp)) {
+ Column(Modifier.weight(0.4f), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+ Text(stringResource(R.string.nav_sports), color = BrowseColors.TextPrimary)
+ LazyColumn(verticalArrangement = Arrangement.spacedBy(4.dp), contentPadding = PaddingValues(4.dp)) {
+ items(SportType.entries.filter { it != SportType.UNKNOWN }, key = { it.name }) { sport ->
+ InclusionRow(stringResource(sport.labelResource()), sport.discoveryKey !in state.excludedSports) {
+ onSport(sport, sport.discoveryKey in state.excludedSports)
+ }
+ }
+ }
+ }
+ Column(Modifier.weight(0.6f), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+ Text(stringResource(R.string.live_sports_leagues), color = BrowseColors.TextPrimary)
+ OutlinedTextField(
+ value = leagueQuery, onValueChange = { leagueQuery = it }, singleLine = true,
+ label = { Text(stringResource(R.string.live_sports_search_leagues), color = BrowseColors.TextSecondary) },
+ modifier = Modifier.fillMaxWidth(),
+ colors = sportsSearchColors(),
+ )
+ LazyColumn(verticalArrangement = Arrangement.spacedBy(4.dp), contentPadding = PaddingValues(4.dp)) {
+ items(leagues, key = { it.key }) { league ->
+ InclusionRow(league.value, league.key !in state.excludedLeagues) {
+ onLeague(league.key, league.key in state.excludedLeagues)
+ }
+ }
+ }
+ }
+ }
+ Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {
+ TvButton(onClick = onReset) { Text(stringResource(R.string.hidden_categories_dialog_unhide_all)) }
+ Spacer(Modifier.weight(1f))
+ TvButton(onClick = onDismiss) { Text(stringResource(R.string.hidden_categories_dialog_close)) }
+ }
+ }
+ }
+ }
+}
+
+@Composable
+private fun sportsSearchColors() = OutlinedTextFieldDefaults.colors(
+ focusedTextColor = BrowseColors.TextPrimary,
+ unfocusedTextColor = BrowseColors.TextPrimary,
+ cursorColor = BrowseColors.Brand,
+ focusedBorderColor = BrowseColors.Brand,
+ unfocusedBorderColor = BrowseColors.TextSecondary,
+)
+
+@Composable
+private fun InclusionRow(label: String, included: Boolean, onClick: () -> Unit) {
+ TvClickableSurface(onClick = onClick, modifier = Modifier.fillMaxWidth().semantics(mergeDescendants = true) {
+ toggleableState = if (included) ToggleableState.On else ToggleableState.Off
+ }) {
+ Row(Modifier.padding(horizontal = 8.dp, vertical = 4.dp), verticalAlignment = Alignment.CenterVertically) {
+ Checkbox(included, onCheckedChange = null, colors = CheckboxDefaults.colors(
+ checkedColor = BrowseColors.Brand, uncheckedColor = BrowseColors.TextSecondary,
+ ))
+ Text(label, color = BrowseColors.TextPrimary, modifier = Modifier.padding(start = 6.dp), maxLines = 2)
+ }
+ }
+}
+
+private fun SportType.labelResource(): Int = when (this) {
+ SportType.FOOTBALL -> R.string.live_sports_filter_football
+ SportType.BASKETBALL -> R.string.live_sports_filter_basketball
+ SportType.MOTORSPORT -> R.string.live_sports_filter_motorsport
+ SportType.AMERICAN_FOOTBALL -> R.string.live_sports_american_football
+ SportType.BASEBALL -> R.string.live_sports_baseball
+ SportType.HOCKEY -> R.string.live_sports_hockey
+ SportType.TENNIS -> R.string.live_sports_tennis
+ SportType.MMA -> R.string.live_sports_mma
+ SportType.BOXING -> R.string.live_sports_boxing
+ SportType.CRICKET -> R.string.live_sports_cricket
+ SportType.RUGBY -> R.string.live_sports_rugby
+ SportType.GOLF -> R.string.live_sports_golf
+ SportType.VOLLEYBALL -> R.string.live_sports_volleyball
+ SportType.HANDBALL -> R.string.live_sports_handball
+ SportType.SNOOKER -> R.string.live_sports_snooker
+ SportType.DARTS -> R.string.live_sports_darts
+ SportType.CYCLING -> R.string.live_sports_cycling
+ SportType.OTHER, SportType.UNKNOWN -> R.string.live_sports_filter_other
+}
diff --git a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsDiscoveryPresentation.kt b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsDiscoveryPresentation.kt
new file mode 100644
index 00000000..ea20baa9
--- /dev/null
+++ b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsDiscoveryPresentation.kt
@@ -0,0 +1,47 @@
+package com.streamvault.feature.live.sports
+
+import java.time.Duration
+import java.time.Instant
+
+internal val SportType.discoveryKey: String
+ get() = if (this == SportType.UNKNOWN) SportType.OTHER.name else name
+
+internal fun SportsEvent.matchesDiscovery(state: SportsHubUiState): Boolean {
+ if (sport.discoveryKey in state.excludedSports || leagueFilterKey in state.excludedLeagues) return false
+ if (!matches(state.selectedSportFilter)) return false
+ if (state.selectedLeagueFilter != null && leagueFilterKey != state.selectedLeagueFilter) return false
+ val query = SportsTextNormalizer.normalize(state.searchQuery).split(' ').filter(String::isNotBlank)
+ if (query.isEmpty()) return true
+ val text = SportsTextNormalizer.normalize(buildList {
+ add(title)
+ league?.let(::add)
+ competitors.forEach { add(it.displayName); add(it.canonicalName) }
+ provenance.score?.value?.scores?.forEach { add(it.competitor.name) }
+ provenance.teamMetadata?.value?.forEach { add(it.team.name) }
+ }.joinToString(" "))
+ return query.all(text::contains)
+}
+
+/** Keep recent enrichment when a refresh has only partial data, without keeping old fixtures. */
+internal fun retainSportsPresentation(event: SportsEvent, previous: SportsEvent?, now: Instant): SportsEvent {
+ if (previous == null || previous.id != event.id || previous.sport != event.sport) return event
+ if (Duration.ofMillis(event.startTime - previous.startTime).abs() > Duration.ofHours(2)) return event
+ val identities = event.competitors.map { it.canonicalName }.toSet()
+ if (identities.isEmpty() || identities != previous.competitors.map { it.canonicalName }.toSet()) return event
+ val oldScore = previous.provenance.score?.takeIf { score ->
+ score.updatedAt?.let { !it.isBefore(now.minus(Duration.ofMinutes(10))) } == true
+ }
+ val score = event.provenance.score ?: oldScore?.copy(isStale = true)
+ val status = event.provenance.status ?: previous.provenance.status?.takeIf { oldScore != null }
+ return event.copy(
+ competitors = event.competitors.map { competitor ->
+ competitor.copy(logoUrl = competitor.logoUrl ?: previous.competitors
+ .firstOrNull { it.canonicalName == competitor.canonicalName }?.logoUrl)
+ },
+ provenance = event.provenance.copy(
+ sources = event.provenance.sources + listOfNotNull(score?.source, status?.source),
+ score = score,
+ status = status,
+ ),
+ )
+}
diff --git a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsEvent.kt b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsEvent.kt
index b394f592..dbf43a98 100644
--- a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsEvent.kt
+++ b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsEvent.kt
@@ -68,6 +68,7 @@ internal enum class SportsEventType {
internal data class SportsCompetitor(
val displayName: String,
val canonicalName: String = SportsAliasRegistry.normalizeTeamName(displayName),
+ val logoUrl: String? = null,
)
internal data class SportsClassification(
diff --git a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsHubRepository.kt b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsHubRepository.kt
index 72797643..884c7582 100644
--- a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsHubRepository.kt
+++ b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsHubRepository.kt
@@ -14,6 +14,7 @@ import com.streamvault.domain.repository.ProviderRepository
import com.streamvault.domain.repository.SyncMetadataRepository
import com.streamvault.domain.sports.provider.ProviderEvent
import com.streamvault.domain.sports.provider.ProviderLeague
+import com.streamvault.domain.sports.provider.CUSTOM_SPORTS_PROVIDER_TYPE_ID
import com.streamvault.domain.sports.provider.SourcedValue
import com.streamvault.domain.sports.provider.SportsEventSourcePreference
import com.streamvault.domain.sports.provider.SportsEventSourceSettings
@@ -33,6 +34,7 @@ import java.time.Instant
import java.time.Duration
import java.time.LocalDate
import java.time.ZoneId
+import kotlinx.coroutines.async
import kotlinx.coroutines.CancellationException
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
@@ -58,6 +60,7 @@ import kotlinx.coroutines.flow.shareIn
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeoutOrNull
internal data class SportsHubUiState(
val isLoading: Boolean = true,
@@ -67,6 +70,10 @@ internal data class SportsHubUiState(
val selectedSportFilter: SportsSportFilter = SportsSportFilter.ALL,
val selectedLeagueFilter: String? = null,
val nowMillis: Long = System.currentTimeMillis(),
+ val searchQuery: String = "",
+ val excludedSports: Set<String> = emptySet(),
+ val excludedLeagues: Set<String> = emptySet(),
+ val knownLeagues: Map<String, String> = emptyMap(),
)
internal fun shouldRefreshSportsOnClock(
@@ -90,6 +97,7 @@ internal class SportsHubRepository @Inject constructor(
private val sportsProviderScoreSourceRouter: SportsProviderScoreSourceRouter,
private val sportsProviderStandingsRouter: SportsProviderStandingsRouter,
private val sportsProviderMetadataRouter: SportsProviderMetadataRouter,
+ private val sportsProviderExtraDetailsRouter: SportsProviderExtraDetailsRouter,
private val sportsEventSourceSettings: SportsEventSourceSettings,
private val sportsScoreSourceSettings: SportsScoreSourceSettings,
private val sportsStandingsSourceSettings: SportsStandingsSourceSettings,
@@ -113,8 +121,18 @@ internal class SportsHubRepository @Inject constructor(
private val initialLoadStartedAt = SystemClock.elapsedRealtime()
private var initialContentLogged = false
private var lastPublishedAtMillis = 0L
+ private var loadInProgress = false
+ private var progressiveLoad = true
init {
+ scope.launch {
+ combine(preferencesRepository.getExcludedSports(), preferencesRepository.getExcludedSportsLeagues()) { sports, leagues ->
+ sports to leagues
+ }.collect { (sports, leagues) ->
+ _uiState.update { it.copy(excludedSports = sports, excludedLeagues = leagues,
+ selectedLeagueFilter = it.selectedLeagueFilter?.takeUnless { league -> league in leagues }) }
+ }
+ }
val activeSource = combine(
combinedM3uRepository.getActiveLiveSource(),
providerRepository.getActiveProvider(),
@@ -208,8 +226,9 @@ internal class SportsHubRepository @Inject constructor(
val sourcePreferences = combine(
sportsEventSourceSettings.eventSourcePreference,
sportsScoreSourceSettings.scoreSourcePreference,
- ) { eventSourcePreference, scoreSourcePreference ->
- eventSourcePreference to scoreSourcePreference
+ sportsProviderStore.configurationChanges,
+ ) { eventSourcePreference, scoreSourcePreference, revision ->
+ Triple(eventSourcePreference, scoreSourcePreference, revision)
}
val loadSettings = combine(
selectedTimeRange,
@@ -224,6 +243,7 @@ internal class SportsHubRepository @Inject constructor(
sourceSelection.first,
sourceSelection.second,
metadataSourcePreference,
+ sourceSelection.third,
)
}
val loadRequests = combine(channelSnapshots, guideRevision, loadSettings) { channels, revision, settings ->
@@ -234,6 +254,7 @@ internal class SportsHubRepository @Inject constructor(
settings.eventSourcePreference,
settings.scoreSourcePreference,
settings.metadataSourcePreference,
+ settings.providerRevision,
) to settings.range
}
scope.launch {
@@ -270,7 +291,7 @@ internal class SportsHubRepository @Inject constructor(
com.streamvault.domain.sports.provider.ProviderGameState.LIVE ||
event.broadcastStatusAt(now) == SportsBroadcastStatus.ON_AIR
}
- if (_uiState.subscriptionCount.value > 0 &&
+ if (_uiState.subscriptionCount.value > 0 && !loadInProgress &&
shouldRefreshSportsOnClock(range, hasLiveEvents, lastRequestedLocalDate != today)
) {
refreshRequest.update { it + 1 }
@@ -326,8 +347,22 @@ internal class SportsHubRepository @Inject constructor(
_uiState.update { it.copy(selectedLeagueFilter = league) }
}
+ fun setSearchQuery(query: String) { _uiState.update { it.copy(searchQuery = query) } }
+
+ fun setSportIncluded(sport: SportType, included: Boolean) {
+ scope.launch { preferencesRepository.setSportsSportIncluded(sport.discoveryKey, included) }
+ }
+
+ fun setLeagueIncluded(league: String, included: Boolean) {
+ scope.launch { preferencesRepository.setSportsLeagueIncluded(league, included) }
+ }
+
+ fun resetInclusions() { scope.launch { preferencesRepository.resetSportsInclusions() } }
+
private suspend fun loadEvents(inputs: SportsLoadInputs, range: SportsTimeRange, now: Long) {
val loadStartedAt = SystemClock.elapsedRealtime()
+ loadInProgress = true
+ progressiveLoad = _uiState.value.events.isEmpty() || _uiState.value.isLoading
val providerChannels = inputs.providers
val window = windowFor(range, now)
lastRequestedLocalDate = localDate(now)
@@ -356,11 +391,31 @@ internal class SportsHubRepository @Inject constructor(
cached.events to cached.providerEvents
} ?: withContext(Dispatchers.Default) {
val (requestFromMillis, requestUntilMillis) = providerEventRequestWindow(range, now, window)
- val providerEventLoad = sportsProviderEventSourceRouter.load(
- eventProviders,
- Instant.ofEpochMilli(requestFromMillis),
- Instant.ofEpochMilli(requestUntilMillis),
- )
+ availableChannelEntries = providerChannels.flatMap { provider ->
+ provider.channels.map { SportsChannelIndexEntry(it, provider.combinedProfileId) }
+ }
+ val providerTask = async {
+ withTimeoutOrNull(PROVIDER_LOAD_TIMEOUT_MS) {
+ sportsProviderEventSourceRouter.load(
+ eventProviders, Instant.ofEpochMilli(requestFromMillis), Instant.ofEpochMilli(requestUntilMillis),
+ )
+ } ?: LoadedSportsProviderEvents()
+ }
+ // A week of guide data can be large. Show API events while that local scan
+ // continues; the final resolver will join them to actual guide broadcasts.
+ val provisionalPublisher = launch {
+ val early = providerTask.await()
+ if (early.events.isNotEmpty()) {
+ val resolved = sportsProviderEventResolver.resolve(
+ epgEvents = emptyList(), providerEvents = sourcedEvents(early),
+ selection = SportsEventSourceSelection(eventInstanceId = early.instanceId),
+ now = Instant.ofEpochMilli(now),
+ )
+ withContext(Dispatchers.Main.immediate) {
+ publishEvents(resolved.mapNotNull { it.toSportsHubEvent() }, range, now, window)
+ }
+ }
+ }
val providerData = buildList {
providerChannels.forEach { provider ->
add(loadProviderCandidates(provider, range, now, window))
@@ -377,27 +432,19 @@ internal class SportsHubRepository @Inject constructor(
)
val entries = providerData.flatMap { it.channels }
availableChannelEntries = entries
+ // The guide is usable immediately, even when a remote API is slow.
+ if (!providerTask.isCompleted && (assembled.isNotEmpty() || eventProviders.isEmpty())) {
+ withContext(Dispatchers.Main.immediate) { publishEvents(assembled, range, now, window) }
+ }
+ val providerEventLoad = providerTask.await()
+ provisionalPublisher.join()
// Most guide-derived events already have playable broadcasts. Build the
// full text index only when fallback matching or manual search needs it.
val channelIndex by lazy { getFallbackChannelIndex(entries) }
- val sourcedProviderEvents = if (providerEventLoad.instanceId == null || providerEventLoad.typeId == null) {
- emptyList()
- } else {
- providerEventLoad.events.map { event ->
- SourcedValue(
- value = event,
- source = SportsSourceRef.Provider(
- instanceId = providerEventLoad.instanceId,
- typeId = providerEventLoad.typeId,
- externalEventId = event.providerEventId,
- ),
- )
- }
- }
+ val sourcedProviderEvents = sourcedEvents(providerEventLoad)
val selectedProviderId = providerEventLoad.instanceId
val providerResolutionStartedAt = SystemClock.elapsedRealtime()
- val providerResolved = sportsProviderEventSourceRouter.enrichBroadcasters(
- sportsProviderEventResolver.resolve(
+ val catalogResolved = sportsProviderEventResolver.resolve(
epgEvents = assembled,
providerEvents = sourcedProviderEvents,
selection = SportsEventSourceSelection(
@@ -405,10 +452,15 @@ internal class SportsHubRepository @Inject constructor(
metadataInstanceId = selectedProviderId,
),
now = Instant.ofEpochMilli(now),
- ),
- configuredProviders,
- Instant.ofEpochMilli(now),
)
+ withContext(Dispatchers.Main.immediate) {
+ publishEvents(catalogResolved.mapNotNull { it.toSportsHubEvent() }, range, now, window)
+ }
+ val providerResolved = withTimeoutOrNull(ENRICHMENT_TIMEOUT_MS) {
+ sportsProviderEventSourceRouter.enrichBroadcasters(
+ catalogResolved, configuredProviders, Instant.ofEpochMilli(now),
+ )
+ } ?: catalogResolved
SportsDiagnostics.performance(
stage = "provider-event-resolution",
elapsedMillis = SystemClock.elapsedRealtime() - providerResolutionStartedAt,
@@ -416,7 +468,10 @@ internal class SportsHubRepository @Inject constructor(
groupCount = sourcedProviderEvents.size,
)
val resolved = providerResolved.mapNotNull { resolved ->
- resolved.toSportsHubEvent()?.let { event ->
+ currentCoroutineContext().ensureActive()
+ resolved.toSportsHubEvent()?.takeIf { event ->
+ programMatchesRange(event.startTime, event.endTime, range, now, window)
+ }?.let { event ->
val resolvedEvent = if (event.broadcasts.none { it.channel.streamUrl.isNotBlank() }) {
SportsEventFallbackResolver.addFallbacksWhenDirectChoicesAreUnavailable(event, channelIndex)
} else {
@@ -430,6 +485,7 @@ internal class SportsHubRepository @Inject constructor(
if (cacheKey != null) cacheEvents(cacheKey, resolved, providerEventLoad)
resolved to providerEventLoad
}
+ publishEvents(baseEvents, range, now, window)
val selectedEventProviderInstanceId = reusableProviderEvents.instanceId
val scoreProviders = sportsProviderScoreSourceRouter.eligibleProviders(
configuredProviders,
@@ -438,13 +494,13 @@ internal class SportsHubRepository @Inject constructor(
)
val (requestFromMillis, requestUntilMillis) = providerEventRequestWindow(range, now, window)
val scoreLoad = withContext(Dispatchers.Default) {
- sportsProviderScoreSourceRouter.load(
+ withTimeoutOrNull(ENRICHMENT_TIMEOUT_MS) { sportsProviderScoreSourceRouter.load(
providers = scoreProviders,
reusableEventLoad = reusableProviderEvents,
from = Instant.ofEpochMilli(requestFromMillis),
until = Instant.ofEpochMilli(requestUntilMillis),
now = Instant.ofEpochMilli(now),
- )
+ ) } ?: LoadedSportsProviderScores()
}
val sourcedScoreEvents = if (scoreLoad.instanceId == null || scoreLoad.typeId == null) {
emptyList()
@@ -456,6 +512,8 @@ internal class SportsHubRepository @Inject constructor(
instanceId = scoreLoad.instanceId,
typeId = scoreLoad.typeId,
externalEventId = event.providerEventId,
+ sport = event.sport.takeIf { scoreLoad.typeId == CUSTOM_SPORTS_PROVIDER_TYPE_ID },
+ leagueId = event.league?.id.takeIf { scoreLoad.typeId == CUSTOM_SPORTS_PROVIDER_TYPE_ID },
),
)
}
@@ -485,14 +543,15 @@ internal class SportsHubRepository @Inject constructor(
events = scoreLoad.events,
),
)
+ publishEvents(resolvedEvents, range, now, window)
val metadata = withContext(Dispatchers.Default) {
- sportsProviderMetadataRouter.load(
+ withTimeoutOrNull(ENRICHMENT_TIMEOUT_MS) { sportsProviderMetadataRouter.load(
configs = configuredProviders,
preference = inputs.metadataSourcePreference,
eventCatalogs = eventCatalogs,
eventProviderInstanceId = reusableProviderEvents.instanceId,
now = Instant.ofEpochMilli(now),
- )
+ ) } ?: LoadedSportsProviderMetadata()
}
val events = sportsProviderMetadataRouter.enrichEvents(resolvedEvents, metadata).map { event ->
event.copy(providerAttributions = sportsProviderEventSourceRouter.attributions(event.provenance))
@@ -502,47 +561,77 @@ internal class SportsHubRepository @Inject constructor(
elapsedMillis = SystemClock.elapsedRealtime() - loadStartedAt,
itemCount = events.size,
)
- val currentEvents = events.filter { event ->
- programMatchesRange(event.startTime, event.endTime, range, now, window)
- }
- val rememberedPicks = preferencesRepository.getSportsEventChannelPicks(
- eventIds = currentEvents.mapTo(mutableSetOf(), SportsEvent::id),
- nowMillis = now,
- )
- val availableChannels = availableChannelEntries
- val presentedEvents = currentEvents.map { event ->
- SportsEventChannelPreferencePolicy.apply(
- event = event,
- pick = rememberedPicks[event.id],
- availableChannels = availableChannels,
- nowMillis = now,
- )
- }
- val currentState = _uiState.value
- val selectedLeague = currentState.selectedLeagueFilter?.takeIf { league ->
- presentedEvents.any { event -> event.leagueFilterKey == league && event.matches(currentState.selectedSportFilter) }
- }
- _uiState.value = SportsHubUiState(
- isLoading = false,
- events = presentedEvents,
- selectedTimeRange = range,
- selectedSportFilter = currentState.selectedSportFilter,
- selectedLeagueFilter = selectedLeague,
- nowMillis = now,
- )
- lastPublishedAtMillis = System.currentTimeMillis()
- if (!initialContentLogged) {
- SportsDiagnostics.performance(
- stage = "initial-content",
- elapsedMillis = SystemClock.elapsedRealtime() - initialLoadStartedAt,
- itemCount = presentedEvents.size,
- )
- initialContentLogged = true
- }
+ publishEvents(events, range, now, window, complete = true)
} catch (cancelled: CancellationException) {
throw cancelled
} catch (_: Exception) {
_uiState.update { it.copy(isLoading = false, hasError = true) }
+ } finally {
+ loadInProgress = false
+ }
+ }
+
+ private fun sourcedEvents(loaded: LoadedSportsProviderEvents): List<SourcedValue<ProviderEvent>> {
+ val instanceId = loaded.instanceId ?: return emptyList()
+ val typeId = loaded.typeId ?: return emptyList()
+ return loaded.events.map { event ->
+ SourcedValue(event, SportsSourceRef.Provider(
+ instanceId, typeId, event.providerEventId,
+ sport = event.sport.takeIf { typeId == CUSTOM_SPORTS_PROVIDER_TYPE_ID },
+ leagueId = event.league?.id.takeIf { typeId == CUSTOM_SPORTS_PROVIDER_TYPE_ID },
+ ))
+ }
+ }
+
+ private suspend fun publishEvents(
+ events: List<SportsEvent>,
+ range: SportsTimeRange,
+ now: Long,
+ window: SportsTimeWindow,
+ complete: Boolean = false,
+ ) {
+ if (!complete && !progressiveLoad) return
+ val previous = _uiState.value.events.associateBy(SportsEvent::id)
+ val currentEvents = events.filter { event ->
+ programMatchesRange(event.startTime, event.endTime, range, now, window)
+ }
+ val rememberedPicks = preferencesRepository.getSportsEventChannelPicks(
+ eventIds = currentEvents.mapTo(mutableSetOf(), SportsEvent::id),
+ nowMillis = now,
+ )
+ val availableChannels = availableChannelEntries
+ val presentedEvents = currentEvents.map { event ->
+ val retained = retainSportsPresentation(event, previous[event.id], Instant.ofEpochMilli(now))
+ SportsEventChannelPreferencePolicy.apply(
+ event = retained,
+ pick = rememberedPicks[event.id],
+ availableChannels = availableChannels,
+ nowMillis = now,
+ ).copy(providerAttributions = sportsProviderEventSourceRouter.attributions(retained.provenance))
+ }
+ val currentState = _uiState.value
+ val selectedLeague = currentState.selectedLeagueFilter?.takeIf { league ->
+ presentedEvents.any { event -> event.leagueFilterKey == league && event.matches(currentState.selectedSportFilter) }
+ }
+ _uiState.value = currentState.copy(
+ isLoading = false,
+ events = presentedEvents,
+ selectedTimeRange = range,
+ selectedSportFilter = currentState.selectedSportFilter,
+ selectedLeagueFilter = selectedLeague,
+ nowMillis = now,
+ knownLeagues = currentState.knownLeagues + presentedEvents.mapNotNull { event ->
+ event.leagueFilterKey?.let { it to (event.league ?: event.leagueInfo?.displayName ?: it) }
+ }.toMap(),
+ )
+ lastPublishedAtMillis = System.currentTimeMillis()
+ if (!initialContentLogged) {
+ SportsDiagnostics.performance(
+ stage = "initial-content",
+ elapsedMillis = SystemClock.elapsedRealtime() - initialLoadStartedAt,
+ itemCount = presentedEvents.size,
+ )
+ initialContentLogged = true
}
}
@@ -581,6 +670,10 @@ internal class SportsHubRepository @Inject constructor(
}
}
+ suspend fun loadExtraDetails(event: SportsEvent): LoadedSportsEventExtraDetails? = withContext(Dispatchers.IO) {
+ sportsProviderExtraDetailsRouter.load(event)
+ }
+
private fun SportsResolvedEvent.toSportsHubEvent(): SportsEvent? {
val local = epgEvent
if (local != null) {
@@ -592,6 +685,12 @@ internal class SportsHubRepository @Inject constructor(
SportsLeagueRegistry.detectNormalized(SportsTextNormalizer.normalize(league))
},
provenance = provenance,
+ competitors = local.competitors.map { competitor ->
+ val providerCompetitor = providerEvent?.value?.competitors?.firstOrNull {
+ SportsAliasRegistry.normalizeTeamName(it.name) == competitor.canonicalName
+ }
+ competitor.copy(logoUrl = providerCompetitor?.logoUrl ?: competitor.logoUrl)
+ },
)
}
@@ -616,13 +715,15 @@ internal class SportsHubRepository @Inject constructor(
league = league,
categoryLabel = null,
description = "",
- sport = providerEvent.sport.toSportType(),
+ sport = SportsProgrammeClassifier.sportForProvider(
+ providerEvent.sport ?: providerEvent.league?.sport, league,
+ ).takeUnless { it == SportType.UNKNOWN } ?: SportType.OTHER,
startTime = startTime,
endTime = safeEndTime,
broadcasts = emptyList(),
confidence = 0.85f,
competitors = providerEvent.competitors.map { competitor ->
- SportsCompetitor(competitor.name)
+ SportsCompetitor(competitor.name, logoUrl = competitor.logoUrl)
},
session = providerEvent.session,
eventType = providerEvent.status?.state.toSportsEventType(),
@@ -632,27 +733,6 @@ internal class SportsHubRepository @Inject constructor(
)
}
- private fun String?.toSportType(): SportType = when (SportsTextNormalizer.normalize(this.orEmpty())) {
- "football", "soccer" -> SportType.FOOTBALL
- "basketball" -> SportType.BASKETBALL
- "american football" -> SportType.AMERICAN_FOOTBALL
- "baseball" -> SportType.BASEBALL
- "hockey", "ice hockey" -> SportType.HOCKEY
- "tennis" -> SportType.TENNIS
- "motorsport", "motor sport", "racing" -> SportType.MOTORSPORT
- "mma", "mixed martial arts" -> SportType.MMA
- "boxing" -> SportType.BOXING
- "cricket" -> SportType.CRICKET
- "rugby", "rugby union", "rugby league" -> SportType.RUGBY
- "golf" -> SportType.GOLF
- "volleyball" -> SportType.VOLLEYBALL
- "handball" -> SportType.HANDBALL
- "snooker" -> SportType.SNOOKER
- "darts" -> SportType.DARTS
- "cycling" -> SportType.CYCLING
- else -> SportType.OTHER
- }
-
private fun com.streamvault.domain.sports.provider.ProviderGameState?.toSportsEventType(): SportsEventType = when (this) {
com.streamvault.domain.sports.provider.ProviderGameState.LIVE -> SportsEventType.LIVE_EVENT
com.streamvault.domain.sports.provider.ProviderGameState.SCHEDULED,
@@ -946,6 +1026,7 @@ internal class SportsHubRepository @Inject constructor(
val eventSourcePreference: SportsEventSourcePreference,
val scoreSourcePreference: SportsScoreSourcePreference,
val metadataSourcePreference: SportsMetadataSourcePreference,
+ val providerRevision: Long,
)
private data class SportsLoadSettings(
@@ -954,6 +1035,7 @@ internal class SportsHubRepository @Inject constructor(
val eventSourcePreference: SportsEventSourcePreference,
val scoreSourcePreference: SportsScoreSourcePreference,
val metadataSourcePreference: SportsMetadataSourcePreference,
+ val providerRevision: Long,
)
private data class LoadedSportsProvider(
@@ -1023,6 +1105,8 @@ internal class SportsHubRepository @Inject constructor(
)
private companion object {
+ const val PROVIDER_LOAD_TIMEOUT_MS = 25_000L
+ const val ENRICHMENT_TIMEOUT_MS = 5_000L
const val EVENT_INDEX_CACHE_TTL_MS = 5 * 60_000L
const val MAX_EVENT_INDEX_ENTRIES = 8
const val PROVIDER_EVENT_LOOKBACK_MS = 18 * 60 * 60_000L
diff --git a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsHubScreen.kt b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsHubScreen.kt
index 1feaad26..0c84acf0 100644
--- a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsHubScreen.kt
+++ b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsHubScreen.kt
@@ -70,7 +70,6 @@ import androidx.tv.material3.Icon
import androidx.tv.material3.MaterialTheme
import androidx.tv.material3.Surface
import androidx.tv.material3.SurfaceDefaults
-import com.streamvault.domain.sports.provider.ProviderCompetitorRole
import com.streamvault.domain.sports.provider.ProviderGameState
import com.streamvault.domain.sports.provider.ProviderAttributionFormat
import androidx.tv.material3.Text
@@ -104,6 +103,10 @@ fun SportsHubScreen(
SportsHubContent(
state = state,
onRetry = viewModel::retry,
+ onSearchQueryChanged = viewModel::setSearchQuery,
+ onSetSportIncluded = viewModel::setSportIncluded,
+ onSetLeagueIncluded = viewModel::setLeagueIncluded,
+ onResetInclusions = viewModel::resetInclusions,
onSelectTimeRange = viewModel::selectTimeRange,
onSelectSportFilter = viewModel::selectSportFilter,
onSelectLeagueFilter = viewModel::selectLeagueFilter,
@@ -111,6 +114,7 @@ fun SportsHubScreen(
onRememberChannelForEvent = viewModel::rememberChannelForEvent,
onForgetChannelForEvent = viewModel::forgetChannelForEvent,
onLoadStandings = viewModel::loadStandings,
+ onLoadExtraDetails = viewModel::loadExtraDetails,
onPlayBroadcast = { broadcast ->
onPlaybackRequested(
LiveChannelPlaybackRequest(
@@ -133,6 +137,10 @@ fun SportsHubScreen(
private fun SportsHubContent(
state: SportsHubUiState,
onRetry: () -> Unit,
+ onSearchQueryChanged: (String) -> Unit,
+ onSetSportIncluded: (SportType, Boolean) -> Unit,
+ onSetLeagueIncluded: (String, Boolean) -> Unit,
+ onResetInclusions: () -> Unit,
onSelectTimeRange: (SportsTimeRange) -> Unit,
onSelectSportFilter: (SportsSportFilter) -> Unit,
onSelectLeagueFilter: (String?) -> Unit,
@@ -140,18 +148,18 @@ private fun SportsHubContent(
onRememberChannelForEvent: suspend (SportsEvent, SportsBroadcast) -> Boolean,
onForgetChannelForEvent: suspend (SportsEvent) -> Unit,
onLoadStandings: suspend (SportsEvent) -> LoadedSportsStandings?,
+ onLoadExtraDetails: suspend (SportsEvent) -> LoadedSportsEventExtraDetails?,
onPlayBroadcast: (SportsBroadcast) -> Unit,
) {
var detailsEvent by remember { mutableStateOf<SportsEvent?>(null) }
var manualPickerEvent by remember { mutableStateOf<SportsEvent?>(null) }
val actionScope = rememberCoroutineScope()
- val visibleEvents = state.events.filter { event ->
- event.matches(state.selectedSportFilter) &&
- (state.selectedLeagueFilter == null || event.leagueFilterKey == state.selectedLeagueFilter)
- }
+ var inclusionsOpen by remember { mutableStateOf(false) }
+ val visibleEvents = state.events.filter { it.matchesDiscovery(state) }
val eflChampionshipLabel = stringResource(R.string.live_sports_league_efl_championship)
val availableLeagues = state.events.asSequence()
- .filter { it.matches(state.selectedSportFilter) }
+ .filter { it.matches(state.selectedSportFilter) && it.sport.discoveryKey !in state.excludedSports &&
+ it.leagueFilterKey !in state.excludedLeagues }
.mapNotNull { event -> event.leagueFilterKey?.let { key ->
SportsLeagueFilterOption(key, event.localizedLeagueName(eflChampionshipLabel).orEmpty())
} }
@@ -179,6 +187,7 @@ private fun SportsHubContent(
}
item(key = "sports-filters") {
Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
+ SportsDiscoverySearch(state.searchQuery, onSearchQueryChanged, onOpenInclusions = { inclusionsOpen = true })
SportsSportFilters(state.selectedSportFilter, onSelectSportFilter)
if (availableLeagues.isNotEmpty()) {
SportsLeagueFilters(availableLeagues, state.selectedLeagueFilter, onSelectLeagueFilter)
@@ -238,11 +247,16 @@ private fun SportsHubContent(
}
}
}
- detailsEvent?.let { event ->
+ if (inclusionsOpen) {
+ SportsInclusionsDialog(state, onSetSportIncluded, onSetLeagueIncluded, onResetInclusions) { inclusionsOpen = false }
+ }
+ detailsEvent?.let { selected ->
+ val event = state.events.firstOrNull { it.id == selected.id } ?: selected
SportsEventDetailsDialog(
event = event,
nowMillis = state.nowMillis,
onLoadStandings = onLoadStandings,
+ onLoadExtraDetails = onLoadExtraDetails,
onDismiss = { detailsEvent = null },
onFindAnotherChannel = {
detailsEvent = null
@@ -397,7 +411,7 @@ private fun FeaturedSportsEvent(
onPlayBroadcast: (SportsBroadcast) -> Unit,
) {
Row(
- modifier = Modifier.fillMaxWidth().height(140.dp + 18.dp * event.attributionCredits.sumOf { it.lineCount })
+ modifier = Modifier.fillMaxWidth().height(180.dp + 18.dp * event.attributionCredits.sumOf { it.lineCount })
.clip(RoundedCornerShape(12.dp))
.background(Brush.horizontalGradient(listOf(BrowseColors.SurfaceEmphasis, BrowseColors.Surface)))
.border(1.dp, BrowseColors.Outline, RoundedCornerShape(12.dp))
@@ -532,36 +546,31 @@ private fun SportsEvent.localizedLeagueName(eflChampionshipLabel: String): Strin
if (leagueInfo?.id == "efl-championship") eflChampionshipLabel
else league ?: leagueInfo?.displayName
-private fun SportsEvent.scoreFor(competitor: SportsCompetitor, index: Int): String? {
+internal fun SportsEvent.scoreFor(competitor: SportsCompetitor): String? {
val scores = provenance.score?.value?.scores.orEmpty()
- val expectedRole = when (index) {
- 0 -> ProviderCompetitorRole.HOME
- 1 -> ProviderCompetitorRole.AWAY
- else -> ProviderCompetitorRole.PARTICIPANT
- }
- return scores.firstOrNull { it.competitor.role == expectedRole }
- ?.value?.takeIf(String::isNotBlank)
- ?: scores.firstOrNull {
- SportsAliasRegistry.normalizeTeamName(it.competitor.name) == competitor.canonicalName
- }?.value?.takeIf(String::isNotBlank)
+ return scores.firstOrNull {
+ SportsAliasRegistry.normalizeTeamName(it.competitor.name) == competitor.canonicalName
+ }?.value?.takeIf(String::isNotBlank)
}
@Composable
private fun SportsFixture(event: SportsEvent, featured: Boolean, modifier: Modifier = Modifier) {
Column(modifier, verticalArrangement = Arrangement.spacedBy(if (featured) 8.dp else 6.dp)) {
if (event.competitors.size == 2) {
- event.competitors.forEachIndexed { index, competitor ->
+ event.competitors.forEach { competitor ->
Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
- Box(Modifier.size(if (featured) 28.dp else 22.dp).clip(CircleShape)
- .background(BrowseColors.Brand.copy(alpha = 0.14f)), contentAlignment = Alignment.Center) {
- Text(competitor.displayName.firstOrNull(Char::isLetterOrDigit)?.toString().orEmpty(), fontSize = if (featured) 14.sp else 11.sp,
- color = BrowseColors.BrandStrong, fontWeight = FontWeight.Bold)
- }
+ ChannelLogoBadge(
+ channelName = competitor.displayName,
+ logoUrl = competitor.logoUrl,
+ modifier = Modifier.size(if (featured) 32.dp else 26.dp),
+ shape = CircleShape,
+ backgroundColor = BrowseColors.Brand.copy(alpha = 0.14f),
+ )
Text(competitor.displayName, fontSize = if (featured) 18.sp else 14.sp,
modifier = Modifier.weight(1f),
fontWeight = FontWeight.SemiBold, color = BrowseColors.TextPrimary,
maxLines = 1, overflow = TextOverflow.Ellipsis)
- event.scoreFor(competitor, index)?.let { score ->
+ event.scoreFor(competitor)?.let { score ->
Text(
score,
fontSize = if (featured) 18.sp else 14.sp,
@@ -597,7 +606,7 @@ private fun SportsEventCard(
) {
TvClickableSurface(
onClick = { onShowDetails(event) },
- modifier = Modifier.width(244.dp).height(140.dp + 18.dp * event.attributionCredits.sumOf { it.lineCount }),
+ modifier = Modifier.width(244.dp).height(172.dp + 18.dp * event.attributionCredits.sumOf { it.lineCount }),
shape = ClickableSurfaceDefaults.shape(RoundedCornerShape(10.dp)),
scale = ClickableSurfaceDefaults.scale(focusedScale = 1.02f),
) {
@@ -658,6 +667,7 @@ private fun SportsEventDetailsDialog(
onForgetChoice: () -> Unit,
onPlayBroadcast: (SportsBroadcast) -> Unit,
onLoadStandings: suspend (SportsEvent) -> LoadedSportsStandings?,
+ onLoadExtraDetails: suspend (SportsEvent) -> LoadedSportsEventExtraDetails?,
) {
val firstChannelFocusRequester = remember(event.id) { FocusRequester() }
val displayBroadcasts = event.broadcastsForPresentation()
@@ -665,6 +675,9 @@ private fun SportsEventDetailsDialog(
var standings by remember(event.id) { mutableStateOf<LoadedSportsStandings?>(null) }
var standingsLoading by remember(event.id) { mutableStateOf(false) }
var standingsRequested by remember(event.id) { mutableStateOf(false) }
+ var extraDetails by remember(event.id) { mutableStateOf<LoadedSportsEventExtraDetails?>(null) }
+ var extraDetailsLoading by remember(event.id) { mutableStateOf(false) }
+ var extraDetailsRequested by remember(event.id) { mutableStateOf(false) }
LaunchedEffect(event.id) {
if (displayBroadcasts.isNotEmpty()) firstChannelFocusRequester.requestFocus()
}
@@ -756,6 +769,47 @@ private fun SportsEventDetailsDialog(
)
standings != null -> SportsStandingsContent(checkNotNull(standings))
}
+ if (event.provenance.sources.any { it is com.streamvault.domain.sports.provider.SportsSourceRef.Provider }) {
+ Row(
+ modifier = Modifier.fillMaxWidth(),
+ verticalAlignment = Alignment.CenterVertically,
+ horizontalArrangement = Arrangement.spacedBy(8.dp),
+ ) {
+ Text(
+ stringResource(R.string.live_sports_extra_details),
+ fontSize = 14.sp,
+ fontWeight = FontWeight.SemiBold,
+ color = BrowseColors.TextPrimary,
+ )
+ Spacer(Modifier.weight(1f))
+ TvButton(
+ onClick = {
+ if (!extraDetailsLoading) standingsScope.launch {
+ extraDetailsRequested = true
+ extraDetailsLoading = true
+ extraDetails = onLoadExtraDetails(event)
+ extraDetailsLoading = false
+ }
+ },
+ modifier = Modifier.height(32.dp),
+ ) {
+ Text(stringResource(R.string.live_sports_extra_details_load), fontSize = 11.sp)
+ }
+ }
+ when {
+ extraDetailsLoading -> Text(
+ stringResource(R.string.live_sports_extra_details_loading),
+ fontSize = 11.sp,
+ color = BrowseColors.TextSecondary,
+ )
+ extraDetailsRequested && extraDetails == null -> Text(
+ stringResource(R.string.live_sports_extra_details_unavailable),
+ fontSize = 11.sp,
+ color = BrowseColors.TextSecondary,
+ )
+ extraDetails != null -> SportsExtraDetailsContent(checkNotNull(extraDetails))
+ }
+ }
displayBroadcasts.forEachIndexed { index, broadcast ->
SportsChannelButton(channel = broadcast.channel, compact = true,
modifier = Modifier.fillMaxWidth().then(
@@ -782,6 +836,77 @@ private fun SportsEventDetailsDialog(
}
}
+@Composable
+private fun SportsExtraDetailsContent(details: LoadedSportsEventExtraDetails) {
+ val teamArtwork = details.teamArtwork.distinctBy(LoadedSportsTeamArtwork::teamName)
+ if (teamArtwork.isNotEmpty()) {
+ Row(horizontalArrangement = Arrangement.spacedBy(10.dp)) {
+ teamArtwork.forEach { item ->
+ ChannelLogoBadge(
+ channelName = item.teamName,
+ logoUrl = item.artwork.uri.toString(),
+ modifier = Modifier.size(46.dp),
+ shape = CircleShape,
+ )
+ }
+ }
+ }
+ details.statistics?.let { result ->
+ if (result.statistics.isNotEmpty()) {
+ Text(
+ stringResource(R.string.live_sports_statistics),
+ fontSize = 12.sp,
+ fontWeight = FontWeight.SemiBold,
+ color = BrowseColors.TextPrimary,
+ )
+ result.statistics.forEach { statistic ->
+ val label = statistic.label?.takeIf(String::isNotBlank) ?: statistic.key
+ val value = statistic.value?.takeIf(String::isNotBlank) ?: return@forEach
+ val teamName = statistic.competitor?.name?.takeIf(String::isNotBlank)
+ Text(
+ listOfNotNull(teamName, label, value).joinToString(" · "),
+ fontSize = 11.sp,
+ color = BrowseColors.TextSecondary,
+ )
+ }
+ }
+ }
+ details.lineups.forEach { lineup ->
+ if (lineup.members.isNotEmpty()) {
+ Text(
+ lineup.team?.name?.takeIf(String::isNotBlank)
+ ?: stringResource(R.string.live_sports_lineups),
+ fontSize = 12.sp,
+ fontWeight = FontWeight.SemiBold,
+ color = BrowseColors.TextPrimary,
+ )
+ lineup.members.forEach { member ->
+ val detailsText = listOfNotNull(
+ member.position?.takeIf(String::isNotBlank),
+ member.shirtNumber?.takeIf(String::isNotBlank)?.let { "#$it" },
+ if (member.starter == true) stringResource(R.string.live_sports_lineup_starter) else null,
+ ).joinToString(" · ")
+ Text(
+ listOfNotNull(member.competitor.name, detailsText.takeIf(String::isNotBlank))
+ .joinToString(" · "),
+ fontSize = 11.sp,
+ color = BrowseColors.TextSecondary,
+ )
+ }
+ }
+ }
+ val attribution = details.attribution
+ SportsAttributionLine(
+ SportsAttributionCredit(
+ sourceName = attribution?.sourceName ?: details.providerName,
+ format = attribution?.format ?: ProviderAttributionFormat.SOURCE_NAME,
+ sourceUrl = attribution?.sourceUrl,
+ licenseUrl = attribution?.licenseUrl,
+ ),
+ color = BrowseColors.TextSecondary,
+ )
+}
+
@Composable
private fun SportsStandingsContent(loaded: LoadedSportsStandings) {
val standings = loaded.standings
diff --git a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsHubViewModel.kt b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsHubViewModel.kt
index ae540859..ae63fc81 100644
--- a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsHubViewModel.kt
+++ b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsHubViewModel.kt
@@ -14,6 +14,10 @@ internal class SportsHubViewModel @Inject constructor(
val uiState = repository.uiState
+ fun setSearchQuery(query: String) = repository.setSearchQuery(query)
+ fun setSportIncluded(sport: SportType, included: Boolean) = repository.setSportIncluded(sport, included)
+ fun setLeagueIncluded(league: String, included: Boolean) = repository.setLeagueIncluded(league, included)
+ fun resetInclusions() = repository.resetInclusions()
fun retry() = repository.retry()
fun selectTimeRange(range: SportsTimeRange) = repository.selectTimeRange(range)
fun selectSportFilter(filter: SportsSportFilter) = repository.selectSportFilter(filter)
@@ -23,4 +27,5 @@ internal class SportsHubViewModel @Inject constructor(
repository.rememberChannelForEvent(event, broadcast)
suspend fun forgetChannelForEvent(event: SportsEvent) = repository.forgetChannelForEvent(event)
suspend fun loadStandings(event: SportsEvent) = repository.loadStandings(event)
+ suspend fun loadExtraDetails(event: SportsEvent) = repository.loadExtraDetails(event)
}
diff --git a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProgrammeClassifier.kt b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProgrammeClassifier.kt
index b2e2280e..65634485 100644
--- a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProgrammeClassifier.kt
+++ b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProgrammeClassifier.kt
@@ -168,7 +168,19 @@ internal object SportsProgrammeClassifier {
SportsEventParser.eventIdentity(classification, sourceKey)
/** Uses Plan 2's sport aliases for provider names; unknown values remain unknown. */
- fun sportForProvider(value: String?): SportType = value?.let(::detectSport) ?: SportType.UNKNOWN
+ fun sportForProvider(value: String?, league: String? = null): SportType {
+ // Some APIs route American football under "football". League identity
+ // disambiguates the sport without changing the provider's route variables.
+ if (SportsTextNormalizer.normalize(value.orEmpty()) == "football") {
+ val normalizedLeague = SportsTextNormalizer.normalize(league.orEmpty())
+ if ("nfl" in normalizedLeague.split(' ') ||
+ normalizedLeague.contains("national football league") ||
+ normalizedLeague.contains("college football") ||
+ normalizedLeague.contains("ncaa football")
+ ) return SportType.AMERICAN_FOOTBALL
+ }
+ return value?.let(::detectSport) ?: SportType.UNKNOWN
+ }
fun canonicalEventTitle(value: String): String = SportsEventParser.canonicalEventTitle(value)
diff --git a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderEventMatcher.kt b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderEventMatcher.kt
index 0104d0a4..e000c05a 100644
--- a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderEventMatcher.kt
+++ b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderEventMatcher.kt
@@ -68,6 +68,7 @@ internal object SportsProviderEventMatcher {
val providerSport = SportsProgrammeClassifier.sportForProvider(
providerEvent.sport ?: providerEvent.league?.sport,
+ providerEvent.league?.name,
)
if (providerSport != SportType.UNKNOWN && localEvent.sport != SportType.UNKNOWN &&
providerSport != localEvent.sport
diff --git a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderEventResolver.kt b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderEventResolver.kt
index 00fc21a3..de45614f 100644
--- a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderEventResolver.kt
+++ b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderEventResolver.kt
@@ -56,7 +56,9 @@ internal class SportsProviderEventResolver @Inject constructor(
}
}
- val proposedMatches = uniqueProviderEvents.mapNotNull { sourced ->
+ // An absent guide (including a provisional API-only presentation) is not
+ // evidence that an existing link has become invalid.
+ val proposedMatches = if (epgEvents.isEmpty()) emptyList() else uniqueProviderEvents.mapNotNull { sourced ->
val candidates = SportsProviderEventMatcher.candidateKeys(sourced.value)
.flatMap { localEventsByCandidateKey[it].orEmpty() }
.distinctBy(SportsEvent::id)
diff --git a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderEventSourceRouter.kt b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderEventSourceRouter.kt
index 5faea02c..8699fced 100644
--- a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderEventSourceRouter.kt
+++ b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderEventSourceRouter.kt
@@ -15,10 +15,12 @@ import com.streamvault.domain.sports.provider.ProviderAttribution
import com.streamvault.domain.sports.provider.SourcedValue
import com.streamvault.domain.sports.provider.SportsSourceRef
import com.streamvault.domain.sports.provider.SportsEventProvenance
+import com.streamvault.domain.sports.provider.CUSTOM_SPORTS_PROVIDER_TYPE_ID
import java.time.Instant
import javax.inject.Inject
import javax.inject.Singleton
import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.withTimeoutOrNull
internal data class LoadedSportsProviderEvents(
val instanceId: String? = null,
@@ -62,7 +64,11 @@ internal class SportsProviderEventSourceRouter @Inject constructor(
if (synchronized(broadcasterCooldowns) { broadcasterCooldowns[config]?.isAfter(now) == true }) continue
val result = try {
val provider = registry.create(config) as? BroadcastProvider ?: continue
- provider.broadcasters(ProviderEventDetailRequest(source.externalEventId))
+ provider.broadcasters(ProviderEventDetailRequest(
+ eventId = source.externalEventId,
+ sport = sourced.value.sport.takeIf { config.typeId == CUSTOM_SPORTS_PROVIDER_TYPE_ID },
+ leagueId = sourced.value.league?.id.takeIf { config.typeId == CUSTOM_SPORTS_PROVIDER_TYPE_ID },
+ ))
} catch (cancelled: CancellationException) {
throw cancelled
} catch (_: Exception) { continue }
@@ -120,22 +126,29 @@ internal class SportsProviderEventSourceRouter @Inject constructor(
?: listOf(null)
var succeeded = false
val events = mutableListOf<ProviderEvent>()
- for (leagueId in leagueIds) {
- val result = try {
- provider.events(ProviderEventRequest(from = from, until = until, leagueId = leagueId))
- } catch (cancelled: CancellationException) {
- throw cancelled
- } catch (_: Exception) {
- continue
- }
- when (result) {
- is SportsProviderResult.Success -> {
- succeeded = true
- events += result.value.items
+ val completed = withTimeoutOrNull(20_000L) {
+ for (leagueId in leagueIds) {
+ val result = try {
+ provider.events(ProviderEventRequest(from = from, until = until, leagueId = leagueId))
+ } catch (cancelled: CancellationException) {
+ throw cancelled
+ } catch (_: Exception) {
+ continue
+ }
+ when (result) {
+ is SportsProviderResult.Success -> {
+ succeeded = true
+ events += result.value.items
+ }
+ is SportsProviderResult.Failure -> SportsDiagnostics.providerFailure(
+ "events", result.category, result.httpStatus,
+ )
}
- is SportsProviderResult.Failure -> Unit
}
}
+ if (completed == null) SportsDiagnostics.providerFailure(
+ "events-timeout", com.streamvault.domain.sports.provider.SportsProviderError.NETWORK,
+ )
if (succeeded) {
return LoadedSportsProviderEvents(
instanceId = config.instanceId,
diff --git a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderExtraDetailsRouter.kt b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderExtraDetailsRouter.kt
new file mode 100644
index 00000000..20e6a81c
--- /dev/null
+++ b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderExtraDetailsRouter.kt
@@ -0,0 +1,143 @@
+package com.streamvault.feature.live.sports
+
+import com.streamvault.domain.sports.provider.ProviderAttribution
+import com.streamvault.domain.sports.provider.ProviderArtwork
+import com.streamvault.domain.sports.provider.ProviderEntityRef
+import com.streamvault.domain.sports.provider.ProviderEntityType
+import com.streamvault.domain.sports.provider.ProviderEventDetailRequest
+import com.streamvault.domain.sports.provider.ProviderEventStatistics
+import com.streamvault.domain.sports.provider.ProviderLineup
+import com.streamvault.domain.sports.provider.ProviderTeamMetadata
+import com.streamvault.domain.sports.provider.SportsCapability
+import com.streamvault.domain.sports.provider.SportsProviderRegistry
+import com.streamvault.domain.sports.provider.SportsProviderResult
+import com.streamvault.domain.sports.provider.SportsProviderStore
+import com.streamvault.domain.sports.provider.SportsSourceRef
+import com.streamvault.domain.sports.provider.ArtworkProvider
+import com.streamvault.domain.sports.provider.LineupProvider
+import com.streamvault.domain.sports.provider.StatisticsProvider
+import javax.inject.Inject
+import javax.inject.Singleton
+import kotlinx.coroutines.CancellationException
+
+internal data class LoadedSportsEventExtraDetails(
+ val statistics: ProviderEventStatistics? = null,
+ val lineups: List<ProviderLineup> = emptyList(),
+ val teamArtwork: List<LoadedSportsTeamArtwork> = emptyList(),
+ val providerName: String,
+ val attribution: ProviderAttribution?,
+)
+
+internal data class LoadedSportsTeamArtwork(
+ val teamName: String,
+ val artwork: ProviderArtwork,
+)
+
+/** Fetches optional per-event details only from the provider that owns the event ID. */
+@Singleton
+internal class SportsProviderExtraDetailsRouter @Inject constructor(
+ private val registry: SportsProviderRegistry,
+ private val store: SportsProviderStore,
+) {
+ suspend fun load(event: SportsEvent): LoadedSportsEventExtraDetails? {
+ val sources = event.provenance.sources.filterIsInstance<SportsSourceRef.Provider>()
+ if (sources.isEmpty()) return null
+ val configs = try {
+ store.configurations()
+ } catch (cancelled: CancellationException) {
+ throw cancelled
+ } catch (_: Exception) {
+ return null
+ }
+ for (source in sources) {
+ val config = configs.firstOrNull {
+ it.enabled && it.instanceId == source.instanceId && it.typeId == source.typeId
+ } ?: continue
+ val capabilities = registry.capabilities(config)
+ if (SportsCapability.LINEUPS !in capabilities &&
+ SportsCapability.STATISTICS !in capabilities &&
+ SportsCapability.ARTWORK !in capabilities
+ ) continue
+ val provider = try {
+ registry.create(config)
+ } catch (cancelled: CancellationException) {
+ throw cancelled
+ } catch (_: Exception) {
+ continue
+ }
+ val request = ProviderEventDetailRequest(
+ eventId = source.externalEventId,
+ sport = source.sport,
+ leagueId = source.leagueId,
+ )
+ val statistics = if (SportsCapability.STATISTICS in capabilities && provider is StatisticsProvider) {
+ try {
+ (provider.statistics(request) as? SportsProviderResult.Success)?.value
+ ?.takeIf { it.statistics.isNotEmpty() }
+ } catch (cancelled: CancellationException) {
+ throw cancelled
+ } catch (_: Exception) {
+ null
+ }
+ } else null
+ val lineups = if (SportsCapability.LINEUPS in capabilities && provider is LineupProvider) {
+ try {
+ (provider.lineups(request) as? SportsProviderResult.Success)?.value?.items.orEmpty()
+ } catch (cancelled: CancellationException) {
+ throw cancelled
+ } catch (_: Exception) {
+ emptyList()
+ }
+ } else emptyList()
+ val teamArtwork = if (SportsCapability.ARTWORK in capabilities && provider is ArtworkProvider) {
+ loadTeamArtwork(
+ provider,
+ event.provenance.teamMetadata?.value.orEmpty(),
+ request.sport,
+ request.leagueId,
+ )
+ } else emptyList()
+ if (statistics == null && lineups.isEmpty() && teamArtwork.isEmpty()) continue
+ val descriptor = registry.descriptor(config.typeId)
+ return LoadedSportsEventExtraDetails(
+ statistics = statistics,
+ lineups = lineups,
+ teamArtwork = teamArtwork,
+ providerName = registry.displayName(config) ?: descriptor?.displayName ?: config.typeId,
+ attribution = descriptor?.compliance?.attribution,
+ )
+ }
+ return null
+ }
+
+ private suspend fun loadTeamArtwork(
+ provider: ArtworkProvider,
+ teams: List<ProviderTeamMetadata>,
+ sport: String?,
+ leagueId: String?,
+ ): List<LoadedSportsTeamArtwork> {
+ val results = mutableListOf<LoadedSportsTeamArtwork>()
+ for (team in teams.take(MAX_TEAM_ARTWORK_REQUESTS)) {
+ val teamId = team.team.id ?: continue
+ val result = try {
+ provider.artwork(ProviderEntityRef(ProviderEntityType.TEAM, teamId, sport, leagueId))
+ } catch (cancelled: CancellationException) {
+ throw cancelled
+ } catch (_: Exception) {
+ continue
+ }
+ if (result is SportsProviderResult.Success) {
+ result.value.items.forEach { artwork ->
+ results += LoadedSportsTeamArtwork(team.team.name, artwork)
+ if (results.size >= MAX_TEAM_ARTWORKS) return results
+ }
+ }
+ }
+ return results
+ }
+
+ private companion object {
+ const val MAX_TEAM_ARTWORK_REQUESTS = 4
+ const val MAX_TEAM_ARTWORKS = 8
+ }
+}
diff --git a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderMetadataRouter.kt b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderMetadataRouter.kt
index 36f7ee01..96e2f8db 100644
--- a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderMetadataRouter.kt
+++ b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderMetadataRouter.kt
@@ -27,12 +27,15 @@ internal data class LoadedSportsProviderMetadata(
val providerName: String? = null,
val teams: Map<String, LoadedMetadataValue<ProviderTeamMetadata>> = emptyMap(),
val leagues: Map<String, LoadedMetadataValue<ProviderLeagueMetadata>> = emptyMap(),
+ val scopedTeams: Map<ProviderMetadataKey, LoadedMetadataValue<ProviderTeamMetadata>> = emptyMap(),
+ val scopedLeagues: Map<ProviderMetadataKey, LoadedMetadataValue<ProviderLeagueMetadata>> = emptyMap(),
val eventCatalogs: Map<ProviderEventKey, com.streamvault.domain.sports.provider.ProviderEvent> = emptyMap(),
)
internal data class LoadedMetadataValue<out T>(val value: T, val isStale: Boolean)
internal data class ProviderEventKey(val instanceId: String, val typeId: String, val eventId: String)
+internal data class ProviderMetadataKey(val id: String, val sport: String?, val leagueId: String?)
/** Bounded metadata enrichment; stable provider IDs and account-scoped caches avoid fuzzy API fan-out. */
@Singleton
@@ -104,33 +107,66 @@ internal class SportsProviderMetadataRouter @Inject constructor(
}
val teams = linkedMapOf<String, LoadedMetadataValue<ProviderTeamMetadata>>()
val leagues = linkedMapOf<String, LoadedMetadataValue<ProviderLeagueMetadata>>()
- val teamIds = providerEvents.asSequence().flatMap { it.competitors.asSequence() }
- .mapNotNull { it.id }.distinct().take(MAX_TEAM_REQUESTS).toList()
- val leagueIds = providerEvents.asSequence().mapNotNull { it.league?.id }
- .distinct().take(MAX_LEAGUE_REQUESTS).toList()
+ val scopedTeams = linkedMapOf<ProviderMetadataKey, LoadedMetadataValue<ProviderTeamMetadata>>()
+ val scopedLeagues = linkedMapOf<ProviderMetadataKey, LoadedMetadataValue<ProviderLeagueMetadata>>()
+ val teamRequests = providerEvents.flatMap { event ->
+ event.competitors.mapNotNull { competitor ->
+ competitor.id?.let {
+ metadataKey(config.typeId, it, event.sport, event.league?.id)
+ }
+ }
+ }.distinct().take(MAX_TEAM_REQUESTS)
+ val leagueRequests = providerEvents.mapNotNull { event ->
+ event.league?.let { league ->
+ league.id?.let { leagueId ->
+ metadataKey(config.typeId, leagueId, event.sport ?: league.sport, leagueId)
+ }
+ }
+ }.distinct().take(MAX_LEAGUE_REQUESTS)
val capabilities = registry.capabilities(config)
if (provider is TeamMetadataProvider && SportsCapability.TEAM_METADATA in capabilities) {
- for (teamId in teamIds) {
- val value = loadTeam(config, provider, teamId, now)
- if (value != null) teams[teamId] = value
+ for (teamRequest in teamRequests) {
+ val value = loadTeam(
+ config,
+ provider,
+ teamRequest.id,
+ teamRequest.sport,
+ teamRequest.leagueId,
+ now,
+ )
+ if (value != null) {
+ teams[teamRequest.id] = value
+ scopedTeams[teamRequest] = value
+ }
}
}
if (provider is LeagueMetadataProvider &&
SportsCapability.LEAGUE_METADATA in capabilities
) {
- for (leagueId in leagueIds) {
- val value = loadLeague(config, provider, leagueId, now)
- if (value != null) leagues[leagueId] = value
+ for (leagueRequest in leagueRequests) {
+ val value = loadLeague(
+ config,
+ provider,
+ leagueRequest.id,
+ leagueRequest.sport,
+ now,
+ )
+ if (value != null) {
+ leagues[leagueRequest.id] = value
+ scopedLeagues[leagueRequest] = value
+ }
}
}
- if (teams.isNotEmpty() || leagues.isNotEmpty()) {
+ if (scopedTeams.isNotEmpty() || scopedLeagues.isNotEmpty()) {
return LoadedSportsProviderMetadata(
instanceId = config.instanceId,
typeId = config.typeId,
providerName = registry.descriptor(config.typeId)?.displayName ?: config.typeId,
teams = teams,
leagues = leagues,
+ scopedTeams = scopedTeams,
+ scopedLeagues = scopedLeagues,
eventCatalogs = eventIndex,
)
}
@@ -144,7 +180,9 @@ internal class SportsProviderMetadataRouter @Inject constructor(
): List<SportsEvent> {
val instanceId = metadata.instanceId ?: return events
val typeId = metadata.typeId ?: return events
- if (metadata.teams.isEmpty() && metadata.leagues.isEmpty()) return events
+ if (metadata.teams.isEmpty() && metadata.leagues.isEmpty() &&
+ metadata.scopedTeams.isEmpty() && metadata.scopedLeagues.isEmpty()
+ ) return events
return events.map { event ->
val sourceAndProviderEvent = event.provenance.sources.asSequence()
.filterIsInstance<SportsSourceRef.Provider>()
@@ -156,14 +194,31 @@ internal class SportsProviderMetadataRouter @Inject constructor(
.firstOrNull() ?: return@map event
val (eventSource, providerEvent) = sourceAndProviderEvent
val teams = providerEvent.competitors.mapNotNull { competitor ->
- competitor.id?.let(metadata.teams::get)?.value
+ competitor.id?.let {
+ metadata.team(typeId, it, providerEvent.sport, providerEvent.league?.id)
+ }?.value
}.distinctBy { it.team.id ?: it.team.name }
val teamMetadataStale = providerEvent.competitors.mapNotNull { competitor ->
- competitor.id?.let(metadata.teams::get)
+ competitor.id?.let {
+ metadata.team(typeId, it, providerEvent.sport, providerEvent.league?.id)
+ }
}.any(LoadedMetadataValue<ProviderTeamMetadata>::isStale)
- val leagueResult = providerEvent.league?.id?.let(metadata.leagues::get)
+ val leagueResult = providerEvent.league?.id?.let { leagueId ->
+ metadata.league(typeId, metadataKey(
+ typeId,
+ leagueId,
+ providerEvent.sport ?: providerEvent.league?.sport,
+ leagueId,
+ ))
+ }
val league = leagueResult?.value
- val source = SportsSourceRef.Provider(instanceId, typeId, eventSource.externalEventId)
+ val source = SportsSourceRef.Provider(
+ instanceId = instanceId,
+ typeId = typeId,
+ externalEventId = eventSource.externalEventId,
+ sport = eventSource.sport,
+ leagueId = eventSource.leagueId,
+ )
val teamValue = teams.takeIf { it.isNotEmpty() }?.let {
SourcedValue(
it,
@@ -190,9 +245,11 @@ internal class SportsProviderMetadataRouter @Inject constructor(
config: SportsProviderConfig,
provider: TeamMetadataProvider,
teamId: String,
+ sport: String?,
+ leagueId: String?,
now: Instant,
): LoadedMetadataValue<ProviderTeamMetadata>? {
- val key = MetadataCacheKey(config, teamId)
+ val key = MetadataCacheKey(config, teamId, sport, leagueId)
val cached = synchronized(teamCache) { teamCache[key] }
if (cached != null && now.isBefore(cached.fetchedAt.plus(CACHE_TTL))) {
return LoadedMetadataValue(cached.value, isStale = false)
@@ -201,7 +258,7 @@ internal class SportsProviderMetadataRouter @Inject constructor(
if (cooling) return cached?.takeIf { now.isBefore(it.fetchedAt.plus(STALE_CACHE_TTL)) }
?.let { LoadedMetadataValue(it.value, isStale = true) }
val result = try {
- provider.teamMetadata(ProviderTeamMetadataRequest(teamId))
+ provider.teamMetadata(ProviderTeamMetadataRequest(teamId, sport, leagueId))
} catch (cancelled: CancellationException) {
throw cancelled
} catch (_: Exception) {
@@ -235,9 +292,10 @@ internal class SportsProviderMetadataRouter @Inject constructor(
config: SportsProviderConfig,
provider: LeagueMetadataProvider,
leagueId: String,
+ sport: String?,
now: Instant,
): LoadedMetadataValue<ProviderLeagueMetadata>? {
- val key = MetadataCacheKey(config, leagueId)
+ val key = MetadataCacheKey(config, leagueId, sport, leagueId)
val cached = synchronized(leagueCache) { leagueCache[key] }
if (cached != null && now.isBefore(cached.fetchedAt.plus(CACHE_TTL))) {
return LoadedMetadataValue(cached.value, isStale = false)
@@ -247,7 +305,7 @@ internal class SportsProviderMetadataRouter @Inject constructor(
?.let { LoadedMetadataValue(it.value, isStale = true) }
}
val result = try {
- provider.leagueMetadata(ProviderLeagueMetadataRequest(leagueId))
+ provider.leagueMetadata(ProviderLeagueMetadataRequest(leagueId, sport))
} catch (cancelled: CancellationException) {
throw cancelled
} catch (_: Exception) {
@@ -280,6 +338,33 @@ internal class SportsProviderMetadataRouter @Inject constructor(
private fun isCoolingDown(config: SportsProviderConfig, now: Instant): Boolean =
synchronized(failureCooldowns) { failureCooldowns[config]?.isAfter(now) == true }
+ private fun metadataKey(
+ typeId: String,
+ id: String,
+ sport: String?,
+ leagueId: String?,
+ ) = if (typeId == CUSTOM_SPORTS_PROVIDER_TYPE_ID) {
+ ProviderMetadataKey(id, sport, leagueId)
+ } else {
+ ProviderMetadataKey(id, sport = null, leagueId = null)
+ }
+
+ private fun LoadedSportsProviderMetadata.team(
+ typeId: String,
+ id: String,
+ sport: String?,
+ leagueId: String?,
+ ): LoadedMetadataValue<ProviderTeamMetadata>? =
+ scopedTeams[metadataKey(typeId, id, sport, leagueId)]
+ ?: teams[id].takeIf { typeId != CUSTOM_SPORTS_PROVIDER_TYPE_ID }
+
+ private fun LoadedSportsProviderMetadata.league(
+ typeId: String,
+ key: ProviderMetadataKey,
+ ): LoadedMetadataValue<ProviderLeagueMetadata>? =
+ scopedLeagues[key]
+ ?: leagues[key.id].takeIf { typeId != CUSTOM_SPORTS_PROVIDER_TYPE_ID }
+
private fun clearCooldown(config: SportsProviderConfig) {
synchronized(failureCooldowns) { failureCooldowns.remove(config) }
}
@@ -291,7 +376,12 @@ internal class SportsProviderMetadataRouter @Inject constructor(
}
}
- private data class MetadataCacheKey(val config: SportsProviderConfig, val entityId: String)
+ private data class MetadataCacheKey(
+ val config: SportsProviderConfig,
+ val entityId: String,
+ val sport: String?,
+ val leagueId: String?,
+ )
private data class CachedTeam(val value: ProviderTeamMetadata, val fetchedAt: Instant)
private data class CachedLeague(val value: ProviderLeagueMetadata, val fetchedAt: Instant)
diff --git a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderScoreSourceRouter.kt b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderScoreSourceRouter.kt
index a27d84b5..cb07b12c 100644
--- a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderScoreSourceRouter.kt
+++ b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderScoreSourceRouter.kt
@@ -2,8 +2,10 @@ package com.streamvault.feature.live.sports
import com.streamvault.domain.sports.provider.LiveScoreProvider
import com.streamvault.domain.sports.provider.ProviderEvent
+import com.streamvault.domain.sports.provider.ProviderEventScope
import com.streamvault.domain.sports.provider.ProviderScore
import com.streamvault.domain.sports.provider.ProviderScoreRequest
+import com.streamvault.domain.sports.provider.CUSTOM_SPORTS_PROVIDER_TYPE_ID
import com.streamvault.domain.sports.provider.SourcedValue
import com.streamvault.domain.sports.provider.SportsCapability
import com.streamvault.domain.sports.provider.SportsProviderConfig
@@ -71,20 +73,24 @@ internal class SportsProviderScoreSourceRouter @Inject constructor(
if (providerEvents.isEmpty()) continue
val eventIds = providerEvents.asSequence()
.filter { it.isRelevantForScoreRefresh(now) }
+ .sortedWith(compareBy<com.streamvault.domain.sports.provider.ProviderEvent> {
+ if (it.status?.state == com.streamvault.domain.sports.provider.ProviderGameState.LIVE) 0 else 1
+ }.thenBy { it.eventStart?.let { start -> Duration.between(now, start).abs() } ?: Duration.ofDays(365) })
+ .take(MAX_SCORE_EVENTS)
.map(ProviderEvent::providerEventId)
- .toSortedSet()
+ .toCollection(linkedSetOf())
if (eventIds.isEmpty()) continue
- val cacheKey = ScoreCacheKey(config, eventIds.toList())
+ val cacheKey = ScoreCacheKey(config, eventIds.sorted())
val cached = synchronized(scoreCache) { scoreCache[cacheKey] }
if (cached != null && now.isBefore(cached.fetchedAt.plus(SCORE_CACHE_TTL))) {
- return loaded(config, providerEvents, cached.scores, stale = false)
+ return loaded(config, providerEvents, cached.scores, stale = false, fetchedAt = cached.fetchedAt)
}
val cooldownUntil = synchronized(failureCooldowns) { failureCooldowns[config] }
if (cooldownUntil != null && now.isBefore(cooldownUntil)) {
val stale = cached?.takeIf { now.isBefore(it.fetchedAt.plus(STALE_SCORE_CACHE_TTL)) }
if (stale != null && staleFallback == null) {
- staleFallback = loaded(config, providerEvents, stale.scores, stale = true)
+ staleFallback = loaded(config, providerEvents, stale.scores, stale = true, fetchedAt = stale.fetchedAt)
}
continue
}
@@ -101,7 +107,14 @@ internal class SportsProviderScoreSourceRouter @Inject constructor(
continue
}
val result = try {
- provider.liveScores(ProviderScoreRequest(eventIds))
+ provider.liveScores(ProviderScoreRequest(
+ eventIds = eventIds,
+ eventScopes = if (config.typeId == CUSTOM_SPORTS_PROVIDER_TYPE_ID) {
+ providerEvents.associate { event ->
+ event.providerEventId to ProviderEventScope(event.sport, event.league?.id)
+ }
+ } else emptyMap(),
+ ))
} catch (cancelled: CancellationException) {
throw cancelled
} catch (_: Exception) {
@@ -115,20 +128,20 @@ internal class SportsProviderScoreSourceRouter @Inject constructor(
trim(scoreCache, MAX_SCORE_CACHE_ENTRIES)
}
synchronized(failureCooldowns) { failureCooldowns.remove(config) }
- return loaded(config, providerEvents, scores, stale = false)
+ return loaded(config, providerEvents, scores, stale = false, fetchedAt = now)
}
is SportsProviderResult.Failure -> {
putFailureCooldown(config, result.retryAt, now)
val stale = cached?.takeIf { now.isBefore(it.fetchedAt.plus(STALE_SCORE_CACHE_TTL)) }
if (stale != null && staleFallback == null) {
- staleFallback = loaded(config, providerEvents, stale.scores, stale = true)
+ staleFallback = loaded(config, providerEvents, stale.scores, stale = true, fetchedAt = stale.fetchedAt)
}
}
null -> {
putFailureCooldown(config, retryAt = null, now = now)
val stale = cached?.takeIf { now.isBefore(it.fetchedAt.plus(STALE_SCORE_CACHE_TTL)) }
if (stale != null && staleFallback == null) {
- staleFallback = loaded(config, providerEvents, stale.scores, stale = true)
+ staleFallback = loaded(config, providerEvents, stale.scores, stale = true, fetchedAt = stale.fetchedAt)
}
}
}
@@ -194,15 +207,23 @@ internal class SportsProviderScoreSourceRouter @Inject constructor(
events: List<ProviderEvent>,
scores: List<ProviderScore>,
stale: Boolean,
+ fetchedAt: Instant,
) = LoadedSportsProviderScores(
instanceId = config.instanceId,
typeId = config.typeId,
events = events,
scores = scores.map { score ->
+ val event = events.firstOrNull { it.providerEventId == score.providerEventId }
SourcedValue(
value = score,
- source = SportsSourceRef.Provider(config.instanceId, config.typeId, score.providerEventId),
- updatedAt = score.updatedAt ?: score.status?.updatedAt,
+ source = SportsSourceRef.Provider(
+ instanceId = config.instanceId,
+ typeId = config.typeId,
+ externalEventId = score.providerEventId,
+ sport = event?.sport.takeIf { config.typeId == CUSTOM_SPORTS_PROVIDER_TYPE_ID },
+ leagueId = event?.league?.id.takeIf { config.typeId == CUSTOM_SPORTS_PROVIDER_TYPE_ID },
+ ),
+ updatedAt = score.updatedAt ?: score.status?.updatedAt ?: fetchedAt,
isStale = stale,
)
},
@@ -244,6 +265,7 @@ internal class SportsProviderScoreSourceRouter @Inject constructor(
com.streamvault.domain.sports.provider.ProviderGameState.POSTPONED,
)
const val MAX_SCORE_CACHE_ENTRIES = 64
+ const val MAX_SCORE_EVENTS = 50
const val MAX_EVENT_CACHE_ENTRIES = 32
}
}
diff --git a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderStandingsRouter.kt b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderStandingsRouter.kt
index e26d5a1c..1d5b0e93 100644
--- a/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderStandingsRouter.kt
+++ b/feature/live/src/main/java/com/streamvault/feature/live/sports/SportsProviderStandingsRouter.kt
@@ -12,6 +12,7 @@ import com.streamvault.domain.sports.provider.SportsProviderResult
import com.streamvault.domain.sports.provider.SportsStandingsSourceMode
import com.streamvault.domain.sports.provider.SportsStandingsSourcePreference
import com.streamvault.domain.sports.provider.SportsSourceRef
+import com.streamvault.domain.sports.provider.CUSTOM_SPORTS_PROVIDER_TYPE_ID
import java.time.Duration
import java.time.Instant
import javax.inject.Inject
@@ -61,7 +62,9 @@ internal class SportsProviderStandingsRouter @Inject constructor(
eventLeagueSource: SportsSourceRef.Provider?,
now: Instant = Instant.now(),
): LoadedSportsStandings? {
- val leagueName = eventLeague?.name?.trim()?.takeIf(String::isNotEmpty) ?: return null
+ val leagueName = eventLeague?.name?.trim()?.takeIf(String::isNotEmpty)
+ ?: eventLeague?.id?.takeIf(String::isNotEmpty)
+ ?: return null
var staleFallback: LoadedSportsStandings? = null
for (config in providers) {
val sameProviderIdentity = config.instanceId == eventLeagueSource?.instanceId
@@ -99,7 +102,11 @@ internal class SportsProviderStandingsRouter @Inject constructor(
}
val result = try {
- provider.standings(ProviderStandingsRequest(leagueId))
+ provider.standings(ProviderStandingsRequest(
+ leagueId = leagueId,
+ sport = eventLeague?.sport.takeIf { config.typeId == CUSTOM_SPORTS_PROVIDER_TYPE_ID },
+ leagueName = eventLeague?.name,
+ ))
} catch (cancelled: CancellationException) {
throw cancelled
} catch (_: Exception) {
@@ -142,10 +149,10 @@ internal class SportsProviderStandingsRouter @Inject constructor(
sameProviderIdentity: Boolean,
): Boolean {
val returnedId = standings.league.id
- if (returnedId != null && returnedId != requestedId) return false
- if (sameProviderIdentity || returnedId == requestedId) return true
- val returnedName = standings.league.name?.trim()?.takeIf(String::isNotEmpty) ?: return false
- return normalize(returnedName) == normalize(requestedName)
+ val returnedName = standings.league.name?.trim()?.takeIf(String::isNotEmpty)
+ val namesMatch = returnedName?.let { normalize(it) == normalize(requestedName) } == true
+ if (returnedId != null && returnedId != requestedId) return sameProviderIdentity && namesMatch
+ return sameProviderIdentity || returnedId == requestedId || namesMatch
}
private fun loaded(config: SportsProviderConfig, value: ProviderStandings, stale: Boolean) =
diff --git a/feature/live/src/main/res/values-ar/strings.xml b/feature/live/src/main/res/values-ar/strings.xml
index 9a58c9e8..75a8f718 100644
--- a/feature/live/src/main/res/values-ar/strings.xml
+++ b/feature/live/src/main/res/values-ar/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">نقاط</string>
<string name="live_sports_football_data_attribution">بيانات كرة القدم مقدمة من %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">تفاصيل إضافية للحدث</string>
+ <string name="live_sports_extra_details_load">تحميل التفاصيل</string>
+ <string name="live_sports_extra_details_loading">جارٍ تحميل تفاصيل الحدث…</string>
+ <string name="live_sports_extra_details_unavailable">تفاصيل الحدث غير متاحة</string>
+ <string name="live_sports_statistics">الإحصاءات</string>
+ <string name="live_sports_lineups">التشكيلات</string>
+ <string name="live_sports_lineup_starter">أساسي</string>
+ <string name="live_sports_inclusions">الرياضات والدوريات</string>
+ <string name="live_sports_inclusions_hint">تظهر الرياضات والدوريات المحددة في قسم الرياضة.</string>
+ <string name="live_sports_search_events">ابحث عن فرق أو مباريات</string>
+ <string name="live_sports_search_leagues">ابحث عن دوريات</string>
+ <string name="live_sports_leagues">الدوريات</string>
+ <string name="live_sports_american_football">كرة القدم الأمريكية</string>
+ <string name="live_sports_baseball">البيسبول</string>
+ <string name="live_sports_hockey">هوكي الجليد</string>
+ <string name="live_sports_tennis">التنس</string>
+ <string name="live_sports_mma">الفنون القتالية المختلطة</string>
+ <string name="live_sports_boxing">الملاكمة</string>
+ <string name="live_sports_cricket">الكريكيت</string>
+ <string name="live_sports_rugby">الرغبي</string>
+ <string name="live_sports_golf">الغولف</string>
+ <string name="live_sports_volleyball">الكرة الطائرة</string>
+ <string name="live_sports_handball">كرة اليد</string>
+ <string name="live_sports_snooker">السنوكر</string>
+ <string name="live_sports_darts">رمي السهام</string>
+ <string name="live_sports_cycling">ركوب الدراجات</string>
</resources>
diff --git a/feature/live/src/main/res/values-bg/strings.xml b/feature/live/src/main/res/values-bg/strings.xml
index 49d53573..136807b0 100644
--- a/feature/live/src/main/res/values-bg/strings.xml
+++ b/feature/live/src/main/res/values-bg/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Точки</string>
<string name="live_sports_football_data_attribution">Футболни данни, предоставени от %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Още подробности за събитието</string>
+ <string name="live_sports_extra_details_load">Зареждане на подробности</string>
+ <string name="live_sports_extra_details_loading">Зареждане на подробностите за събитието…</string>
+ <string name="live_sports_extra_details_unavailable">Подробностите за събитието не са налични</string>
+ <string name="live_sports_statistics">Статистика</string>
+ <string name="live_sports_lineups">Състави</string>
+ <string name="live_sports_lineup_starter">Титуляр</string>
+ <string name="live_sports_inclusions">Спортове и лиги</string>
+ <string name="live_sports_inclusions_hint">Избраните спортове и лиги се показват в Спорт.</string>
+ <string name="live_sports_search_events">Търсене на отбори или мачове</string>
+ <string name="live_sports_search_leagues">Търсене на лиги</string>
+ <string name="live_sports_leagues">Лиги</string>
+ <string name="live_sports_american_football">Американски футбол</string>
+ <string name="live_sports_baseball">Бейзбол</string>
+ <string name="live_sports_hockey">Хокей на лед</string>
+ <string name="live_sports_tennis">Тенис</string>
+ <string name="live_sports_mma">Смесени бойни изкуства</string>
+ <string name="live_sports_boxing">Бокс</string>
+ <string name="live_sports_cricket">Крикет</string>
+ <string name="live_sports_rugby">Ръгби</string>
+ <string name="live_sports_golf">Голф</string>
+ <string name="live_sports_volleyball">Волейбол</string>
+ <string name="live_sports_handball">Хандбал</string>
+ <string name="live_sports_snooker">Снукър</string>
+ <string name="live_sports_darts">Дартс</string>
+ <string name="live_sports_cycling">Колоездене</string>
</resources>
diff --git a/feature/live/src/main/res/values-cs/strings.xml b/feature/live/src/main/res/values-cs/strings.xml
index 36f0cfb0..ebac6a00 100644
--- a/feature/live/src/main/res/values-cs/strings.xml
+++ b/feature/live/src/main/res/values-cs/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Body</string>
<string name="live_sports_football_data_attribution">Fotbalová data poskytuje %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Další podrobnosti události</string>
+ <string name="live_sports_extra_details_load">Načíst podrobnosti</string>
+ <string name="live_sports_extra_details_loading">Načítání podrobností události…</string>
+ <string name="live_sports_extra_details_unavailable">Podrobnosti události nejsou dostupné</string>
+ <string name="live_sports_statistics">Statistiky</string>
+ <string name="live_sports_lineups">Sestavy</string>
+ <string name="live_sports_lineup_starter">V základní sestavě</string>
+ <string name="live_sports_inclusions">Sporty a ligy</string>
+ <string name="live_sports_inclusions_hint">Zaškrtnuté sporty a ligy se zobrazují v sekci Sport.</string>
+ <string name="live_sports_search_events">Hledat týmy nebo zápasy</string>
+ <string name="live_sports_search_leagues">Hledat ligy</string>
+ <string name="live_sports_leagues">Ligy</string>
+ <string name="live_sports_american_football">Americký fotbal</string>
+ <string name="live_sports_baseball">Baseball</string>
+ <string name="live_sports_hockey">Lední hokej</string>
+ <string name="live_sports_tennis">Tenis</string>
+ <string name="live_sports_mma">Smíšená bojová umění</string>
+ <string name="live_sports_boxing">Box</string>
+ <string name="live_sports_cricket">Kriket</string>
+ <string name="live_sports_rugby">Ragby</string>
+ <string name="live_sports_golf">Golf</string>
+ <string name="live_sports_volleyball">Volejbal</string>
+ <string name="live_sports_handball">Házená</string>
+ <string name="live_sports_snooker">Snooker</string>
+ <string name="live_sports_darts">Šipky</string>
+ <string name="live_sports_cycling">Cyklistika</string>
</resources>
diff --git a/feature/live/src/main/res/values-da/strings.xml b/feature/live/src/main/res/values-da/strings.xml
index 7d6d746c..beecc83c 100644
--- a/feature/live/src/main/res/values-da/strings.xml
+++ b/feature/live/src/main/res/values-da/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Point</string>
<string name="live_sports_football_data_attribution">Fodboldata leveret af %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Flere kampdetaljer</string>
+ <string name="live_sports_extra_details_load">Indlæs detaljer</string>
+ <string name="live_sports_extra_details_loading">Indlæser kampdetaljer…</string>
+ <string name="live_sports_extra_details_unavailable">Kampdetaljer er ikke tilgængelige</string>
+ <string name="live_sports_statistics">Statistik</string>
+ <string name="live_sports_lineups">Holdopstillinger</string>
+ <string name="live_sports_lineup_starter">Startspiller</string>
+ <string name="live_sports_inclusions">Sportsgrene og ligaer</string>
+ <string name="live_sports_inclusions_hint">Valgte sportsgrene og ligaer vises under Sport.</string>
+ <string name="live_sports_search_events">Søg efter hold eller kampe</string>
+ <string name="live_sports_search_leagues">Søg efter ligaer</string>
+ <string name="live_sports_leagues">Ligaer</string>
+ <string name="live_sports_american_football">Amerikansk fodbold</string>
+ <string name="live_sports_baseball">Baseball</string>
+ <string name="live_sports_hockey">Ishockey</string>
+ <string name="live_sports_tennis">Tennis</string>
+ <string name="live_sports_mma">Blandet kampsport</string>
+ <string name="live_sports_boxing">Boksning</string>
+ <string name="live_sports_cricket">Cricket</string>
+ <string name="live_sports_rugby">Rugby</string>
+ <string name="live_sports_golf">Golf</string>
+ <string name="live_sports_volleyball">Volleyball</string>
+ <string name="live_sports_handball">Håndbold</string>
+ <string name="live_sports_snooker">Snooker</string>
+ <string name="live_sports_darts">Dart</string>
+ <string name="live_sports_cycling">Cykling</string>
</resources>
diff --git a/feature/live/src/main/res/values-de/strings.xml b/feature/live/src/main/res/values-de/strings.xml
index a989c545..882a3616 100644
--- a/feature/live/src/main/res/values-de/strings.xml
+++ b/feature/live/src/main/res/values-de/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Punkte</string>
<string name="live_sports_football_data_attribution">Fußballdaten bereitgestellt von %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Weitere Spieldetails</string>
+ <string name="live_sports_extra_details_load">Details laden</string>
+ <string name="live_sports_extra_details_loading">Spieldetails werden geladen…</string>
+ <string name="live_sports_extra_details_unavailable">Spieldetails nicht verfügbar</string>
+ <string name="live_sports_statistics">Statistiken</string>
+ <string name="live_sports_lineups">Aufstellungen</string>
+ <string name="live_sports_lineup_starter">Stammspieler</string>
+ <string name="live_sports_inclusions">Sportarten und Ligen</string>
+ <string name="live_sports_inclusions_hint">Markierte Sportarten und Ligen erscheinen unter Sport.</string>
+ <string name="live_sports_search_events">Teams oder Spiele suchen</string>
+ <string name="live_sports_search_leagues">Ligen suchen</string>
+ <string name="live_sports_leagues">Ligen</string>
+ <string name="live_sports_american_football">American Football</string>
+ <string name="live_sports_baseball">Baseball</string>
+ <string name="live_sports_hockey">Eishockey</string>
+ <string name="live_sports_tennis">Tennis</string>
+ <string name="live_sports_mma">Gemischte Kampfkünste</string>
+ <string name="live_sports_boxing">Boxen</string>
+ <string name="live_sports_cricket">Cricket</string>
+ <string name="live_sports_rugby">Rugby</string>
+ <string name="live_sports_golf">Golf</string>
+ <string name="live_sports_volleyball">Volleyball</string>
+ <string name="live_sports_handball">Handball</string>
+ <string name="live_sports_snooker">Snooker</string>
+ <string name="live_sports_darts">Darts</string>
+ <string name="live_sports_cycling">Radsport</string>
</resources>
diff --git a/feature/live/src/main/res/values-el/strings.xml b/feature/live/src/main/res/values-el/strings.xml
index 94203dfa..8430c726 100644
--- a/feature/live/src/main/res/values-el/strings.xml
+++ b/feature/live/src/main/res/values-el/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Βαθμοί</string>
<string name="live_sports_football_data_attribution">Δεδομένα ποδοσφαίρου παρέχονται από το %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Περισσότερες λεπτομέρειες αγώνα</string>
+ <string name="live_sports_extra_details_load">Φόρτωση λεπτομερειών</string>
+ <string name="live_sports_extra_details_loading">Φόρτωση λεπτομερειών αγώνα…</string>
+ <string name="live_sports_extra_details_unavailable">Οι λεπτομέρειες αγώνα δεν είναι διαθέσιμες</string>
+ <string name="live_sports_statistics">Στατιστικά</string>
+ <string name="live_sports_lineups">Συνθέσεις</string>
+ <string name="live_sports_lineup_starter">Βασικός</string>
+ <string name="live_sports_inclusions">Αθλήματα και πρωταθλήματα</string>
+ <string name="live_sports_inclusions_hint">Τα επιλεγμένα αθλήματα και πρωταθλήματα εμφανίζονται στα Αθλητικά.</string>
+ <string name="live_sports_search_events">Αναζήτηση ομάδων ή αγώνων</string>
+ <string name="live_sports_search_leagues">Αναζήτηση πρωταθλημάτων</string>
+ <string name="live_sports_leagues">Πρωταθλήματα</string>
+ <string name="live_sports_american_football">Αμερικανικό ποδόσφαιρο</string>
+ <string name="live_sports_baseball">Μπέιζμπολ</string>
+ <string name="live_sports_hockey">Χόκεϊ επί πάγου</string>
+ <string name="live_sports_tennis">Τένις</string>
+ <string name="live_sports_mma">Μικτές πολεμικές τέχνες</string>
+ <string name="live_sports_boxing">Πυγμαχία</string>
+ <string name="live_sports_cricket">Κρίκετ</string>
+ <string name="live_sports_rugby">Ράγκμπι</string>
+ <string name="live_sports_golf">Γκολφ</string>
+ <string name="live_sports_volleyball">Βόλεϊ</string>
+ <string name="live_sports_handball">Χάντμπολ</string>
+ <string name="live_sports_snooker">Σνούκερ</string>
+ <string name="live_sports_darts">Βελάκια</string>
+ <string name="live_sports_cycling">Ποδηλασία</string>
</resources>
diff --git a/feature/live/src/main/res/values-es/strings.xml b/feature/live/src/main/res/values-es/strings.xml
index 8274f7df..95dba2eb 100644
--- a/feature/live/src/main/res/values-es/strings.xml
+++ b/feature/live/src/main/res/values-es/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Puntos</string>
<string name="live_sports_football_data_attribution">Datos de fútbol proporcionados por %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Más detalles del evento</string>
+ <string name="live_sports_extra_details_load">Cargar detalles</string>
+ <string name="live_sports_extra_details_loading">Cargando detalles del evento…</string>
+ <string name="live_sports_extra_details_unavailable">Detalles del evento no disponibles</string>
+ <string name="live_sports_statistics">Estadísticas</string>
+ <string name="live_sports_lineups">Alineaciones</string>
+ <string name="live_sports_lineup_starter">Titular</string>
+ <string name="live_sports_inclusions">Deportes y ligas</string>
+ <string name="live_sports_inclusions_hint">Los deportes y ligas marcados aparecen en Deportes.</string>
+ <string name="live_sports_search_events">Buscar equipos o partidos</string>
+ <string name="live_sports_search_leagues">Buscar ligas</string>
+ <string name="live_sports_leagues">Ligas</string>
+ <string name="live_sports_american_football">Fútbol americano</string>
+ <string name="live_sports_baseball">Béisbol</string>
+ <string name="live_sports_hockey">Hockey sobre hielo</string>
+ <string name="live_sports_tennis">Tenis</string>
+ <string name="live_sports_mma">Artes marciales mixtas</string>
+ <string name="live_sports_boxing">Boxeo</string>
+ <string name="live_sports_cricket">Críquet</string>
+ <string name="live_sports_rugby">Rugbi</string>
+ <string name="live_sports_golf">Golf</string>
+ <string name="live_sports_volleyball">Voleibol</string>
+ <string name="live_sports_handball">Balonmano</string>
+ <string name="live_sports_snooker">Snooker</string>
+ <string name="live_sports_darts">Dardos</string>
+ <string name="live_sports_cycling">Ciclismo</string>
</resources>
diff --git a/feature/live/src/main/res/values-fa/strings.xml b/feature/live/src/main/res/values-fa/strings.xml
index 9e5935e9..b698ae77 100644
--- a/feature/live/src/main/res/values-fa/strings.xml
+++ b/feature/live/src/main/res/values-fa/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">امتیاز</string>
<string name="live_sports_football_data_attribution">داده‌های فوتبال ارائه‌شده توسط %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">جزئیات بیشتر رویداد</string>
+ <string name="live_sports_extra_details_load">بارگذاری جزئیات</string>
+ <string name="live_sports_extra_details_loading">در حال بارگذاری جزئیات رویداد…</string>
+ <string name="live_sports_extra_details_unavailable">جزئیات رویداد در دسترس نیست</string>
+ <string name="live_sports_statistics">آمار</string>
+ <string name="live_sports_lineups">ترکیب‌ها</string>
+ <string name="live_sports_lineup_starter">بازیکن اصلی</string>
+ <string name="live_sports_inclusions">ورزش‌ها و لیگ‌ها</string>
+ <string name="live_sports_inclusions_hint">ورزش‌ها و لیگ‌های انتخاب‌شده در بخش ورزش نمایش داده می‌شوند.</string>
+ <string name="live_sports_search_events">جستجوی تیم‌ها یا مسابقات</string>
+ <string name="live_sports_search_leagues">جستجوی لیگ‌ها</string>
+ <string name="live_sports_leagues">لیگ‌ها</string>
+ <string name="live_sports_american_football">فوتبال آمریکایی</string>
+ <string name="live_sports_baseball">بیسبال</string>
+ <string name="live_sports_hockey">هاکی روی یخ</string>
+ <string name="live_sports_tennis">تنیس</string>
+ <string name="live_sports_mma">هنرهای رزمی ترکیبی</string>
+ <string name="live_sports_boxing">بوکس</string>
+ <string name="live_sports_cricket">کریکت</string>
+ <string name="live_sports_rugby">راگبی</string>
+ <string name="live_sports_golf">گلف</string>
+ <string name="live_sports_volleyball">والیبال</string>
+ <string name="live_sports_handball">هندبال</string>
+ <string name="live_sports_snooker">اسنوکر</string>
+ <string name="live_sports_darts">دارت</string>
+ <string name="live_sports_cycling">دوچرخه‌سواری</string>
</resources>
diff --git a/feature/live/src/main/res/values-fi/strings.xml b/feature/live/src/main/res/values-fi/strings.xml
index a3f12d3b..692959db 100644
--- a/feature/live/src/main/res/values-fi/strings.xml
+++ b/feature/live/src/main/res/values-fi/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Pisteet</string>
<string name="live_sports_football_data_attribution">Jalkapallotiedot tarjoaa %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Tapahtuman lisätiedot</string>
+ <string name="live_sports_extra_details_load">Lataa tiedot</string>
+ <string name="live_sports_extra_details_loading">Ladataan tapahtuman tietoja…</string>
+ <string name="live_sports_extra_details_unavailable">Tapahtuman tietoja ei ole saatavilla</string>
+ <string name="live_sports_statistics">Tilastot</string>
+ <string name="live_sports_lineups">Kokoonpanot</string>
+ <string name="live_sports_lineup_starter">Avauskokoonpanossa</string>
+ <string name="live_sports_inclusions">Urheilulajit ja liigat</string>
+ <string name="live_sports_inclusions_hint">Valitut lajit ja liigat näkyvät Urheilussa.</string>
+ <string name="live_sports_search_events">Hae joukkueita tai otteluita</string>
+ <string name="live_sports_search_leagues">Hae liigoja</string>
+ <string name="live_sports_leagues">Liigat</string>
+ <string name="live_sports_american_football">Amerikkalainen jalkapallo</string>
+ <string name="live_sports_baseball">Baseball</string>
+ <string name="live_sports_hockey">Jääkiekko</string>
+ <string name="live_sports_tennis">Tennis</string>
+ <string name="live_sports_mma">Vapaaottelu</string>
+ <string name="live_sports_boxing">Nyrkkeily</string>
+ <string name="live_sports_cricket">Kriketti</string>
+ <string name="live_sports_rugby">Rugby</string>
+ <string name="live_sports_golf">Golf</string>
+ <string name="live_sports_volleyball">Lentopallo</string>
+ <string name="live_sports_handball">Käsipallo</string>
+ <string name="live_sports_snooker">Snooker</string>
+ <string name="live_sports_darts">Darts</string>
+ <string name="live_sports_cycling">Pyöräily</string>
</resources>
diff --git a/feature/live/src/main/res/values-fil/strings.xml b/feature/live/src/main/res/values-fil/strings.xml
index 2c41766d..2913f65c 100644
--- a/feature/live/src/main/res/values-fil/strings.xml
+++ b/feature/live/src/main/res/values-fil/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Puntos</string>
<string name="live_sports_football_data_attribution">Data ng football na ibinigay ng %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Iba pang detalye ng laban</string>
+ <string name="live_sports_extra_details_load">I-load ang mga detalye</string>
+ <string name="live_sports_extra_details_loading">Nilo-load ang mga detalye ng laban…</string>
+ <string name="live_sports_extra_details_unavailable">Hindi available ang mga detalye ng laban</string>
+ <string name="live_sports_statistics">Mga istatistika</string>
+ <string name="live_sports_lineups">Mga lineup</string>
+ <string name="live_sports_lineup_starter">Starter</string>
+ <string name="live_sports_inclusions">Mga isport at liga</string>
+ <string name="live_sports_inclusions_hint">Lalabas sa Isports ang mga napiling isport at liga.</string>
+ <string name="live_sports_search_events">Maghanap ng mga koponan o laban</string>
+ <string name="live_sports_search_leagues">Maghanap ng mga liga</string>
+ <string name="live_sports_leagues">Mga liga</string>
+ <string name="live_sports_american_football">Amerikanong football</string>
+ <string name="live_sports_baseball">Beisbol</string>
+ <string name="live_sports_hockey">Hockey sa yelo</string>
+ <string name="live_sports_tennis">Tenis</string>
+ <string name="live_sports_mma">Pinaghalong sining ng pakikipaglaban</string>
+ <string name="live_sports_boxing">Boksing</string>
+ <string name="live_sports_cricket">Kriket</string>
+ <string name="live_sports_rugby">Ragbi</string>
+ <string name="live_sports_golf">Golp</string>
+ <string name="live_sports_volleyball">Balibol</string>
+ <string name="live_sports_handball">Handbol</string>
+ <string name="live_sports_snooker">Snooker</string>
+ <string name="live_sports_darts">Darts</string>
+ <string name="live_sports_cycling">Pagbibisikleta</string>
</resources>
diff --git a/feature/live/src/main/res/values-fr/strings.xml b/feature/live/src/main/res/values-fr/strings.xml
index 63dd4f03..bda465a9 100644
--- a/feature/live/src/main/res/values-fr/strings.xml
+++ b/feature/live/src/main/res/values-fr/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Points</string>
<string name="live_sports_football_data_attribution">Données de football fournies par %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Détails supplémentaires du match</string>
+ <string name="live_sports_extra_details_load">Charger les détails</string>
+ <string name="live_sports_extra_details_loading">Chargement des détails du match…</string>
+ <string name="live_sports_extra_details_unavailable">Détails du match indisponibles</string>
+ <string name="live_sports_statistics">Statistiques</string>
+ <string name="live_sports_lineups">Compositions</string>
+ <string name="live_sports_lineup_starter">Titulaire</string>
+ <string name="live_sports_inclusions">Sports et ligues</string>
+ <string name="live_sports_inclusions_hint">Les sports et ligues cochés apparaissent dans Sports.</string>
+ <string name="live_sports_search_events">Rechercher des équipes ou des matchs</string>
+ <string name="live_sports_search_leagues">Rechercher des ligues</string>
+ <string name="live_sports_leagues">Ligues</string>
+ <string name="live_sports_american_football">Football américain</string>
+ <string name="live_sports_baseball">Baseball</string>
+ <string name="live_sports_hockey">Hockey sur glace</string>
+ <string name="live_sports_tennis">Tennis</string>
+ <string name="live_sports_mma">Arts martiaux mixtes</string>
+ <string name="live_sports_boxing">Boxe</string>
+ <string name="live_sports_cricket">Cricket</string>
+ <string name="live_sports_rugby">Rugby</string>
+ <string name="live_sports_golf">Golf</string>
+ <string name="live_sports_volleyball">Volley-ball</string>
+ <string name="live_sports_handball">Handball</string>
+ <string name="live_sports_snooker">Snooker</string>
+ <string name="live_sports_darts">Fléchettes</string>
+ <string name="live_sports_cycling">Cyclisme</string>
</resources>
diff --git a/feature/live/src/main/res/values-hi/strings.xml b/feature/live/src/main/res/values-hi/strings.xml
index 617c84b3..dba1bdf0 100644
--- a/feature/live/src/main/res/values-hi/strings.xml
+++ b/feature/live/src/main/res/values-hi/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">अंक</string>
<string name="live_sports_football_data_attribution">फुटबॉल डेटा %1$s द्वारा प्रदान किया गया</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">इवेंट की अतिरिक्त जानकारी</string>
+ <string name="live_sports_extra_details_load">जानकारी लोड करें</string>
+ <string name="live_sports_extra_details_loading">इवेंट की जानकारी लोड हो रही है…</string>
+ <string name="live_sports_extra_details_unavailable">इवेंट की जानकारी उपलब्ध नहीं है</string>
+ <string name="live_sports_statistics">आँकड़े</string>
+ <string name="live_sports_lineups">लाइनअप</string>
+ <string name="live_sports_lineup_starter">शुरुआती खिलाड़ी</string>
+ <string name="live_sports_inclusions">खेल और लीग</string>
+ <string name="live_sports_inclusions_hint">चुने गए खेल और लीग खेल अनुभाग में दिखाई देते हैं।</string>
+ <string name="live_sports_search_events">टीमें या मैच खोजें</string>
+ <string name="live_sports_search_leagues">लीग खोजें</string>
+ <string name="live_sports_leagues">लीग</string>
+ <string name="live_sports_american_football">अमेरिकी फ़ुटबॉल</string>
+ <string name="live_sports_baseball">बेसबॉल</string>
+ <string name="live_sports_hockey">आइस हॉकी</string>
+ <string name="live_sports_tennis">टेनिस</string>
+ <string name="live_sports_mma">मिश्रित मार्शल आर्ट</string>
+ <string name="live_sports_boxing">मुक्केबाज़ी</string>
+ <string name="live_sports_cricket">क्रिकेट</string>
+ <string name="live_sports_rugby">रग्बी</string>
+ <string name="live_sports_golf">गोल्फ़</string>
+ <string name="live_sports_volleyball">वॉलीबॉल</string>
+ <string name="live_sports_handball">हैंडबॉल</string>
+ <string name="live_sports_snooker">स्नूकर</string>
+ <string name="live_sports_darts">डार्ट्स</string>
+ <string name="live_sports_cycling">साइकिलिंग</string>
</resources>
diff --git a/feature/live/src/main/res/values-hr/strings.xml b/feature/live/src/main/res/values-hr/strings.xml
index 68e04200..4d6e04d7 100644
--- a/feature/live/src/main/res/values-hr/strings.xml
+++ b/feature/live/src/main/res/values-hr/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Bodovi</string>
<string name="live_sports_football_data_attribution">Nogometne podatke pruža %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Dodatni detalji događaja</string>
+ <string name="live_sports_extra_details_load">Učitaj detalje</string>
+ <string name="live_sports_extra_details_loading">Učitavanje detalja događaja…</string>
+ <string name="live_sports_extra_details_unavailable">Detalji događaja nisu dostupni</string>
+ <string name="live_sports_statistics">Statistika</string>
+ <string name="live_sports_lineups">Postave</string>
+ <string name="live_sports_lineup_starter">U početnoj postavi</string>
+ <string name="live_sports_inclusions">Sportovi i lige</string>
+ <string name="live_sports_inclusions_hint">Označeni sportovi i lige prikazuju se u Sportu.</string>
+ <string name="live_sports_search_events">Pretraži momčadi ili utakmice</string>
+ <string name="live_sports_search_leagues">Pretraži lige</string>
+ <string name="live_sports_leagues">Lige</string>
+ <string name="live_sports_american_football">Američki nogomet</string>
+ <string name="live_sports_baseball">Bejzbol</string>
+ <string name="live_sports_hockey">Hokej na ledu</string>
+ <string name="live_sports_tennis">Tenis</string>
+ <string name="live_sports_mma">Mješovite borilačke vještine</string>
+ <string name="live_sports_boxing">Boks</string>
+ <string name="live_sports_cricket">Kriket</string>
+ <string name="live_sports_rugby">Ragbi</string>
+ <string name="live_sports_golf">Golf</string>
+ <string name="live_sports_volleyball">Odbojka</string>
+ <string name="live_sports_handball">Rukomet</string>
+ <string name="live_sports_snooker">Snooker</string>
+ <string name="live_sports_darts">Pikado</string>
+ <string name="live_sports_cycling">Biciklizam</string>
</resources>
diff --git a/feature/live/src/main/res/values-hu/strings.xml b/feature/live/src/main/res/values-hu/strings.xml
index 7dc54c6a..ae44b428 100644
--- a/feature/live/src/main/res/values-hu/strings.xml
+++ b/feature/live/src/main/res/values-hu/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Pontok</string>
<string name="live_sports_football_data_attribution">Labdarúgási adatokat a(z) %1$s szolgáltatja</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">További eseményadatok</string>
+ <string name="live_sports_extra_details_load">Részletek betöltése</string>
+ <string name="live_sports_extra_details_loading">Eseményadatok betöltése…</string>
+ <string name="live_sports_extra_details_unavailable">Az eseményadatok nem érhetők el</string>
+ <string name="live_sports_statistics">Statisztikák</string>
+ <string name="live_sports_lineups">Felállások</string>
+ <string name="live_sports_lineup_starter">Kezdőjátékos</string>
+ <string name="live_sports_inclusions">Sportágak és ligák</string>
+ <string name="live_sports_inclusions_hint">A kijelölt sportágak és ligák a Sport lapon jelennek meg.</string>
+ <string name="live_sports_search_events">Csapatok vagy mérkőzések keresése</string>
+ <string name="live_sports_search_leagues">Ligák keresése</string>
+ <string name="live_sports_leagues">Ligák</string>
+ <string name="live_sports_american_football">Amerikai futball</string>
+ <string name="live_sports_baseball">Baseball</string>
+ <string name="live_sports_hockey">Jégkorong</string>
+ <string name="live_sports_tennis">Tenisz</string>
+ <string name="live_sports_mma">Kevert harcművészetek</string>
+ <string name="live_sports_boxing">Ökölvívás</string>
+ <string name="live_sports_cricket">Krikett</string>
+ <string name="live_sports_rugby">Rögbi</string>
+ <string name="live_sports_golf">Golf</string>
+ <string name="live_sports_volleyball">Röplabda</string>
+ <string name="live_sports_handball">Kézilabda</string>
+ <string name="live_sports_snooker">Snooker</string>
+ <string name="live_sports_darts">Darts</string>
+ <string name="live_sports_cycling">Kerékpározás</string>
</resources>
diff --git a/feature/live/src/main/res/values-in/strings.xml b/feature/live/src/main/res/values-in/strings.xml
index c56a6410..23cfd9af 100644
--- a/feature/live/src/main/res/values-in/strings.xml
+++ b/feature/live/src/main/res/values-in/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Poin</string>
<string name="live_sports_football_data_attribution">Data sepak bola disediakan oleh %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Detail acara lainnya</string>
+ <string name="live_sports_extra_details_load">Muat detail</string>
+ <string name="live_sports_extra_details_loading">Memuat detail acara…</string>
+ <string name="live_sports_extra_details_unavailable">Detail acara tidak tersedia</string>
+ <string name="live_sports_statistics">Statistik</string>
+ <string name="live_sports_lineups">Susunan pemain</string>
+ <string name="live_sports_lineup_starter">Pemain inti</string>
+ <string name="live_sports_inclusions">Olahraga dan liga</string>
+ <string name="live_sports_inclusions_hint">Olahraga dan liga yang dicentang muncul di Olahraga.</string>
+ <string name="live_sports_search_events">Cari tim atau pertandingan</string>
+ <string name="live_sports_search_leagues">Cari liga</string>
+ <string name="live_sports_leagues">Liga</string>
+ <string name="live_sports_american_football">Sepak bola Amerika</string>
+ <string name="live_sports_baseball">Bisbol</string>
+ <string name="live_sports_hockey">Hoki es</string>
+ <string name="live_sports_tennis">Tenis</string>
+ <string name="live_sports_mma">Seni bela diri campuran</string>
+ <string name="live_sports_boxing">Tinju</string>
+ <string name="live_sports_cricket">Kriket</string>
+ <string name="live_sports_rugby">Rugbi</string>
+ <string name="live_sports_golf">Golf</string>
+ <string name="live_sports_volleyball">Bola voli</string>
+ <string name="live_sports_handball">Bola tangan</string>
+ <string name="live_sports_snooker">Snooker</string>
+ <string name="live_sports_darts">Dart</string>
+ <string name="live_sports_cycling">Balap sepeda</string>
</resources>
diff --git a/feature/live/src/main/res/values-it/strings.xml b/feature/live/src/main/res/values-it/strings.xml
index 14f16f12..099c503f 100644
--- a/feature/live/src/main/res/values-it/strings.xml
+++ b/feature/live/src/main/res/values-it/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Punti</string>
<string name="live_sports_football_data_attribution">Dati sul calcio forniti da %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Altri dettagli della partita</string>
+ <string name="live_sports_extra_details_load">Carica dettagli</string>
+ <string name="live_sports_extra_details_loading">Caricamento dettagli partita…</string>
+ <string name="live_sports_extra_details_unavailable">Dettagli partita non disponibili</string>
+ <string name="live_sports_statistics">Statistiche</string>
+ <string name="live_sports_lineups">Formazioni</string>
+ <string name="live_sports_lineup_starter">Titolare</string>
+ <string name="live_sports_inclusions">Sport e campionati</string>
+ <string name="live_sports_inclusions_hint">Gli sport e i campionati selezionati compaiono in Sport.</string>
+ <string name="live_sports_search_events">Cerca squadre o partite</string>
+ <string name="live_sports_search_leagues">Cerca campionati</string>
+ <string name="live_sports_leagues">Campionati</string>
+ <string name="live_sports_american_football">Football americano</string>
+ <string name="live_sports_baseball">Baseball</string>
+ <string name="live_sports_hockey">Hockey su ghiaccio</string>
+ <string name="live_sports_tennis">Tennis</string>
+ <string name="live_sports_mma">Arti marziali miste</string>
+ <string name="live_sports_boxing">Pugilato</string>
+ <string name="live_sports_cricket">Cricket</string>
+ <string name="live_sports_rugby">Rugby</string>
+ <string name="live_sports_golf">Golf</string>
+ <string name="live_sports_volleyball">Pallavolo</string>
+ <string name="live_sports_handball">Pallamano</string>
+ <string name="live_sports_snooker">Snooker</string>
+ <string name="live_sports_darts">Freccette</string>
+ <string name="live_sports_cycling">Ciclismo</string>
</resources>
diff --git a/feature/live/src/main/res/values-iw/strings.xml b/feature/live/src/main/res/values-iw/strings.xml
index 2d795162..206da788 100644
--- a/feature/live/src/main/res/values-iw/strings.xml
+++ b/feature/live/src/main/res/values-iw/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">נקודות</string>
<string name="live_sports_football_data_attribution">נתוני כדורגל מסופקים על ידי %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">פרטים נוספים על האירוע</string>
+ <string name="live_sports_extra_details_load">טען פרטים</string>
+ <string name="live_sports_extra_details_loading">טוען פרטי אירוע…</string>
+ <string name="live_sports_extra_details_unavailable">פרטי האירוע אינם זמינים</string>
+ <string name="live_sports_statistics">סטטיסטיקה</string>
+ <string name="live_sports_lineups">הרכבים</string>
+ <string name="live_sports_lineup_starter">שחקן פותח</string>
+ <string name="live_sports_inclusions">ענפי ספורט וליגות</string>
+ <string name="live_sports_inclusions_hint">ענפי הספורט והליגות המסומנים יופיעו בספורט.</string>
+ <string name="live_sports_search_events">חיפוש קבוצות או משחקים</string>
+ <string name="live_sports_search_leagues">חיפוש ליגות</string>
+ <string name="live_sports_leagues">ליגות</string>
+ <string name="live_sports_american_football">פוטבול אמריקאי</string>
+ <string name="live_sports_baseball">בייסבול</string>
+ <string name="live_sports_hockey">הוקי קרח</string>
+ <string name="live_sports_tennis">טניס</string>
+ <string name="live_sports_mma">אמנויות לחימה משולבות</string>
+ <string name="live_sports_boxing">אגרוף</string>
+ <string name="live_sports_cricket">קריקט</string>
+ <string name="live_sports_rugby">רוגבי</string>
+ <string name="live_sports_golf">גולף</string>
+ <string name="live_sports_volleyball">כדורעף</string>
+ <string name="live_sports_handball">כדוריד</string>
+ <string name="live_sports_snooker">סנוקר</string>
+ <string name="live_sports_darts">הטלת חצים</string>
+ <string name="live_sports_cycling">רכיבת אופניים</string>
</resources>
diff --git a/feature/live/src/main/res/values-ja/strings.xml b/feature/live/src/main/res/values-ja/strings.xml
index 360a8d3b..2561d0d0 100644
--- a/feature/live/src/main/res/values-ja/strings.xml
+++ b/feature/live/src/main/res/values-ja/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">勝点</string>
<string name="live_sports_football_data_attribution">サッカーデータ提供元: %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">イベントの追加情報</string>
+ <string name="live_sports_extra_details_load">詳細を読み込む</string>
+ <string name="live_sports_extra_details_loading">イベント情報を読み込み中…</string>
+ <string name="live_sports_extra_details_unavailable">イベント情報を利用できません</string>
+ <string name="live_sports_statistics">統計</string>
+ <string name="live_sports_lineups">ラインナップ</string>
+ <string name="live_sports_lineup_starter">先発</string>
+ <string name="live_sports_inclusions">競技とリーグ</string>
+ <string name="live_sports_inclusions_hint">選択した競技とリーグがスポーツに表示されます。</string>
+ <string name="live_sports_search_events">チームや試合を検索</string>
+ <string name="live_sports_search_leagues">リーグを検索</string>
+ <string name="live_sports_leagues">リーグ</string>
+ <string name="live_sports_american_football">アメリカンフットボール</string>
+ <string name="live_sports_baseball">野球</string>
+ <string name="live_sports_hockey">アイスホッケー</string>
+ <string name="live_sports_tennis">テニス</string>
+ <string name="live_sports_mma">総合格闘技</string>
+ <string name="live_sports_boxing">ボクシング</string>
+ <string name="live_sports_cricket">クリケット</string>
+ <string name="live_sports_rugby">ラグビー</string>
+ <string name="live_sports_golf">ゴルフ</string>
+ <string name="live_sports_volleyball">バレーボール</string>
+ <string name="live_sports_handball">ハンドボール</string>
+ <string name="live_sports_snooker">スヌーカー</string>
+ <string name="live_sports_darts">ダーツ</string>
+ <string name="live_sports_cycling">自転車競技</string>
</resources>
diff --git a/feature/live/src/main/res/values-ko/strings.xml b/feature/live/src/main/res/values-ko/strings.xml
index f67e29dc..85c8097f 100644
--- a/feature/live/src/main/res/values-ko/strings.xml
+++ b/feature/live/src/main/res/values-ko/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">승점</string>
<string name="live_sports_football_data_attribution">축구 데이터 제공: %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">추가 경기 정보</string>
+ <string name="live_sports_extra_details_load">정보 불러오기</string>
+ <string name="live_sports_extra_details_loading">경기 정보 불러오는 중…</string>
+ <string name="live_sports_extra_details_unavailable">경기 정보를 사용할 수 없습니다</string>
+ <string name="live_sports_statistics">통계</string>
+ <string name="live_sports_lineups">라인업</string>
+ <string name="live_sports_lineup_starter">선발</string>
+ <string name="live_sports_inclusions">종목 및 리그</string>
+ <string name="live_sports_inclusions_hint">선택한 종목과 리그가 스포츠에 표시됩니다.</string>
+ <string name="live_sports_search_events">팀 또는 경기 검색</string>
+ <string name="live_sports_search_leagues">리그 검색</string>
+ <string name="live_sports_leagues">리그</string>
+ <string name="live_sports_american_football">미식축구</string>
+ <string name="live_sports_baseball">야구</string>
+ <string name="live_sports_hockey">아이스하키</string>
+ <string name="live_sports_tennis">테니스</string>
+ <string name="live_sports_mma">종합격투기</string>
+ <string name="live_sports_boxing">복싱</string>
+ <string name="live_sports_cricket">크리켓</string>
+ <string name="live_sports_rugby">럭비</string>
+ <string name="live_sports_golf">골프</string>
+ <string name="live_sports_volleyball">배구</string>
+ <string name="live_sports_handball">핸드볼</string>
+ <string name="live_sports_snooker">스누커</string>
+ <string name="live_sports_darts">다트</string>
+ <string name="live_sports_cycling">사이클</string>
</resources>
diff --git a/feature/live/src/main/res/values-mk/strings.xml b/feature/live/src/main/res/values-mk/strings.xml
index 6d8e24e0..86cab13c 100644
--- a/feature/live/src/main/res/values-mk/strings.xml
+++ b/feature/live/src/main/res/values-mk/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Бодови</string>
<string name="live_sports_football_data_attribution">Фудбалски податоци обезбедува %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Дополнителни детали за настанот</string>
+ <string name="live_sports_extra_details_load">Вчитај детали</string>
+ <string name="live_sports_extra_details_loading">Се вчитуваат деталите за настанот…</string>
+ <string name="live_sports_extra_details_unavailable">Деталите за настанот не се достапни</string>
+ <string name="live_sports_statistics">Статистика</string>
+ <string name="live_sports_lineups">Постави</string>
+ <string name="live_sports_lineup_starter">Стартер</string>
+ <string name="live_sports_inclusions">Спортови и лиги</string>
+ <string name="live_sports_inclusions_hint">Означените спортови и лиги се прикажуваат во Спорт.</string>
+ <string name="live_sports_search_events">Пребарај тимови или натпревари</string>
+ <string name="live_sports_search_leagues">Пребарај лиги</string>
+ <string name="live_sports_leagues">Лиги</string>
+ <string name="live_sports_american_football">Американски фудбал</string>
+ <string name="live_sports_baseball">Бејзбол</string>
+ <string name="live_sports_hockey">Хокеј на мраз</string>
+ <string name="live_sports_tennis">Тенис</string>
+ <string name="live_sports_mma">Мешани боречки вештини</string>
+ <string name="live_sports_boxing">Бокс</string>
+ <string name="live_sports_cricket">Крикет</string>
+ <string name="live_sports_rugby">Рагби</string>
+ <string name="live_sports_golf">Голф</string>
+ <string name="live_sports_volleyball">Одбојка</string>
+ <string name="live_sports_handball">Ракомет</string>
+ <string name="live_sports_snooker">Снукер</string>
+ <string name="live_sports_darts">Пикадо</string>
+ <string name="live_sports_cycling">Велосипедизам</string>
</resources>
diff --git a/feature/live/src/main/res/values-ms/strings.xml b/feature/live/src/main/res/values-ms/strings.xml
index c4294cb7..7eed37d1 100644
--- a/feature/live/src/main/res/values-ms/strings.xml
+++ b/feature/live/src/main/res/values-ms/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Mata</string>
<string name="live_sports_football_data_attribution">Data bola sepak disediakan oleh %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Butiran acara tambahan</string>
+ <string name="live_sports_extra_details_load">Muatkan butiran</string>
+ <string name="live_sports_extra_details_loading">Memuatkan butiran acara…</string>
+ <string name="live_sports_extra_details_unavailable">Butiran acara tidak tersedia</string>
+ <string name="live_sports_statistics">Statistik</string>
+ <string name="live_sports_lineups">Barisan pemain</string>
+ <string name="live_sports_lineup_starter">Pemain utama</string>
+ <string name="live_sports_inclusions">Sukan dan liga</string>
+ <string name="live_sports_inclusions_hint">Sukan dan liga yang ditandakan dipaparkan dalam Sukan.</string>
+ <string name="live_sports_search_events">Cari pasukan atau perlawanan</string>
+ <string name="live_sports_search_leagues">Cari liga</string>
+ <string name="live_sports_leagues">Liga</string>
+ <string name="live_sports_american_football">Bola sepak Amerika</string>
+ <string name="live_sports_baseball">Besbol</string>
+ <string name="live_sports_hockey">Hoki ais</string>
+ <string name="live_sports_tennis">Tenis</string>
+ <string name="live_sports_mma">Seni bela diri campuran</string>
+ <string name="live_sports_boxing">Tinju</string>
+ <string name="live_sports_cricket">Kriket</string>
+ <string name="live_sports_rugby">Ragbi</string>
+ <string name="live_sports_golf">Golf</string>
+ <string name="live_sports_volleyball">Bola tampar</string>
+ <string name="live_sports_handball">Bola baling</string>
+ <string name="live_sports_snooker">Snuker</string>
+ <string name="live_sports_darts">Dart</string>
+ <string name="live_sports_cycling">Berbasikal</string>
</resources>
diff --git a/feature/live/src/main/res/values-nb/strings.xml b/feature/live/src/main/res/values-nb/strings.xml
index 1403e1d7..7e5befbc 100644
--- a/feature/live/src/main/res/values-nb/strings.xml
+++ b/feature/live/src/main/res/values-nb/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Poeng</string>
<string name="live_sports_football_data_attribution">Fotballdata levert av %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Flere kampdetaljer</string>
+ <string name="live_sports_extra_details_load">Last inn detaljer</string>
+ <string name="live_sports_extra_details_loading">Laster inn kampdetaljer…</string>
+ <string name="live_sports_extra_details_unavailable">Kampdetaljer er ikke tilgjengelige</string>
+ <string name="live_sports_statistics">Statistikk</string>
+ <string name="live_sports_lineups">Lagoppstillinger</string>
+ <string name="live_sports_lineup_starter">Starter</string>
+ <string name="live_sports_inclusions">Idretter og ligaer</string>
+ <string name="live_sports_inclusions_hint">Valgte idretter og ligaer vises under Sport.</string>
+ <string name="live_sports_search_events">Søk etter lag eller kamper</string>
+ <string name="live_sports_search_leagues">Søk etter ligaer</string>
+ <string name="live_sports_leagues">Ligaer</string>
+ <string name="live_sports_american_football">Amerikansk fotball</string>
+ <string name="live_sports_baseball">Baseball</string>
+ <string name="live_sports_hockey">Ishockey</string>
+ <string name="live_sports_tennis">Tennis</string>
+ <string name="live_sports_mma">Blandet kampsport</string>
+ <string name="live_sports_boxing">Boksing</string>
+ <string name="live_sports_cricket">Cricket</string>
+ <string name="live_sports_rugby">Rugby</string>
+ <string name="live_sports_golf">Golf</string>
+ <string name="live_sports_volleyball">Volleyball</string>
+ <string name="live_sports_handball">Håndball</string>
+ <string name="live_sports_snooker">Snooker</string>
+ <string name="live_sports_darts">Dart</string>
+ <string name="live_sports_cycling">Sykling</string>
</resources>
diff --git a/feature/live/src/main/res/values-nl/strings.xml b/feature/live/src/main/res/values-nl/strings.xml
index c34b6324..fcc3f504 100644
--- a/feature/live/src/main/res/values-nl/strings.xml
+++ b/feature/live/src/main/res/values-nl/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Punten</string>
<string name="live_sports_football_data_attribution">Voetbalgegevens geleverd door %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Meer evenementdetails</string>
+ <string name="live_sports_extra_details_load">Details laden</string>
+ <string name="live_sports_extra_details_loading">Evenementdetails laden…</string>
+ <string name="live_sports_extra_details_unavailable">Evenementdetails niet beschikbaar</string>
+ <string name="live_sports_statistics">Statistieken</string>
+ <string name="live_sports_lineups">Opstellingen</string>
+ <string name="live_sports_lineup_starter">Basisspeler</string>
+ <string name="live_sports_inclusions">Sporten en competities</string>
+ <string name="live_sports_inclusions_hint">Aangevinkte sporten en competities verschijnen onder Sport.</string>
+ <string name="live_sports_search_events">Teams of wedstrijden zoeken</string>
+ <string name="live_sports_search_leagues">Competities zoeken</string>
+ <string name="live_sports_leagues">Competities</string>
+ <string name="live_sports_american_football">American football</string>
+ <string name="live_sports_baseball">Honkbal</string>
+ <string name="live_sports_hockey">IJshockey</string>
+ <string name="live_sports_tennis">Tennis</string>
+ <string name="live_sports_mma">Gemengde vechtsporten</string>
+ <string name="live_sports_boxing">Boksen</string>
+ <string name="live_sports_cricket">Cricket</string>
+ <string name="live_sports_rugby">Rugby</string>
+ <string name="live_sports_golf">Golf</string>
+ <string name="live_sports_volleyball">Volleybal</string>
+ <string name="live_sports_handball">Handbal</string>
+ <string name="live_sports_snooker">Snooker</string>
+ <string name="live_sports_darts">Darts</string>
+ <string name="live_sports_cycling">Wielrennen</string>
</resources>
diff --git a/feature/live/src/main/res/values-pl/strings.xml b/feature/live/src/main/res/values-pl/strings.xml
index af9bfc4a..752117ba 100644
--- a/feature/live/src/main/res/values-pl/strings.xml
+++ b/feature/live/src/main/res/values-pl/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Punkty</string>
<string name="live_sports_football_data_attribution">Dane piłkarskie udostępnia %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Więcej informacji o wydarzeniu</string>
+ <string name="live_sports_extra_details_load">Wczytaj szczegóły</string>
+ <string name="live_sports_extra_details_loading">Wczytywanie szczegółów wydarzenia…</string>
+ <string name="live_sports_extra_details_unavailable">Szczegóły wydarzenia są niedostępne</string>
+ <string name="live_sports_statistics">Statystyki</string>
+ <string name="live_sports_lineups">Składy</string>
+ <string name="live_sports_lineup_starter">Zawodnik w pierwszym składzie</string>
+ <string name="live_sports_inclusions">Sporty i ligi</string>
+ <string name="live_sports_inclusions_hint">Zaznaczone sporty i ligi pojawiają się w sekcji Sport.</string>
+ <string name="live_sports_search_events">Szukaj drużyn lub meczów</string>
+ <string name="live_sports_search_leagues">Szukaj lig</string>
+ <string name="live_sports_leagues">Ligi</string>
+ <string name="live_sports_american_football">Futbol amerykański</string>
+ <string name="live_sports_baseball">Baseball</string>
+ <string name="live_sports_hockey">Hokej na lodzie</string>
+ <string name="live_sports_tennis">Tenis</string>
+ <string name="live_sports_mma">Mieszane sztuki walki</string>
+ <string name="live_sports_boxing">Boks</string>
+ <string name="live_sports_cricket">Krykiet</string>
+ <string name="live_sports_rugby">Rugby</string>
+ <string name="live_sports_golf">Golf</string>
+ <string name="live_sports_volleyball">Siatkówka</string>
+ <string name="live_sports_handball">Piłka ręczna</string>
+ <string name="live_sports_snooker">Snooker</string>
+ <string name="live_sports_darts">Dart</string>
+ <string name="live_sports_cycling">Kolarstwo</string>
</resources>
diff --git a/feature/live/src/main/res/values-pt/strings.xml b/feature/live/src/main/res/values-pt/strings.xml
index 455a6eca..0848f78e 100644
--- a/feature/live/src/main/res/values-pt/strings.xml
+++ b/feature/live/src/main/res/values-pt/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Pontos</string>
<string name="live_sports_football_data_attribution">Dados de futebol fornecidos por %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Mais detalhes do evento</string>
+ <string name="live_sports_extra_details_load">Carregar detalhes</string>
+ <string name="live_sports_extra_details_loading">Carregando detalhes do evento…</string>
+ <string name="live_sports_extra_details_unavailable">Detalhes do evento indisponíveis</string>
+ <string name="live_sports_statistics">Estatísticas</string>
+ <string name="live_sports_lineups">Escalações</string>
+ <string name="live_sports_lineup_starter">Titular</string>
+ <string name="live_sports_inclusions">Desportos e ligas</string>
+ <string name="live_sports_inclusions_hint">Os desportos e ligas assinalados aparecem em Desporto.</string>
+ <string name="live_sports_search_events">Pesquisar equipas ou jogos</string>
+ <string name="live_sports_search_leagues">Pesquisar ligas</string>
+ <string name="live_sports_leagues">Ligas</string>
+ <string name="live_sports_american_football">Futebol americano</string>
+ <string name="live_sports_baseball">Basebol</string>
+ <string name="live_sports_hockey">Hóquei no gelo</string>
+ <string name="live_sports_tennis">Ténis</string>
+ <string name="live_sports_mma">Artes marciais mistas</string>
+ <string name="live_sports_boxing">Boxe</string>
+ <string name="live_sports_cricket">Críquete</string>
+ <string name="live_sports_rugby">Râguebi</string>
+ <string name="live_sports_golf">Golfe</string>
+ <string name="live_sports_volleyball">Voleibol</string>
+ <string name="live_sports_handball">Andebol</string>
+ <string name="live_sports_snooker">Snooker</string>
+ <string name="live_sports_darts">Dardos</string>
+ <string name="live_sports_cycling">Ciclismo</string>
</resources>
diff --git a/feature/live/src/main/res/values-ro/strings.xml b/feature/live/src/main/res/values-ro/strings.xml
index fefb771e..91b70b12 100644
--- a/feature/live/src/main/res/values-ro/strings.xml
+++ b/feature/live/src/main/res/values-ro/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Puncte</string>
<string name="live_sports_football_data_attribution">Datele despre fotbal sunt furnizate de %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Mai multe detalii despre eveniment</string>
+ <string name="live_sports_extra_details_load">Încarcă detaliile</string>
+ <string name="live_sports_extra_details_loading">Se încarcă detaliile evenimentului…</string>
+ <string name="live_sports_extra_details_unavailable">Detaliile evenimentului nu sunt disponibile</string>
+ <string name="live_sports_statistics">Statistici</string>
+ <string name="live_sports_lineups">Echipe</string>
+ <string name="live_sports_lineup_starter">Titular</string>
+ <string name="live_sports_inclusions">Sporturi și ligi</string>
+ <string name="live_sports_inclusions_hint">Sporturile și ligile bifate apar în Sport.</string>
+ <string name="live_sports_search_events">Caută echipe sau meciuri</string>
+ <string name="live_sports_search_leagues">Caută ligi</string>
+ <string name="live_sports_leagues">Ligi</string>
+ <string name="live_sports_american_football">Fotbal american</string>
+ <string name="live_sports_baseball">Baseball</string>
+ <string name="live_sports_hockey">Hochei pe gheață</string>
+ <string name="live_sports_tennis">Tenis</string>
+ <string name="live_sports_mma">Arte marțiale mixte</string>
+ <string name="live_sports_boxing">Box</string>
+ <string name="live_sports_cricket">Crichet</string>
+ <string name="live_sports_rugby">Rugbi</string>
+ <string name="live_sports_golf">Golf</string>
+ <string name="live_sports_volleyball">Volei</string>
+ <string name="live_sports_handball">Handbal</string>
+ <string name="live_sports_snooker">Snooker</string>
+ <string name="live_sports_darts">Darts</string>
+ <string name="live_sports_cycling">Ciclism</string>
</resources>
diff --git a/feature/live/src/main/res/values-ru/strings.xml b/feature/live/src/main/res/values-ru/strings.xml
index 0bbfeba0..8dcbb2a6 100644
--- a/feature/live/src/main/res/values-ru/strings.xml
+++ b/feature/live/src/main/res/values-ru/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Очки</string>
<string name="live_sports_football_data_attribution">Футбольные данные предоставляет %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Дополнительные сведения о событии</string>
+ <string name="live_sports_extra_details_load">Загрузить сведения</string>
+ <string name="live_sports_extra_details_loading">Загрузка сведений о событии…</string>
+ <string name="live_sports_extra_details_unavailable">Сведения о событии недоступны</string>
+ <string name="live_sports_statistics">Статистика</string>
+ <string name="live_sports_lineups">Составы</string>
+ <string name="live_sports_lineup_starter">В стартовом составе</string>
+ <string name="live_sports_inclusions">Виды спорта и лиги</string>
+ <string name="live_sports_inclusions_hint">Отмеченные виды спорта и лиги отображаются в Спорте.</string>
+ <string name="live_sports_search_events">Поиск команд или матчей</string>
+ <string name="live_sports_search_leagues">Поиск лиг</string>
+ <string name="live_sports_leagues">Лиги</string>
+ <string name="live_sports_american_football">Американский футбол</string>
+ <string name="live_sports_baseball">Бейсбол</string>
+ <string name="live_sports_hockey">Хоккей с шайбой</string>
+ <string name="live_sports_tennis">Теннис</string>
+ <string name="live_sports_mma">Смешанные боевые искусства</string>
+ <string name="live_sports_boxing">Бокс</string>
+ <string name="live_sports_cricket">Крикет</string>
+ <string name="live_sports_rugby">Регби</string>
+ <string name="live_sports_golf">Гольф</string>
+ <string name="live_sports_volleyball">Волейбол</string>
+ <string name="live_sports_handball">Гандбол</string>
+ <string name="live_sports_snooker">Снукер</string>
+ <string name="live_sports_darts">Дартс</string>
+ <string name="live_sports_cycling">Велоспорт</string>
</resources>
diff --git a/feature/live/src/main/res/values-sk/strings.xml b/feature/live/src/main/res/values-sk/strings.xml
index 87a743f7..46fdcddc 100644
--- a/feature/live/src/main/res/values-sk/strings.xml
+++ b/feature/live/src/main/res/values-sk/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Body</string>
<string name="live_sports_football_data_attribution">Futbalové údaje poskytuje %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Ďalšie podrobnosti o udalosti</string>
+ <string name="live_sports_extra_details_load">Načítať podrobnosti</string>
+ <string name="live_sports_extra_details_loading">Načítavajú sa podrobnosti o udalosti…</string>
+ <string name="live_sports_extra_details_unavailable">Podrobnosti o udalosti nie sú dostupné</string>
+ <string name="live_sports_statistics">Štatistiky</string>
+ <string name="live_sports_lineups">Zostavy</string>
+ <string name="live_sports_lineup_starter">V základnej zostave</string>
+ <string name="live_sports_inclusions">Športy a ligy</string>
+ <string name="live_sports_inclusions_hint">Označené športy a ligy sa zobrazujú v sekcii Šport.</string>
+ <string name="live_sports_search_events">Hľadať tímy alebo zápasy</string>
+ <string name="live_sports_search_leagues">Hľadať ligy</string>
+ <string name="live_sports_leagues">Ligy</string>
+ <string name="live_sports_american_football">Americký futbal</string>
+ <string name="live_sports_baseball">Bejzbal</string>
+ <string name="live_sports_hockey">Ľadový hokej</string>
+ <string name="live_sports_tennis">Tenis</string>
+ <string name="live_sports_mma">Zmiešané bojové umenia</string>
+ <string name="live_sports_boxing">Box</string>
+ <string name="live_sports_cricket">Kriket</string>
+ <string name="live_sports_rugby">Ragby</string>
+ <string name="live_sports_golf">Golf</string>
+ <string name="live_sports_volleyball">Volejbal</string>
+ <string name="live_sports_handball">Hádzaná</string>
+ <string name="live_sports_snooker">Snooker</string>
+ <string name="live_sports_darts">Šípky</string>
+ <string name="live_sports_cycling">Cyklistika</string>
</resources>
diff --git a/feature/live/src/main/res/values-sq/strings.xml b/feature/live/src/main/res/values-sq/strings.xml
index 019a5f4f..c26e257a 100644
--- a/feature/live/src/main/res/values-sq/strings.xml
+++ b/feature/live/src/main/res/values-sq/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Pikë</string>
<string name="live_sports_football_data_attribution">Të dhënat e futbollit ofrohen nga %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Detaje shtesë të ndeshjes</string>
+ <string name="live_sports_extra_details_load">Ngarko detajet</string>
+ <string name="live_sports_extra_details_loading">Po ngarkohen detajet e ndeshjes…</string>
+ <string name="live_sports_extra_details_unavailable">Detajet e ndeshjes nuk janë të disponueshme</string>
+ <string name="live_sports_statistics">Statistika</string>
+ <string name="live_sports_lineups">Formacionet</string>
+ <string name="live_sports_lineup_starter">Titullar</string>
+ <string name="live_sports_inclusions">Sportet dhe ligat</string>
+ <string name="live_sports_inclusions_hint">Sportet dhe ligat e shënuara shfaqen te Sporti.</string>
+ <string name="live_sports_search_events">Kërko ekipe ose ndeshje</string>
+ <string name="live_sports_search_leagues">Kërko liga</string>
+ <string name="live_sports_leagues">Ligat</string>
+ <string name="live_sports_american_football">Futboll amerikan</string>
+ <string name="live_sports_baseball">Bejsboll</string>
+ <string name="live_sports_hockey">Hokej në akull</string>
+ <string name="live_sports_tennis">Tenis</string>
+ <string name="live_sports_mma">Arte marciale të përziera</string>
+ <string name="live_sports_boxing">Boks</string>
+ <string name="live_sports_cricket">Kriket</string>
+ <string name="live_sports_rugby">Regbi</string>
+ <string name="live_sports_golf">Golf</string>
+ <string name="live_sports_volleyball">Volejboll</string>
+ <string name="live_sports_handball">Hendboll</string>
+ <string name="live_sports_snooker">Snuker</string>
+ <string name="live_sports_darts">Hedhje shigjetash</string>
+ <string name="live_sports_cycling">Çiklizëm</string>
</resources>
diff --git a/feature/live/src/main/res/values-sr/strings.xml b/feature/live/src/main/res/values-sr/strings.xml
index 11819e9d..8f12a453 100644
--- a/feature/live/src/main/res/values-sr/strings.xml
+++ b/feature/live/src/main/res/values-sr/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Бодови</string>
<string name="live_sports_football_data_attribution">Фудбалске податке пружа %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Додатни детаљи догађаја</string>
+ <string name="live_sports_extra_details_load">Учитај детаље</string>
+ <string name="live_sports_extra_details_loading">Учитавање детаља догађаја…</string>
+ <string name="live_sports_extra_details_unavailable">Детаљи догађаја нису доступни</string>
+ <string name="live_sports_statistics">Статистика</string>
+ <string name="live_sports_lineups">Поставе</string>
+ <string name="live_sports_lineup_starter">Стартер</string>
+ <string name="live_sports_inclusions">Спортови и лиге</string>
+ <string name="live_sports_inclusions_hint">Означени спортови и лиге приказују се у Спорту.</string>
+ <string name="live_sports_search_events">Претражи тимове или утакмице</string>
+ <string name="live_sports_search_leagues">Претражи лиге</string>
+ <string name="live_sports_leagues">Лиге</string>
+ <string name="live_sports_american_football">Амерички фудбал</string>
+ <string name="live_sports_baseball">Бејзбол</string>
+ <string name="live_sports_hockey">Хокеј на леду</string>
+ <string name="live_sports_tennis">Тенис</string>
+ <string name="live_sports_mma">Мешовите борилачке вештине</string>
+ <string name="live_sports_boxing">Бокс</string>
+ <string name="live_sports_cricket">Крикет</string>
+ <string name="live_sports_rugby">Рагби</string>
+ <string name="live_sports_golf">Голф</string>
+ <string name="live_sports_volleyball">Одбојка</string>
+ <string name="live_sports_handball">Рукомет</string>
+ <string name="live_sports_snooker">Снукер</string>
+ <string name="live_sports_darts">Пикадо</string>
+ <string name="live_sports_cycling">Бициклизам</string>
</resources>
diff --git a/feature/live/src/main/res/values-sv/strings.xml b/feature/live/src/main/res/values-sv/strings.xml
index 973f2e91..303e5692 100644
--- a/feature/live/src/main/res/values-sv/strings.xml
+++ b/feature/live/src/main/res/values-sv/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Poäng</string>
<string name="live_sports_football_data_attribution">Fotbollsdata tillhandahålls av %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Fler matchdetaljer</string>
+ <string name="live_sports_extra_details_load">Läs in detaljer</string>
+ <string name="live_sports_extra_details_loading">Läser in matchdetaljer…</string>
+ <string name="live_sports_extra_details_unavailable">Matchdetaljer är inte tillgängliga</string>
+ <string name="live_sports_statistics">Statistik</string>
+ <string name="live_sports_lineups">Laguppställningar</string>
+ <string name="live_sports_lineup_starter">Startspelare</string>
+ <string name="live_sports_inclusions">Sporter och ligor</string>
+ <string name="live_sports_inclusions_hint">Markerade sporter och ligor visas under Sport.</string>
+ <string name="live_sports_search_events">Sök efter lag eller matcher</string>
+ <string name="live_sports_search_leagues">Sök efter ligor</string>
+ <string name="live_sports_leagues">Ligor</string>
+ <string name="live_sports_american_football">Amerikansk fotboll</string>
+ <string name="live_sports_baseball">Baseboll</string>
+ <string name="live_sports_hockey">Ishockey</string>
+ <string name="live_sports_tennis">Tennis</string>
+ <string name="live_sports_mma">Blandad kampsport</string>
+ <string name="live_sports_boxing">Boxning</string>
+ <string name="live_sports_cricket">Cricket</string>
+ <string name="live_sports_rugby">Rugby</string>
+ <string name="live_sports_golf">Golf</string>
+ <string name="live_sports_volleyball">Volleyboll</string>
+ <string name="live_sports_handball">Handboll</string>
+ <string name="live_sports_snooker">Snooker</string>
+ <string name="live_sports_darts">Dart</string>
+ <string name="live_sports_cycling">Cykling</string>
</resources>
diff --git a/feature/live/src/main/res/values-th/strings.xml b/feature/live/src/main/res/values-th/strings.xml
index 92f5d617..bff5002b 100644
--- a/feature/live/src/main/res/values-th/strings.xml
+++ b/feature/live/src/main/res/values-th/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">คะแนน</string>
<string name="live_sports_football_data_attribution">ข้อมูลฟุตบอลจัดทำโดย %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">รายละเอียดการแข่งขันเพิ่มเติม</string>
+ <string name="live_sports_extra_details_load">โหลดรายละเอียด</string>
+ <string name="live_sports_extra_details_loading">กำลังโหลดรายละเอียดการแข่งขัน…</string>
+ <string name="live_sports_extra_details_unavailable">ไม่มีรายละเอียดการแข่งขัน</string>
+ <string name="live_sports_statistics">สถิติ</string>
+ <string name="live_sports_lineups">รายชื่อผู้เล่น</string>
+ <string name="live_sports_lineup_starter">ผู้เล่นตัวจริง</string>
+ <string name="live_sports_inclusions">กีฬาและลีก</string>
+ <string name="live_sports_inclusions_hint">กีฬาและลีกที่เลือกจะแสดงในหน้า กีฬา</string>
+ <string name="live_sports_search_events">ค้นหาทีมหรือการแข่งขัน</string>
+ <string name="live_sports_search_leagues">ค้นหาลีก</string>
+ <string name="live_sports_leagues">ลีก</string>
+ <string name="live_sports_american_football">อเมริกันฟุตบอล</string>
+ <string name="live_sports_baseball">เบสบอล</string>
+ <string name="live_sports_hockey">ฮอกกี้น้ำแข็ง</string>
+ <string name="live_sports_tennis">เทนนิส</string>
+ <string name="live_sports_mma">ศิลปะการต่อสู้แบบผสม</string>
+ <string name="live_sports_boxing">มวยสากล</string>
+ <string name="live_sports_cricket">คริกเก็ต</string>
+ <string name="live_sports_rugby">รักบี้</string>
+ <string name="live_sports_golf">กอล์ฟ</string>
+ <string name="live_sports_volleyball">วอลเลย์บอล</string>
+ <string name="live_sports_handball">แฮนด์บอล</string>
+ <string name="live_sports_snooker">สนุกเกอร์</string>
+ <string name="live_sports_darts">ปาเป้า</string>
+ <string name="live_sports_cycling">จักรยาน</string>
</resources>
diff --git a/feature/live/src/main/res/values-tr/strings.xml b/feature/live/src/main/res/values-tr/strings.xml
index 45a9b32f..51511700 100644
--- a/feature/live/src/main/res/values-tr/strings.xml
+++ b/feature/live/src/main/res/values-tr/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Puan</string>
<string name="live_sports_football_data_attribution">Futbol verileri %1$s tarafından sağlanır</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Etkinlik ayrıntıları</string>
+ <string name="live_sports_extra_details_load">Ayrıntıları yükle</string>
+ <string name="live_sports_extra_details_loading">Etkinlik ayrıntıları yükleniyor…</string>
+ <string name="live_sports_extra_details_unavailable">Etkinlik ayrıntıları kullanılamıyor</string>
+ <string name="live_sports_statistics">İstatistikler</string>
+ <string name="live_sports_lineups">Kadro</string>
+ <string name="live_sports_lineup_starter">İlk 11 oyuncusu</string>
+ <string name="live_sports_inclusions">Sporlar ve ligler</string>
+ <string name="live_sports_inclusions_hint">İşaretli sporlar ve ligler Spor bölümünde görünür.</string>
+ <string name="live_sports_search_events">Takım veya maç ara</string>
+ <string name="live_sports_search_leagues">Lig ara</string>
+ <string name="live_sports_leagues">Ligler</string>
+ <string name="live_sports_american_football">Amerikan futbolu</string>
+ <string name="live_sports_baseball">Beyzbol</string>
+ <string name="live_sports_hockey">Buz hokeyi</string>
+ <string name="live_sports_tennis">Tenis</string>
+ <string name="live_sports_mma">Karma dövüş sanatları</string>
+ <string name="live_sports_boxing">Boks</string>
+ <string name="live_sports_cricket">Kriket</string>
+ <string name="live_sports_rugby">Ragbi</string>
+ <string name="live_sports_golf">Golf</string>
+ <string name="live_sports_volleyball">Voleybol</string>
+ <string name="live_sports_handball">Hentbol</string>
+ <string name="live_sports_snooker">Snooker</string>
+ <string name="live_sports_darts">Dart</string>
+ <string name="live_sports_cycling">Bisiklet</string>
</resources>
diff --git a/feature/live/src/main/res/values-uk/strings.xml b/feature/live/src/main/res/values-uk/strings.xml
index 3b37936e..2bf1f9a2 100644
--- a/feature/live/src/main/res/values-uk/strings.xml
+++ b/feature/live/src/main/res/values-uk/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Очки</string>
<string name="live_sports_football_data_attribution">Футбольні дані надає %1$s</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Додаткові відомості про подію</string>
+ <string name="live_sports_extra_details_load">Завантажити відомості</string>
+ <string name="live_sports_extra_details_loading">Завантаження відомостей про подію…</string>
+ <string name="live_sports_extra_details_unavailable">Відомості про подію недоступні</string>
+ <string name="live_sports_statistics">Статистика</string>
+ <string name="live_sports_lineups">Склади</string>
+ <string name="live_sports_lineup_starter">У стартовому складі</string>
+ <string name="live_sports_inclusions">Види спорту та ліги</string>
+ <string name="live_sports_inclusions_hint">Позначені види спорту та ліги відображаються у Спорті.</string>
+ <string name="live_sports_search_events">Пошук команд або матчів</string>
+ <string name="live_sports_search_leagues">Пошук ліг</string>
+ <string name="live_sports_leagues">Ліги</string>
+ <string name="live_sports_american_football">Американський футбол</string>
+ <string name="live_sports_baseball">Бейсбол</string>
+ <string name="live_sports_hockey">Хокей із шайбою</string>
+ <string name="live_sports_tennis">Теніс</string>
+ <string name="live_sports_mma">Змішані бойові мистецтва</string>
+ <string name="live_sports_boxing">Бокс</string>
+ <string name="live_sports_cricket">Крикет</string>
+ <string name="live_sports_rugby">Регбі</string>
+ <string name="live_sports_golf">Гольф</string>
+ <string name="live_sports_volleyball">Волейбол</string>
+ <string name="live_sports_handball">Гандбол</string>
+ <string name="live_sports_snooker">Снукер</string>
+ <string name="live_sports_darts">Дартс</string>
+ <string name="live_sports_cycling">Велоспорт</string>
</resources>
diff --git a/feature/live/src/main/res/values-vi/strings.xml b/feature/live/src/main/res/values-vi/strings.xml
index 23b610cd..03881aa3 100644
--- a/feature/live/src/main/res/values-vi/strings.xml
+++ b/feature/live/src/main/res/values-vi/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">Điểm</string>
<string name="live_sports_football_data_attribution">Dữ liệu bóng đá do %1$s cung cấp</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Thông tin sự kiện bổ sung</string>
+ <string name="live_sports_extra_details_load">Tải thông tin</string>
+ <string name="live_sports_extra_details_loading">Đang tải thông tin sự kiện…</string>
+ <string name="live_sports_extra_details_unavailable">Không có thông tin sự kiện</string>
+ <string name="live_sports_statistics">Thống kê</string>
+ <string name="live_sports_lineups">Đội hình</string>
+ <string name="live_sports_lineup_starter">Đá chính</string>
+ <string name="live_sports_inclusions">Môn thể thao và giải đấu</string>
+ <string name="live_sports_inclusions_hint">Các môn thể thao và giải đấu được chọn sẽ hiện trong Thể thao.</string>
+ <string name="live_sports_search_events">Tìm đội hoặc trận đấu</string>
+ <string name="live_sports_search_leagues">Tìm giải đấu</string>
+ <string name="live_sports_leagues">Giải đấu</string>
+ <string name="live_sports_american_football">Bóng bầu dục Mỹ</string>
+ <string name="live_sports_baseball">Bóng chày</string>
+ <string name="live_sports_hockey">Khúc côn cầu trên băng</string>
+ <string name="live_sports_tennis">Quần vợt</string>
+ <string name="live_sports_mma">Võ tổng hợp</string>
+ <string name="live_sports_boxing">Quyền Anh</string>
+ <string name="live_sports_cricket">Cricket</string>
+ <string name="live_sports_rugby">Bóng bầu dục</string>
+ <string name="live_sports_golf">Gôn</string>
+ <string name="live_sports_volleyball">Bóng chuyền</string>
+ <string name="live_sports_handball">Bóng ném</string>
+ <string name="live_sports_snooker">Snooker</string>
+ <string name="live_sports_darts">Phi tiêu</string>
+ <string name="live_sports_cycling">Đua xe đạp</string>
</resources>
diff --git a/feature/live/src/main/res/values-zh-rTW/strings.xml b/feature/live/src/main/res/values-zh-rTW/strings.xml
index b9474827..b44a81b1 100644
--- a/feature/live/src/main/res/values-zh-rTW/strings.xml
+++ b/feature/live/src/main/res/values-zh-rTW/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">積分</string>
<string name="live_sports_football_data_attribution">足球資料由 %1$s 提供</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">更多賽事詳細資料</string>
+ <string name="live_sports_extra_details_load">載入詳細資料</string>
+ <string name="live_sports_extra_details_loading">正在載入賽事詳細資料…</string>
+ <string name="live_sports_extra_details_unavailable">賽事詳細資料無法使用</string>
+ <string name="live_sports_statistics">統計資料</string>
+ <string name="live_sports_lineups">陣容</string>
+ <string name="live_sports_lineup_starter">先發球員</string>
+ <string name="live_sports_inclusions">運動與聯賽</string>
+ <string name="live_sports_inclusions_hint">勾選的運動與聯賽會顯示在體育頁面中。</string>
+ <string name="live_sports_search_events">搜尋球隊或比賽</string>
+ <string name="live_sports_search_leagues">搜尋聯賽</string>
+ <string name="live_sports_leagues">聯賽</string>
+ <string name="live_sports_american_football">美式足球</string>
+ <string name="live_sports_baseball">棒球</string>
+ <string name="live_sports_hockey">冰球</string>
+ <string name="live_sports_tennis">網球</string>
+ <string name="live_sports_mma">綜合格鬥</string>
+ <string name="live_sports_boxing">拳擊</string>
+ <string name="live_sports_cricket">板球</string>
+ <string name="live_sports_rugby">橄欖球</string>
+ <string name="live_sports_golf">高爾夫</string>
+ <string name="live_sports_volleyball">排球</string>
+ <string name="live_sports_handball">手球</string>
+ <string name="live_sports_snooker">司諾克</string>
+ <string name="live_sports_darts">飛鏢</string>
+ <string name="live_sports_cycling">自由車</string>
</resources>
diff --git a/feature/live/src/main/res/values-zh/strings.xml b/feature/live/src/main/res/values-zh/strings.xml
index ee612e04..38f3e33d 100644
--- a/feature/live/src/main/res/values-zh/strings.xml
+++ b/feature/live/src/main/res/values-zh/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_points">积分</string>
<string name="live_sports_football_data_attribution">足球数据由 %1$s 提供</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">更多赛事详情</string>
+ <string name="live_sports_extra_details_load">加载详情</string>
+ <string name="live_sports_extra_details_loading">正在加载赛事详情…</string>
+ <string name="live_sports_extra_details_unavailable">赛事详情不可用</string>
+ <string name="live_sports_statistics">统计数据</string>
+ <string name="live_sports_lineups">阵容</string>
+ <string name="live_sports_lineup_starter">首发球员</string>
+ <string name="live_sports_inclusions">运动和联赛</string>
+ <string name="live_sports_inclusions_hint">勾选的运动和联赛会显示在体育页面中。</string>
+ <string name="live_sports_search_events">搜索球队或比赛</string>
+ <string name="live_sports_search_leagues">搜索联赛</string>
+ <string name="live_sports_leagues">联赛</string>
+ <string name="live_sports_american_football">美式橄榄球</string>
+ <string name="live_sports_baseball">棒球</string>
+ <string name="live_sports_hockey">冰球</string>
+ <string name="live_sports_tennis">网球</string>
+ <string name="live_sports_mma">综合格斗</string>
+ <string name="live_sports_boxing">拳击</string>
+ <string name="live_sports_cricket">板球</string>
+ <string name="live_sports_rugby">橄榄球</string>
+ <string name="live_sports_golf">高尔夫</string>
+ <string name="live_sports_volleyball">排球</string>
+ <string name="live_sports_handball">手球</string>
+ <string name="live_sports_snooker">斯诺克</string>
+ <string name="live_sports_darts">飞镖</string>
+ <string name="live_sports_cycling">自行车</string>
</resources>
diff --git a/feature/live/src/main/res/values/strings.xml b/feature/live/src/main/res/values/strings.xml
index 5cab5460..93068978 100644
--- a/feature/live/src/main/res/values/strings.xml
+++ b/feature/live/src/main/res/values/strings.xml
@@ -287,4 +287,30 @@
<string name="live_sports_table_goal_difference">Goal difference</string>
<string name="live_sports_table_points">Points</string>
<string name="live_sports_odbl_license_name">ODbL 1.0</string>
+ <string name="live_sports_extra_details">Additional event details</string>
+ <string name="live_sports_extra_details_load">Load details</string>
+ <string name="live_sports_extra_details_loading">Loading event details…</string>
+ <string name="live_sports_extra_details_unavailable">Event details unavailable</string>
+ <string name="live_sports_statistics">Statistics</string>
+ <string name="live_sports_lineups">Lineups</string>
+ <string name="live_sports_lineup_starter">Starter</string>
+ <string name="live_sports_inclusions">Sports and leagues</string>
+ <string name="live_sports_inclusions_hint">Checked sports and leagues appear in Sports.</string>
+ <string name="live_sports_search_events">Search teams or games</string>
+ <string name="live_sports_search_leagues">Search leagues</string>
+ <string name="live_sports_leagues">Leagues</string>
+ <string name="live_sports_american_football">American football</string>
+ <string name="live_sports_baseball">Baseball</string>
+ <string name="live_sports_hockey">Ice hockey</string>
+ <string name="live_sports_tennis">Tennis</string>
+ <string name="live_sports_mma">Mixed martial arts</string>
+ <string name="live_sports_boxing">Boxing</string>
+ <string name="live_sports_cricket">Cricket</string>
+ <string name="live_sports_rugby">Rugby</string>
+ <string name="live_sports_golf">Golf</string>
+ <string name="live_sports_volleyball">Volleyball</string>
+ <string name="live_sports_handball">Handball</string>
+ <string name="live_sports_snooker">Snooker</string>
+ <string name="live_sports_darts">Darts</string>
+ <string name="live_sports_cycling">Cycling</string>
</resources>
diff --git a/feature/live/src/test/java/com/streamvault/feature/live/sports/SportsDiscoveryPresentationTest.kt b/feature/live/src/test/java/com/streamvault/feature/live/sports/SportsDiscoveryPresentationTest.kt
new file mode 100644
index 00000000..013ff7eb
--- /dev/null
+++ b/feature/live/src/test/java/com/streamvault/feature/live/sports/SportsDiscoveryPresentationTest.kt
@@ -0,0 +1,57 @@
+package com.streamvault.feature.live.sports
+
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.domain.sports.provider.*
+import java.time.Instant
+import org.junit.Test
+
+class SportsDiscoveryPresentationTest {
+ private val now = Instant.parse("2026-10-17T20:00:00Z")
+ private val source = SportsSourceRef.Provider("account", "custom-json", "game")
+ private val event = SportsEvent(
+ id = "game", title = "Atlanta Dream at Golden State Valkyries", league = "WNBA", categoryLabel = null,
+ description = "", sport = SportType.BASKETBALL, startTime = now.minusSeconds(1800).toEpochMilli(),
+ endTime = now.plusSeconds(3600).toEpochMilli(), broadcasts = emptyList(), confidence = 1f,
+ competitors = listOf(SportsCompetitor("Atlanta Dream"), SportsCompetitor("Golden State Valkyries")),
+ session = null, eventType = SportsEventType.LIVE_EVENT, rawProgrammeRefs = emptyList(),
+ )
+ private val scored = event.copy(
+ competitors = event.competitors.map { it.copy(logoUrl = "https://images.example/${it.canonicalName.replace(' ', '-')}.png") },
+ provenance = event.provenance.copy(score = SourcedValue(
+ ProviderScore("game", listOf(ProviderCompetitorScore(ProviderCompetitor("Atlanta Dream"), "39"))),
+ source, updatedAt = now.minusSeconds(60),
+ )),
+ )
+
+ @Test fun `partial refresh retains recent scores and logos without resetting their age`() {
+ val refreshed = retainSportsPresentation(event, scored, now)
+ assertThat(refreshed.provenance.score?.value).isEqualTo(scored.provenance.score?.value)
+ assertThat(refreshed.provenance.score?.updatedAt).isEqualTo(now.minusSeconds(60))
+ assertThat(refreshed.provenance.score?.isStale).isTrue()
+ assertThat(refreshed.competitors.first().logoUrl).isNotNull()
+ }
+
+ @Test fun `retained scores expire instead of being kept alive by repeated refreshes`() {
+ val refreshed = retainSportsPresentation(event, scored, now.plusSeconds(601))
+ assertThat(refreshed.provenance.score).isNull()
+ }
+
+ @Test fun `new scores win and different teams never inherit old enrichment`() {
+ val fresh = scored.copy(provenance = scored.provenance.copy(score = scored.provenance.score?.copy(updatedAt = now)))
+ assertThat(retainSportsPresentation(fresh, scored, now).provenance.score).isEqualTo(fresh.provenance.score)
+ assertThat(retainSportsPresentation(event.copy(competitors = listOf(SportsCompetitor("Other team"))), scored, now).provenance.score).isNull()
+ }
+
+ @Test fun `team and matchup search is case insensitive and works across competitor names`() {
+ assertThat(event.matchesDiscovery(SportsHubUiState(searchQuery = "ATLANTA"))).isTrue()
+ assertThat(event.matchesDiscovery(SportsHubUiState(searchQuery = "Dream Valkyries"))).isTrue()
+ assertThat(event.matchesDiscovery(SportsHubUiState(searchQuery = "Lakers"))).isFalse()
+ }
+
+ @Test fun `sport and league exclusions apply together with search and quick filters`() {
+ assertThat(event.matchesDiscovery(SportsHubUiState(excludedSports = setOf("BASKETBALL")))).isFalse()
+ assertThat(event.matchesDiscovery(SportsHubUiState(excludedLeagues = setOf("wnba")))).isFalse()
+ assertThat(event.matchesDiscovery(SportsHubUiState(excludedSports = setOf("FOOTBALL"), searchQuery = "Atlanta"))).isTrue()
+ assertThat(event.matchesDiscovery(SportsHubUiState(selectedSportFilter = SportsSportFilter.FOOTBALL))).isFalse()
+ }
+}
diff --git a/feature/live/src/test/java/com/streamvault/feature/live/sports/SportsEventScoreTest.kt b/feature/live/src/test/java/com/streamvault/feature/live/sports/SportsEventScoreTest.kt
new file mode 100644
index 00000000..dac30ba5
--- /dev/null
+++ b/feature/live/src/test/java/com/streamvault/feature/live/sports/SportsEventScoreTest.kt
@@ -0,0 +1,32 @@
+package com.streamvault.feature.live.sports
+
+import com.google.common.truth.Truth.assertThat
+import com.streamvault.domain.sports.provider.*
+import org.junit.Test
+
+class SportsEventScoreTest {
+ private val away = SportsCompetitor("Atlanta Dream")
+ private val home = SportsCompetitor("Golden State Valkyries")
+ private val event = SportsEvent(
+ id = "match", title = "Atlanta at Golden State", league = "WNBA", categoryLabel = null,
+ description = "", sport = SportType.BASKETBALL, startTime = 0, endTime = 3_600_000,
+ broadcasts = emptyList(), confidence = 1f, competitors = listOf(away, home),
+ session = null, eventType = SportsEventType.LIVE_EVENT, rawProgrammeRefs = emptyList(),
+ provenance = SportsEventProvenance(score = SourcedValue(
+ ProviderScore("match", scores = listOf(
+ ProviderCompetitorScore(ProviderCompetitor(home.displayName, role = ProviderCompetitorRole.HOME), "40"),
+ ProviderCompetitorScore(ProviderCompetitor(away.displayName, role = ProviderCompetitorRole.AWAY), "37"),
+ )),
+ SportsSourceRef.Provider("account", "provider", "match"),
+ )),
+ )
+
+ @Test fun `scores follow team identity when the guide lists the away team first`() {
+ assertThat(event.scoreFor(away)).isEqualTo("37")
+ assertThat(event.scoreFor(home)).isEqualTo("40")
+ }
+
+ @Test fun `unrecognized team never inherits another teams score from row position`() {
+ assertThat(event.scoreFor(SportsCompetitor("Unknown team"))).isNull()
+ }
+}
diff --git a/feature/live/src/test/java/com/streamvault/feature/live/sports/SportsHubViewModelTest.kt b/feature/live/src/test/java/com/streamvault/feature/live/sports/SportsHubViewModelTest.kt
index 493b6fbe..51ee7720 100644
--- a/feature/live/src/test/java/com/streamvault/feature/live/sports/SportsHubViewModelTest.kt
+++ b/feature/live/src/test/java/com/streamvault/feature/live/sports/SportsHubViewModelTest.kt
@@ -1,6 +1,6 @@
package com.streamvault.feature.live.sports
-import com.streamvault.domain.sports.provider.SportsProviderReleasePolicy
+import com.streamvault.domain.sports.provider.*
import androidx.lifecycle.ViewModelStore
import androidx.lifecycle.viewModelScope
import com.google.common.truth.Truth.assertThat
@@ -17,18 +17,6 @@ import com.streamvault.domain.repository.EpgRepository
import com.streamvault.domain.repository.EpgSourceRepository
import com.streamvault.domain.repository.ProviderRepository
import com.streamvault.domain.repository.SyncMetadataRepository
-import com.streamvault.domain.sports.provider.SportsEventSourcePreference
-import com.streamvault.domain.sports.provider.SportsEventSourceSettings
-import com.streamvault.domain.sports.provider.SportsScoreSourcePreference
-import com.streamvault.domain.sports.provider.SportsScoreSourceSettings
-import com.streamvault.domain.sports.provider.SportsStandingsSourcePreference
-import com.streamvault.domain.sports.provider.SportsStandingsSourceSettings
-import com.streamvault.domain.sports.provider.SportsMetadataSourcePreference
-import com.streamvault.domain.sports.provider.SportsMetadataSourceSettings
-import com.streamvault.domain.sports.provider.SportsProviderConfig
-import com.streamvault.domain.sports.provider.SportsProviderCredentials
-import com.streamvault.domain.sports.provider.SportsProviderRegistry
-import com.streamvault.domain.sports.provider.SportsProviderStore
import com.streamvault.data.sports.provider.InMemorySportsProviderEventLinkCache
import java.util.concurrent.atomic.AtomicInteger
import java.util.concurrent.atomic.AtomicLong
@@ -74,8 +62,11 @@ class SportsHubViewModelTest {
private val sources: EpgSourceRepository = mock()
private val sync: SyncMetadataRepository = mock()
private val preferences: PreferencesRepository = mock()
+ private var sportsProviderConfigs: List<SportsProviderConfig> = emptyList()
+ private val sportsProviderRevision = MutableStateFlow(0L)
private val sportsProviderStore = object : SportsProviderStore {
- override suspend fun configurations(): List<SportsProviderConfig> = emptyList()
+ override val configurationChanges = sportsProviderRevision
+ override suspend fun configurations(): List<SportsProviderConfig> = sportsProviderConfigs
override suspend fun credentials(instanceId: String): SportsProviderCredentials? = null
override suspend fun save(config: SportsProviderConfig, credentials: SportsProviderCredentials?) = Unit
override suspend fun remove(instanceId: String) = Unit
@@ -135,6 +126,8 @@ class SportsHubViewModelTest {
whenever(preferences.getHiddenCategoryIds(7L, ContentType.LIVE)).thenReturn(hiddenCategories)
whenever(preferences.getHiddenChannelIds(7L)).thenReturn(flowOf(emptySet()))
whenever(preferences.getSportsEventChannelPicks(any(), any())).thenReturn(emptyMap())
+ whenever(preferences.getExcludedSports()).thenReturn(flowOf(emptySet()))
+ whenever(preferences.getExcludedSportsLeagues()).thenReturn(flowOf(emptySet()))
whenever(sync.observeMetadata(7L)).thenReturn(flowOf(null))
whenever(sources.getAllSources()).thenReturn(flowOf(emptyList()))
whenever(sources.getAssignmentsForProvider(7L)).thenReturn(flowOf(emptyList()))
@@ -327,7 +320,162 @@ class SportsHubViewModelTest {
assertThat(subscriptions.get()).isEqualTo(1)
}
- private fun createRepository() = SportsHubRepository(
+ @Test
+ fun `guide is published while provider discovery is pending`() = runBlocking<Unit> {
+ val gate = CompletableDeferred<Unit>()
+ val started = CompletableDeferred<Unit>()
+ val factory = enrichmentFactory(events = {
+ started.complete(Unit)
+ gate.await()
+ emptyList()
+ })
+ sportsProviderConfigs = listOf(SportsProviderConfig("test-api", factory.descriptor.typeId))
+ val registry = SportsProviderRegistry(listOf(factory), SportsProviderReleasePolicy(development = true))
+ val model = createModel(createRepository(registry))
+ withTimeout(10_000L) { started.await() }
+
+ assertThat(model.uiState.value.isLoading).isFalse()
+ assertThat(model.uiState.value.events).hasSize(1)
+ assertThat(model.uiState.value.events.single().broadcasts.single().channel.id).isEqualTo(1L)
+ gate.complete(Unit)
+ }
+
+ @Test
+ fun `API events appear while a long guide scan remains pending across clock ticks`() = runBlocking<Unit> {
+ val guideGate = CompletableDeferred<Map<String, List<Program>>>()
+ val guideReads = AtomicInteger()
+ whenever(epg.getResolvedProgramsForChannels(any(), any(), any(), any())).doSuspendableAnswer {
+ guideReads.incrementAndGet()
+ guideGate.await()
+ }
+ val factory = enrichmentFactory(events = { listOf(ProviderEvent(
+ providerEventId = "api-match", title = "North vs South", sport = "soccer",
+ competitors = listOf(ProviderCompetitor("North"), ProviderCompetitor("South")),
+ eventStart = java.time.Instant.now().minusSeconds(60),
+ )) })
+ sportsProviderConfigs = listOf(SportsProviderConfig("test-api", factory.descriptor.typeId))
+ val registry = SportsProviderRegistry(listOf(factory), SportsProviderReleasePolicy(development = true))
+ val model = createModel(createRepository(registry))
+ await { !model.uiState.value.isLoading && model.uiState.value.events.isNotEmpty() && guideReads.get() > 0 }
+ assertThat(model.uiState.value.events.single().title).isEqualTo("North vs South")
+
+ scheduler.advanceTimeBy(120_000L)
+ scheduler.runCurrent()
+ assertThat(guideReads.get()).isEqualTo(1)
+ assertThat(model.uiState.value.isLoading).isFalse()
+ guideGate.complete(emptyMap())
+ }
+
+ @Test
+ fun `saving provider configuration reloads the retained sports tab`() = runBlocking {
+ val calls = AtomicInteger()
+ val factory = enrichmentFactory(events = { calls.incrementAndGet(); emptyList() })
+ val registry = SportsProviderRegistry(listOf(factory), SportsProviderReleasePolicy(development = true))
+ val model = createModel(createRepository(registry))
+ await { !model.uiState.value.isLoading }
+ assertThat(calls.get()).isEqualTo(0)
+
+ sportsProviderConfigs = listOf(SportsProviderConfig("test-api", factory.descriptor.typeId))
+ sportsProviderRevision.value++
+
+ await { calls.get() > 0 && !model.uiState.value.isLoading }
+ assertThat(model.uiState.value.events.single().broadcasts.single().channel.id).isEqualTo(1L)
+ }
+
+ @Test
+ fun `events remain usable while scores and metadata are pending`() = runBlocking<Unit> {
+ val scoresStarted = CompletableDeferred<Unit>()
+ val scoresGate = CompletableDeferred<Unit>()
+ val metadataStarted = CompletableDeferred<Unit>()
+ val metadataGate = CompletableDeferred<Unit>()
+ val factory = enrichmentFactory(
+ events = { listOf(ProviderEvent(
+ providerEventId = "match", sport = "soccer", title = "Arsenal vs Chelsea",
+ eventStart = java.time.Instant.now().minusSeconds(60),
+ competitors = listOf(ProviderCompetitor("Arsenal", "arsenal"), ProviderCompetitor("Chelsea", "chelsea")),
+ )) },
+ scores = { scoresStarted.complete(Unit); scoresGate.await() },
+ metadata = { if (!metadataStarted.isCompleted) metadataStarted.complete(Unit); metadataGate.await() },
+ )
+ sportsProviderConfigs = listOf(SportsProviderConfig("test-api", factory.descriptor.typeId))
+ val registry = SportsProviderRegistry(listOf(factory), SportsProviderReleasePolicy(development = true))
+ val model = createModel(createRepository(registry))
+ withTimeout(10_000L) { scoresStarted.await() }
+ assertThat(model.uiState.value.isLoading).isFalse()
+ assertThat(model.uiState.value.events).hasSize(1)
+ scoresGate.complete(Unit)
+ withTimeout(10_000L) { metadataStarted.await() }
+ assertThat(model.uiState.value.isLoading).isFalse()
+ assertThat(model.uiState.value.events.single().broadcasts.single().channel.id).isEqualTo(1L)
+ metadataGate.complete(Unit)
+ }
+
+ @Test
+ fun `clock refresh never publishes unscored replacements for scored fixtures`() = runBlocking<Unit> {
+ val eventStart = java.time.Instant.now().minusSeconds(60)
+ val score = ProviderScore("match", listOf(
+ ProviderCompetitorScore(ProviderCompetitor("Arsenal", "arsenal"), "2"),
+ ProviderCompetitorScore(ProviderCompetitor("Chelsea", "chelsea"), "1"),
+ ))
+ val calls = AtomicInteger()
+ val factory = enrichmentFactory(
+ events = {
+ calls.incrementAndGet()
+ listOf(ProviderEvent(
+ providerEventId = "match", sport = "soccer", title = "Arsenal vs Chelsea",
+ eventStart = eventStart,
+ competitors = listOf(ProviderCompetitor("Arsenal", "arsenal"), ProviderCompetitor("Chelsea", "chelsea")),
+ ))
+ },
+ scoreItems = { listOf(score) },
+ )
+ sportsProviderConfigs = listOf(SportsProviderConfig("test-api", factory.descriptor.typeId))
+ val registry = SportsProviderRegistry(listOf(factory), SportsProviderReleasePolicy(development = true))
+ val model = createModel(createRepository(registry))
+ await { model.uiState.value.events.singleOrNull()?.provenance?.score != null }
+ // Let the first load finish, then collect every state during a scheduled refresh.
+ delay(100L)
+ val observed = mutableListOf<SportsHubUiState>()
+ val collector = repositoryScope.launch { model.uiState.collect { observed.add(it) } }
+ val initialCalls = calls.get()
+ scheduler.advanceTimeBy(60_000L)
+ scheduler.runCurrent()
+ await { calls.get() > initialCalls }
+ delay(100L)
+ collector.cancel()
+ assertThat(observed).isNotEmpty()
+ assertThat(observed.all { state -> state.events.isNotEmpty() && state.events.all { it.provenance.score != null } }).isTrue()
+ }
+
+ private fun enrichmentFactory(
+ events: suspend () -> List<ProviderEvent>,
+ scores: suspend () -> Unit = {},
+ metadata: suspend () -> Unit = {},
+ scoreItems: () -> List<ProviderScore> = { emptyList() },
+ ) = object : SportsProviderFactory {
+ override val descriptor = SportsProviderDescriptor(
+ typeId = "test-api", auth = SportsProviderAuth.None,
+ capabilities = setOf(SportsCapability.EVENTS, SportsCapability.LIVE_SCORES, SportsCapability.TEAM_METADATA),
+ )
+ override fun create(config: SportsProviderConfig): SportsProvider {
+ val factoryDescriptor = descriptor
+ return object : EventProvider, LiveScoreProvider, TeamMetadataProvider {
+ override val descriptor = factoryDescriptor
+ override val instanceId = config.instanceId
+ override suspend fun events(request: ProviderEventRequest) = SportsProviderResult.Success(ProviderBatch(events()))
+ override suspend fun liveScores(request: ProviderScoreRequest): SportsProviderResult<ProviderBatch<ProviderScore>> {
+ scores()
+ return SportsProviderResult.Success(ProviderBatch(scoreItems()))
+ }
+ override suspend fun teamMetadata(request: ProviderTeamMetadataRequest): SportsProviderResult<ProviderTeamMetadata> {
+ metadata()
+ return SportsProviderResult.Failure(SportsProviderError.NETWORK)
+ }
+ }
+ }
+ }
+
+ private fun createRepository(registry: SportsProviderRegistry? = null) = SportsHubRepository(
providers,
combined,
channels,
@@ -336,10 +484,11 @@ class SportsHubViewModelTest {
sync,
preferences,
sportsProviderStore,
- providerEventRouter,
- providerScoreRouter,
+ registry?.let(::SportsProviderEventSourceRouter) ?: providerEventRouter,
+ registry?.let { SportsProviderScoreSourceRouter(it, SportsProviderEventSourceRouter(it)) } ?: providerScoreRouter,
providerStandingsRouter,
- providerMetadataRouter,
+ registry?.let(::SportsProviderMetadataRouter) ?: providerMetadataRouter,
+ SportsProviderExtraDetailsRouter(SportsProviderRegistry(emptyList(), SportsProviderReleasePolicy(development = true)), sportsProviderStore),
eventSourceSettings,
scoreSourceSettings,
standingsSourceSettings,
diff --git a/feature/live/src/test/java/com/streamvault/feature/live/sports/SportsProgrammeClassifierTest.kt b/feature/live/src/test/java/com/streamvault/feature/live/sports/SportsProgrammeClassifierTest.kt
index a3f9df0e..70e13c7e 100644
--- a/feature/live/src/test/java/com/streamvault/feature/live/sports/SportsProgrammeClassifierTest.kt
+++ b/feature/live/src/test/java/com/streamvault/feature/live/sports/SportsProgrammeClassifierTest.kt
@@ -6,6 +6,18 @@ import com.streamvault.domain.model.Program
import org.junit.Test
class SportsProgrammeClassifierTest {
+ @Test
+ fun `provider football routes use league identity to distinguish NFL and soccer`() {
+ assertThat(SportsProgrammeClassifier.sportForProvider("football", "NFL"))
+ .isEqualTo(SportType.AMERICAN_FOOTBALL)
+ assertThat(SportsProgrammeClassifier.sportForProvider("football", "College Football"))
+ .isEqualTo(SportType.AMERICAN_FOOTBALL)
+ assertThat(SportsProgrammeClassifier.sportForProvider("football", "Premier League"))
+ .isEqualTo(SportType.FOOTBALL)
+ assertThat(SportsProgrammeClassifier.sportForProvider("soccer", "Premier League"))
+ .isEqualTo(SportType.FOOTBALL)
+ }
+
@Test
fun classifiesTeamAndNonTeamCompetitionsFromTitles() {
val matchup = classify(
diff --git a/feature/live/src/test/java/com/streamvault/feature/live/sports/SportsProviderEventSourceRouterTest.kt b/feature/live/src/test/java/com/streamvault/feature/live/sports/SportsProviderEventSourceRouterTest.kt
index a7e29781..79d9655a 100644
--- a/feature/live/src/test/java/com/streamvault/feature/live/sports/SportsProviderEventSourceRouterTest.kt
+++ b/feature/live/src/test/java/com/streamvault/feature/live/sports/SportsProviderEventSourceRouterTest.kt
@@ -21,6 +21,42 @@ import kotlinx.coroutines.test.runTest
import org.junit.Test
class SportsProviderEventSourceRouterTest {
+ @Test
+ fun `stalled provider times out and automatic selection reaches next account`() = runTest {
+ val stalled = TestFactory("stalled", eventResponse = { _, _ ->
+ kotlinx.coroutines.awaitCancellation()
+ })
+ val working = TestFactory("working", eventResponse = { _, _ ->
+ SportsProviderResult.Success(ProviderBatch(listOf(ProviderEvent("available"))))
+ })
+ val router = SportsProviderEventSourceRouter(SportsProviderRegistry(
+ listOf(stalled, working), SportsProviderReleasePolicy(development = true),
+ ))
+ val loaded = router.load(
+ listOf(config("stalled", "stalled"), config("working", "working")),
+ Instant.parse("2026-10-17T00:00:00Z"), Instant.parse("2026-10-18T00:00:00Z"),
+ )
+ assertThat(loaded.instanceId).isEqualTo("working")
+ assertThat(loaded.events.map { it.providerEventId }).containsExactly("available")
+ }
+
+ @Test
+ fun `completed leagues survive a later league timeout`() = runTest {
+ val scoped = TestFactory("scoped", eventResponse = { _, request ->
+ if (request.leagueId == "slow") kotlinx.coroutines.awaitCancellation()
+ SportsProviderResult.Success(ProviderBatch(listOf(ProviderEvent("available"))))
+ })
+ val router = SportsProviderEventSourceRouter(SportsProviderRegistry(
+ listOf(scoped), SportsProviderReleasePolicy(development = true),
+ ))
+ val loaded = router.load(
+ listOf(config("account", "scoped", leagueIds = listOf("fast", "slow"))),
+ Instant.parse("2026-10-17T00:00:00Z"), Instant.parse("2026-10-18T00:00:00Z"),
+ )
+ assertThat(loaded.instanceId).isEqualTo("account")
+ assertThat(loaded.events.map { it.providerEventId }).containsExactly("available")
+ }
+
@Test
fun `EPG selection returns no event providers`() {
val factory = TestFactory("events")
diff --git a/feature/live/src/test/java/com/streamvault/feature/live/sports/SportsProviderScoreSourceRouterTest.kt b/feature/live/src/test/java/com/streamvault/feature/live/sports/SportsProviderScoreSourceRouterTest.kt
index 5e39be6e..a707a4f1 100644
--- a/feature/live/src/test/java/com/streamvault/feature/live/sports/SportsProviderScoreSourceRouterTest.kt
+++ b/feature/live/src/test/java/com/streamvault/feature/live/sports/SportsProviderScoreSourceRouterTest.kt
@@ -26,6 +26,32 @@ import kotlinx.coroutines.test.runTest
import org.junit.Test
class SportsProviderScoreSourceRouterTest {
+ @Test
+ fun `busy catalog caps score requests and prioritizes live games`() = runTest {
+ val now = Instant.parse("2026-10-17T12:00:00Z")
+ val events = (1..75).map { index -> ProviderEvent(
+ providerEventId = "event-$index", eventStart = now.plusSeconds(index.toLong()),
+ status = ProviderGameStatus(if (index == 75) ProviderGameState.LIVE else ProviderGameState.SCHEDULED),
+ ) }
+ var requested = emptySet<String>()
+ val factory = TestFactory("scores", scoreResponse = { _, request ->
+ requested = request.eventIds
+ SportsProviderResult.Success(ProviderBatch(request.eventIds.map { ProviderScore(it) }))
+ })
+ val registry = SportsProviderRegistry(listOf(factory), SportsProviderReleasePolicy(development = true))
+ val router = SportsProviderScoreSourceRouter(registry, SportsProviderEventSourceRouter(registry))
+ val loaded = router.load(
+ listOf(config("account", "scores")),
+ LoadedSportsProviderEvents("account", "scores", events),
+ now.minusSeconds(86_400), now.plusSeconds(86_400), now,
+ )
+
+ assertThat(requested).hasSize(50)
+ assertThat(requested).contains("event-75")
+ assertThat(requested.first()).isEqualTo("event-75")
+ assertThat(loaded.scores).hasSize(50)
+ }
+
@Test
fun `automatic selection prefers event account and manual selection stays independent`() {
val first = TestFactory("first")
diff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsContentPane.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsContentPane.kt
index 71987820..5296a480 100644
--- a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsContentPane.kt
+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsContentPane.kt
@@ -215,6 +215,9 @@ public fun SettingsContentPane(
SettingsLocalHeader(
title = stringResource(page?.title ?: category.title),
description = stringResource(page?.description ?: category.description),
+ badge = if (category == SettingsCategory.SPORTS) {
+ stringResource(R.string.settings_experimental_badge)
+ } else null,
parentTitle = when {
activeSearchTarget != null -> stringResource(R.string.settings_search_title)
page != null -> stringResource(category.title)
diff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsDestination.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsDestination.kt
index d75eb9a3..964c3345 100644
--- a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsDestination.kt
+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsDestination.kt
@@ -13,9 +13,9 @@ enum class SettingsCategory(val legacyId: Int, val title: Int, val description:
RECORDING(4, R.string.settings_recording_title, R.string.settings_recording_description),
BACKUP(5, R.string.settings_backup_restore, R.string.settings_backup_description),
GUIDE(6, R.string.settings_domain_guide, R.string.settings_guide_description),
- ABOUT(7, R.string.settings_about, R.string.settings_about_description),
TRAKT(10, R.string.settings_trakt, R.string.settings_trakt_description),
- SPORTS(11, R.string.nav_sports, R.string.settings_sports_settings_description);
+ SPORTS(11, R.string.nav_sports, R.string.settings_sports_settings_description),
+ ABOUT(7, R.string.settings_about, R.string.settings_about_description);
val pages: List<SettingsPage> get() = SettingsPage.entries.filter { it.categoryId == legacyId }
companion object {
diff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsShell.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsShell.kt
index 73f762d3..698c663c 100644
--- a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsShell.kt
+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SettingsShell.kt
@@ -1,6 +1,7 @@
package com.streamvault.feature.settings.presentation
import androidx.compose.foundation.BorderStroke
+import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
@@ -41,6 +42,7 @@ internal fun SettingsLocalHeader(
onExit: (() -> Unit)? = null,
searchModifier: Modifier = Modifier,
backModifier: Modifier = Modifier,
+ badge: String? = null,
) {
val colors = SettingsDesignTokens.colors(AppColors.current)
Row(
@@ -100,6 +102,17 @@ internal fun SettingsLocalHeader(
color = colors.primaryText,
modifier = Modifier.semantics { heading() },
)
+ if (badge != null) {
+ Text(
+ text = badge,
+ style = MaterialTheme.typography.labelMedium,
+ fontWeight = FontWeight.SemiBold,
+ color = colors.primaryText,
+ modifier = Modifier
+ .background(colors.groupSurface, RoundedCornerShape(6.dp))
+ .padding(horizontal = 8.dp, vertical = 4.dp),
+ )
+ }
if (description.isNotBlank()) {
Text(
text = description,
diff --git a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SportsDataProviderSettingsPage.kt b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SportsDataProviderSettingsPage.kt
index 36f30b29..eff24d04 100644
--- a/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SportsDataProviderSettingsPage.kt
+++ b/feature/settings/src/main/java/com/streamvault/feature/settings/presentation/SportsDataProviderSettingsPage.kt
@@ -1,5 +1,9 @@
package com.streamvault.feature.settings.presentation
+import android.content.ContentResolver
+import android.net.Uri
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.selection.selectable
@@ -50,7 +54,10 @@ import com.streamvault.domain.sports.provider.SportsMetadataSourceMode
import com.streamvault.domain.sports.provider.SportsMetadataSourcePreference
import com.streamvault.feature.settings.R
import java.net.URI
+import java.io.InputStreamReader
+import java.nio.charset.StandardCharsets
import org.json.JSONObject
+import com.streamvault.domain.sports.provider.CUSTOM_SPORTS_PROVIDER_MAX_CONFIGURATION_CHARS
@Composable
internal fun SportsDataProviderSettingsPage(
@@ -604,6 +611,28 @@ private fun SportsProviderConfigDialog(
var customDefinitionJson by remember(existing?.instanceId, descriptor.typeId) {
mutableStateOf(existing?.customDefinitionJson.orEmpty())
}
+ var customJsonImportError by remember(existing?.instanceId, descriptor.typeId) {
+ mutableStateOf<Int?>(null)
+ }
+ val customJsonFilePicker = rememberLauncherForActivityResult(
+ contract = ActivityResultContracts.OpenDocument(),
+ ) { uri ->
+ if (uri != null) {
+ when (val result = readCustomSportsJsonFile(context.contentResolver, uri)) {
+ is CustomSportsJsonFileResult.Success -> {
+ customDefinitionJson = result.contents
+ customJsonImportError = null
+ onDraftChanged()
+ }
+ CustomSportsJsonFileResult.TooLarge -> {
+ customJsonImportError = R.string.settings_sports_custom_definition_file_too_large
+ }
+ CustomSportsJsonFileResult.Invalid -> {
+ customJsonImportError = R.string.settings_sports_custom_definition_file_error
+ }
+ }
+ }
+ }
val isCustomProvider = descriptor.typeId == CUSTOM_SPORTS_PROVIDER_TYPE_ID
val credentialsAreValid = if (isCustomProvider) {
customCredentialsValid(customDefinitionJson, hasExistingCredentials, username, secret)
@@ -673,27 +702,52 @@ private fun SportsProviderConfigDialog(
color = colors.secondaryText,
style = MaterialTheme.typography.labelSmall,
)
- if (customDefinitionJson.isBlank()) {
+ Row(horizontalArrangement = Arrangement.spacedBy(SettingsDesignTokens.space8)) {
CompactSettingsActionChip(
- label = stringResource(R.string.settings_sports_custom_definition_example_action),
+ label = stringResource(R.string.settings_sports_custom_definition_load_file),
accent = colors.accent,
enabled = !isSaving,
onClick = {
- customDefinitionJson = customSportsProviderExample(
- context.getString(R.string.settings_sports_provider_custom_json),
+ customJsonImportError = null
+ customJsonFilePicker.launch(
+ arrayOf("application/json", "text/*", "application/octet-stream"),
)
- onDraftChanged()
},
)
+ if (customDefinitionJson.isBlank()) {
+ CompactSettingsActionChip(
+ label = stringResource(R.string.settings_sports_custom_definition_example_action),
+ accent = colors.accent,
+ enabled = !isSaving,
+ onClick = {
+ customJsonImportError = null
+ customDefinitionJson = customSportsProviderExample(
+ context.getString(R.string.settings_sports_provider_custom_json),
+ )
+ onDraftChanged()
+ },
+ )
+ }
}
EpgSourceTextField(
value = customDefinitionJson,
- onValueChange = { customDefinitionJson = it; onDraftChanged() },
+ onValueChange = {
+ customDefinitionJson = it
+ customJsonImportError = null
+ onDraftChanged()
+ },
placeholder = stringResource(R.string.settings_sports_custom_definition_placeholder),
modifier = Modifier.heightIn(min = 112.dp, max = 200.dp),
singleLine = false,
maxLines = 8,
)
+ customJsonImportError?.let { errorResource ->
+ Text(
+ text = stringResource(errorResource),
+ color = colors.error,
+ style = MaterialTheme.typography.bodySmall,
+ )
+ }
Text(
text = stringResource(R.string.settings_sports_custom_definition_hint),
color = colors.secondaryText,
@@ -722,7 +776,13 @@ private fun SportsProviderConfigDialog(
placeholder = stringResource(R.string.settings_sports_provider_league_ids),
)
Text(
- text = stringResource(if (descriptor.typeId == OPENLIGADB_TYPE_ID) R.string.settings_sports_provider_openligadb_scope_hint else R.string.settings_sports_provider_league_ids_hint),
+ text = stringResource(
+ when {
+ descriptor.typeId == OPENLIGADB_TYPE_ID -> R.string.settings_sports_provider_openligadb_scope_hint
+ isCustomProvider -> R.string.settings_sports_custom_scopes_hint
+ else -> R.string.settings_sports_provider_league_ids_hint
+ },
+ ),
color = colors.secondaryText,
style = MaterialTheme.typography.bodySmall,
)
@@ -1042,6 +1102,39 @@ private fun customCredentialsValid(
}
}
+private sealed interface CustomSportsJsonFileResult {
+ data class Success(val contents: String) : CustomSportsJsonFileResult
+ data object TooLarge : CustomSportsJsonFileResult
+ data object Invalid : CustomSportsJsonFileResult
+}
+
+private fun readCustomSportsJsonFile(
+ contentResolver: ContentResolver,
+ uri: Uri,
+): CustomSportsJsonFileResult = try {
+ val contents = buildString {
+ val input = requireNotNull(contentResolver.openInputStream(uri))
+ InputStreamReader(input, StandardCharsets.UTF_8).use { reader ->
+ val buffer = CharArray(4_096)
+ while (length <= CUSTOM_SPORTS_PROVIDER_MAX_CONFIGURATION_CHARS) {
+ val remaining = CUSTOM_SPORTS_PROVIDER_MAX_CONFIGURATION_CHARS + 1 - length
+ if (remaining <= 0) break
+ val count = reader.read(buffer, 0, minOf(buffer.size, remaining))
+ if (count < 0) break
+ append(buffer, 0, count)
+ }
+ }
+ }.removePrefix("\uFEFF")
+ if (contents.length > CUSTOM_SPORTS_PROVIDER_MAX_CONFIGURATION_CHARS) {
+ CustomSportsJsonFileResult.TooLarge
+ } else {
+ JSONObject(contents)
+ CustomSportsJsonFileResult.Success(contents)
+ }
+} catch (_: Exception) {
+ CustomSportsJsonFileResult.Invalid
+}
+
@Composable
private fun OpenLigaDbAttribution(
attribution: com.streamvault.domain.sports.provider.ProviderAttribution,
@@ -1072,7 +1165,7 @@ private fun parseEventLeagueIds(input: String): List<String>? {
val trimmed = input.trim()
if (trimmed.isEmpty()) return emptyList()
val ids = trimmed.split(Regex("[,\\s]+")).filter(String::isNotEmpty)
- if (ids.size > 50 || ids.any { !it.matches(Regex("[A-Za-z0-9._:-]{1,128}")) }) return null
+ if (ids.size > 50 || ids.any { !it.matches(Regex("[A-Za-z0-9._:/-]{1,128}")) }) return null
if (ids.distinct().size != ids.size) return null
return ids
}
diff --git a/feature/settings/src/main/res/values-ar/strings.xml b/feature/settings/src/main/res/values-ar/strings.xml
index 947f8886..06174f7f 100644
--- a/feature/settings/src/main/res/values-ar/strings.xml
+++ b/feature/settings/src/main/res/values-ar/strings.xml
@@ -886,6 +886,7 @@
<string name="settings_sports_event_source_epg">دليل التلفاز / EPG</string>
<string name="settings_sports_provider_league_ids">معرّفات الدوريات</string>
<string name="settings_sports_provider_league_ids_hint">اختياري. أضف معرّفات الدوريات فقط إذا كان هذا المزوّد يتطلبها.</string>
+ <string name="settings_sports_custom_scopes_hint">في موفّر JSON المخصّص، أدخل النطاقات بصيغة sport/league وافصل بينها بفواصل.</string>
<string name="nav_sports">الرياضة</string>
<string name="settings_sports_settings_description">إدارة موفري بيانات الرياضة المتصلين.</string>
<string name="settings_sports_data_providers_title">موفرو بيانات الرياضة</string>
@@ -947,4 +948,8 @@
<string name="settings_sports_custom_definition_example_action">إدراج مثال</string>
<string name="settings_sports_custom_definition_placeholder">الصق JSON الخاص بالمزوّد</string>
<string name="settings_open_source_licenses">تراخيص وإشعارات البرامج مفتوحة المصدر</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">تحميل ملف JSON</string>
+ <string name="settings_sports_custom_definition_file_too_large">ملف JSON أكبر من الحد الأقصى البالغ 32 كيلوبايت</string>
+ <string name="settings_sports_custom_definition_file_error">تعذّر تحميل ملف JSON هذا</string>
+ <string name="settings_experimental_badge">تجريبي</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-bg/strings.xml b/feature/settings/src/main/res/values-bg/strings.xml
index 0a319cc4..7a060976 100644
--- a/feature/settings/src/main/res/values-bg/strings.xml
+++ b/feature/settings/src/main/res/values-bg/strings.xml
@@ -872,6 +872,7 @@
<string name="settings_sports_event_source_epg">ТВ справочник / EPG</string>
<string name="settings_sports_provider_league_ids">Идентификатори на лиги</string>
<string name="settings_sports_provider_league_ids_hint">По избор. Добавете идентификатори на лиги само ако доставчикът ги изисква.</string>
+ <string name="settings_sports_custom_scopes_hint">За персонализирания JSON доставчик въведете обхватите във формат sport/league, разделени със запетаи.</string>
<string name="nav_sports">Спорт</string>
<string name="settings_sports_settings_description">Управлявайте свързаните доставчици на спортни данни.</string>
<string name="settings_sports_data_providers_title">Доставчици на спортни данни</string>
@@ -933,4 +934,8 @@
<string name="settings_sports_custom_definition_example_action">Вмъкване на пример</string>
<string name="settings_sports_custom_definition_placeholder">Поставете JSON на доставчика</string>
<string name="settings_open_source_licenses">Лицензи и известия за софтуер с отворен код</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">Зареждане на JSON файл</string>
+ <string name="settings_sports_custom_definition_file_too_large">JSON файлът надвишава ограничението от 32 KB</string>
+ <string name="settings_sports_custom_definition_file_error">Този JSON файл не може да бъде зареден</string>
+ <string name="settings_experimental_badge">Експериментално</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-cs/strings.xml b/feature/settings/src/main/res/values-cs/strings.xml
index 76c590ea..c8e3111d 100644
--- a/feature/settings/src/main/res/values-cs/strings.xml
+++ b/feature/settings/src/main/res/values-cs/strings.xml
@@ -880,6 +880,7 @@
<string name="settings_sports_event_source_epg">TV průvodce / EPG</string>
<string name="settings_sports_provider_league_ids">ID lig</string>
<string name="settings_sports_provider_league_ids_hint">Volitelné. ID lig zadejte pouze tehdy, když je tento poskytovatel vyžaduje.</string>
+ <string name="settings_sports_custom_scopes_hint">U vlastního poskytovatele JSON zadejte rozsahy ve formátu sport/league oddělené čárkami.</string>
<string name="nav_sports">Sport</string>
<string name="settings_sports_settings_description">Spravujte připojené poskytovatele sportovních dat.</string>
<string name="settings_sports_data_providers_title">Poskytovatelé sportovních dat</string>
@@ -941,4 +942,8 @@
<string name="settings_sports_custom_definition_example_action">Vložit příklad</string>
<string name="settings_sports_custom_definition_placeholder">Vložte JSON poskytovatele</string>
<string name="settings_open_source_licenses">Licence a oznámení k softwaru s otevřeným zdrojovým kódem</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">Načíst soubor JSON</string>
+ <string name="settings_sports_custom_definition_file_too_large">Soubor JSON překračuje limit 32 kB</string>
+ <string name="settings_sports_custom_definition_file_error">Tento soubor JSON nelze načíst</string>
+ <string name="settings_experimental_badge">Experimentální</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-da/strings.xml b/feature/settings/src/main/res/values-da/strings.xml
index 84663b0c..890802e4 100644
--- a/feature/settings/src/main/res/values-da/strings.xml
+++ b/feature/settings/src/main/res/values-da/strings.xml
@@ -874,6 +874,7 @@
<string name="settings_sports_event_source_epg">TV-guide / EPG</string>
<string name="settings_sports_provider_league_ids">Liga-ID</string>
<string name="settings_sports_provider_league_ids_hint">Valgfrit. Angiv kun liga-ID, hvis udbyderen kræver det.</string>
+ <string name="settings_sports_custom_scopes_hint">For en brugerdefineret JSON-udbyder skal du angive omfang i formatet sport/league adskilt af kommaer.</string>
<string name="nav_sports">Sport</string>
<string name="settings_sports_settings_description">Administrer tilsluttede udbydere af sportsdata.</string>
<string name="settings_sports_data_providers_title">Udbydere af sportsdata</string>
@@ -935,4 +936,8 @@
<string name="settings_sports_custom_definition_example_action">Indsæt eksempel</string>
<string name="settings_sports_custom_definition_placeholder">Indsæt udbyderens JSON</string>
<string name="settings_open_source_licenses">Open source-licenser og meddelelser</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">Indlæs JSON-fil</string>
+ <string name="settings_sports_custom_definition_file_too_large">JSON-filen overskrider grænsen på 32 kB</string>
+ <string name="settings_sports_custom_definition_file_error">Denne JSON-fil kunne ikke indlæses</string>
+ <string name="settings_experimental_badge">Eksperimentel</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-de/strings.xml b/feature/settings/src/main/res/values-de/strings.xml
index 9a279650..2ee23001 100644
--- a/feature/settings/src/main/res/values-de/strings.xml
+++ b/feature/settings/src/main/res/values-de/strings.xml
@@ -870,6 +870,7 @@
<string name="settings_sports_event_source_epg">TV-Programm / EPG</string>
<string name="settings_sports_provider_league_ids">Liga-IDs</string>
<string name="settings_sports_provider_league_ids_hint">Optional. Gib Liga-IDs nur ein, wenn dieser Anbieter sie benötigt.</string>
+ <string name="settings_sports_custom_scopes_hint">Gib für einen benutzerdefinierten JSON-Anbieter Bereiche im Format sport/league ein, durch Kommas getrennt.</string>
<string name="nav_sports">Sport</string>
<string name="settings_sports_settings_description">Verwalte verbundene Anbieter von Sportdaten.</string>
<string name="settings_sports_data_providers_title">Sportdatenanbieter</string>
@@ -931,4 +932,8 @@
<string name="settings_sports_custom_definition_example_action">Beispiel einfügen</string>
<string name="settings_sports_custom_definition_placeholder">JSON des Anbieters einfügen</string>
<string name="settings_open_source_licenses">Open-Source-Lizenzen und Hinweise</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">JSON-Datei laden</string>
+ <string name="settings_sports_custom_definition_file_too_large">Die JSON-Datei überschreitet das Limit von 32 KB</string>
+ <string name="settings_sports_custom_definition_file_error">Diese JSON-Datei konnte nicht geladen werden</string>
+ <string name="settings_experimental_badge">Experimentell</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-el/strings.xml b/feature/settings/src/main/res/values-el/strings.xml
index 5597ae9a..a20b1c7c 100644
--- a/feature/settings/src/main/res/values-el/strings.xml
+++ b/feature/settings/src/main/res/values-el/strings.xml
@@ -874,6 +874,7 @@
<string name="settings_sports_event_source_epg">Τηλεοπτικός οδηγός / EPG</string>
<string name="settings_sports_provider_league_ids">Αναγνωριστικά πρωταθλημάτων</string>
<string name="settings_sports_provider_league_ids_hint">Προαιρετικό. Προσθέστε αναγνωριστικά πρωταθλημάτων μόνο αν τα απαιτεί αυτός ο πάροχος.</string>
+ <string name="settings_sports_custom_scopes_hint">Για προσαρμοσμένο πάροχο JSON, εισαγάγετε εύρη στη μορφή sport/league, χωρισμένα με κόμμα.</string>
<string name="nav_sports">Αθλητικά</string>
<string name="settings_sports_settings_description">Διαχειριστείτε συνδεδεμένους παρόχους αθλητικών δεδομένων.</string>
<string name="settings_sports_data_providers_title">Πάροχοι αθλητικών δεδομένων</string>
@@ -935,4 +936,8 @@
<string name="settings_sports_custom_definition_example_action">Εισαγωγή παραδείγματος</string>
<string name="settings_sports_custom_definition_placeholder">Επικολλήστε το JSON του παρόχου</string>
<string name="settings_open_source_licenses">Άδειες και γνωστοποιήσεις λογισμικού ανοικτού κώδικα</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">Φόρτωση αρχείου JSON</string>
+ <string name="settings_sports_custom_definition_file_too_large">Το αρχείο JSON υπερβαίνει το όριο των 32 KB</string>
+ <string name="settings_sports_custom_definition_file_error">Δεν ήταν δυνατή η φόρτωση αυτού του αρχείου JSON</string>
+ <string name="settings_experimental_badge">Πειραματικό</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-es/strings.xml b/feature/settings/src/main/res/values-es/strings.xml
index 9a27099b..9bdce996 100644
--- a/feature/settings/src/main/res/values-es/strings.xml
+++ b/feature/settings/src/main/res/values-es/strings.xml
@@ -870,6 +870,7 @@
<string name="settings_sports_event_source_epg">Guía de TV / EPG</string>
<string name="settings_sports_provider_league_ids">ID de ligas</string>
<string name="settings_sports_provider_league_ids_hint">Opcional. Añade ID de ligas solo si este proveedor los requiere.</string>
+ <string name="settings_sports_custom_scopes_hint">Para un proveedor JSON personalizado, introduce ámbitos con el formato sport/league separados por comas.</string>
<string name="nav_sports">Deportes</string>
<string name="settings_sports_settings_description">Administra proveedores conectados de datos deportivos.</string>
<string name="settings_sports_data_providers_title">Proveedores de datos deportivos</string>
@@ -931,4 +932,8 @@
<string name="settings_sports_custom_definition_example_action">Insertar ejemplo</string>
<string name="settings_sports_custom_definition_placeholder">Pega el JSON del proveedor</string>
<string name="settings_open_source_licenses">Licencias y avisos de código abierto</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">Cargar archivo JSON</string>
+ <string name="settings_sports_custom_definition_file_too_large">El archivo JSON supera el límite de 32 KB</string>
+ <string name="settings_sports_custom_definition_file_error">No se pudo cargar este archivo JSON</string>
+ <string name="settings_experimental_badge">Experimental</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-fa/strings.xml b/feature/settings/src/main/res/values-fa/strings.xml
index 9acedfeb..b17741b1 100644
--- a/feature/settings/src/main/res/values-fa/strings.xml
+++ b/feature/settings/src/main/res/values-fa/strings.xml
@@ -872,6 +872,7 @@
<string name="settings_sports_event_source_epg">راهنمای تلویزیون / EPG</string>
<string name="settings_sports_provider_league_ids">شناسه‌های لیگ</string>
<string name="settings_sports_provider_league_ids_hint">اختیاری. فقط اگر این ارائه‌دهنده نیاز دارد، شناسه لیگ وارد کنید.</string>
+ <string name="settings_sports_custom_scopes_hint">برای ارائه‌دهنده JSON سفارشی، محدوده‌ها را با قالب sport/league و با جداکنندهٔ ویرگول وارد کنید.</string>
<string name="nav_sports">ورزش</string>
<string name="settings_sports_settings_description">ارائه‌دهندگان متصل داده‌های ورزشی را مدیریت کنید.</string>
<string name="settings_sports_data_providers_title">ارائه‌دهندگان داده‌های ورزشی</string>
@@ -933,4 +934,8 @@
<string name="settings_sports_custom_definition_example_action">درج نمونه</string>
<string name="settings_sports_custom_definition_placeholder">JSON ارائه‌دهنده را جای‌گذاری کنید</string>
<string name="settings_open_source_licenses">مجوزها و اطلاعیه‌های نرم‌افزار متن‌باز</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">بارگذاری فایل JSON</string>
+ <string name="settings_sports_custom_definition_file_too_large">اندازه فایل JSON از حد ۳۲ کیلوبایت بیشتر است</string>
+ <string name="settings_sports_custom_definition_file_error">بارگذاری این فایل JSON ممکن نبود</string>
+ <string name="settings_experimental_badge">آزمایشی</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-fi/strings.xml b/feature/settings/src/main/res/values-fi/strings.xml
index 531ced8c..bd8599cd 100644
--- a/feature/settings/src/main/res/values-fi/strings.xml
+++ b/feature/settings/src/main/res/values-fi/strings.xml
@@ -874,6 +874,7 @@
<string name="settings_sports_event_source_epg">TV-opas / EPG</string>
<string name="settings_sports_provider_league_ids">Liigatunnukset</string>
<string name="settings_sports_provider_league_ids_hint">Valinnainen. Lisää liigatunnuksia vain, jos tämä palveluntarjoaja niitä vaatii.</string>
+ <string name="settings_sports_custom_scopes_hint">Anna mukautetulle JSON-palveluntarjoajalle lajit ja liigat muodossa sport/league pilkuilla erotettuina.</string>
<string name="nav_sports">Urheilu</string>
<string name="settings_sports_settings_description">Hallitse yhdistettyjä urheilutietojen tarjoajia.</string>
<string name="settings_sports_data_providers_title">Urheilutietojen tarjoajat</string>
@@ -935,4 +936,8 @@
<string name="settings_sports_custom_definition_example_action">Lisää esimerkki</string>
<string name="settings_sports_custom_definition_placeholder">Liitä palveluntarjoajan JSON</string>
<string name="settings_open_source_licenses">Avoimen lähdekoodin lisenssit ja ilmoitukset</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">Lataa JSON-tiedosto</string>
+ <string name="settings_sports_custom_definition_file_too_large">JSON-tiedosto ylittää 32 kt:n rajan</string>
+ <string name="settings_sports_custom_definition_file_error">Tätä JSON-tiedostoa ei voitu ladata</string>
+ <string name="settings_experimental_badge">Kokeellinen</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-fil/strings.xml b/feature/settings/src/main/res/values-fil/strings.xml
index f79430a2..1a5cb4af 100644
--- a/feature/settings/src/main/res/values-fil/strings.xml
+++ b/feature/settings/src/main/res/values-fil/strings.xml
@@ -872,6 +872,7 @@
<string name="settings_sports_event_source_epg">Gabay sa TV / EPG</string>
<string name="settings_sports_provider_league_ids">Mga ID ng liga</string>
<string name="settings_sports_provider_league_ids_hint">Opsyonal. Maglagay lang ng mga ID ng liga kung kailangan ito ng provider na ito.</string>
+ <string name="settings_sports_custom_scopes_hint">Para sa custom na JSON provider, ilagay ang mga scope sa format na sport/league at paghiwalayin ng kuwit.</string>
<string name="nav_sports">Palakasan</string>
<string name="settings_sports_settings_description">Pamahalaan ang mga nakakonektang provider ng datos sa palakasan.</string>
<string name="settings_sports_data_providers_title">Mga provider ng datos sa palakasan</string>
@@ -933,4 +934,8 @@
<string name="settings_sports_custom_definition_example_action">Maglagay ng halimbawa</string>
<string name="settings_sports_custom_definition_placeholder">I-paste ang JSON ng provider</string>
<string name="settings_open_source_licenses">Mga lisensya at abiso ng open source</string>
+ <string name="settings_sports_custom_definition_load_file">Mag-load ng JSON file</string>
+ <string name="settings_sports_custom_definition_file_too_large">Lumampas ang JSON file sa limit na 32 KB</string>
+ <string name="settings_sports_custom_definition_file_error">Hindi ma-load ang JSON file na ito</string>
+ <string name="settings_experimental_badge">Eksperimental</string>
</resources>
diff --git a/feature/settings/src/main/res/values-fr/strings.xml b/feature/settings/src/main/res/values-fr/strings.xml
index 660d7538..d3d8a0a9 100644
--- a/feature/settings/src/main/res/values-fr/strings.xml
+++ b/feature/settings/src/main/res/values-fr/strings.xml
@@ -874,6 +874,7 @@
<string name="settings_sports_event_source_epg">Guide TV / EPG</string>
<string name="settings_sports_provider_league_ids">Identifiants des ligues</string>
<string name="settings_sports_provider_league_ids_hint">Facultatif. Ajoutez des identifiants de ligue uniquement si ce fournisseur les exige.</string>
+ <string name="settings_sports_custom_scopes_hint">Pour un fournisseur JSON personnalisé, saisissez les périmètres au format sport/league, séparés par des virgules.</string>
<string name="nav_sports">Sports</string>
<string name="settings_sports_settings_description">Gérez les fournisseurs de données sportives connectés.</string>
<string name="settings_sports_data_providers_title">Fournisseurs de données sportives</string>
@@ -935,4 +936,8 @@
<string name="settings_sports_custom_definition_example_action">Insérer un exemple</string>
<string name="settings_sports_custom_definition_placeholder">Collez le JSON du fournisseur</string>
<string name="settings_open_source_licenses">Licences et mentions des logiciels libres</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">Charger un fichier JSON</string>
+ <string name="settings_sports_custom_definition_file_too_large">Le fichier JSON dépasse la limite de 32 Ko</string>
+ <string name="settings_sports_custom_definition_file_error">Impossible de charger ce fichier JSON</string>
+ <string name="settings_experimental_badge">Expérimental</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-hi/strings.xml b/feature/settings/src/main/res/values-hi/strings.xml
index b06e3b72..7a88054a 100644
--- a/feature/settings/src/main/res/values-hi/strings.xml
+++ b/feature/settings/src/main/res/values-hi/strings.xml
@@ -872,6 +872,7 @@
<string name="settings_sports_event_source_epg">टीवी गाइड / EPG</string>
<string name="settings_sports_provider_league_ids">लीग आईडी</string>
<string name="settings_sports_provider_league_ids_hint">वैकल्पिक। लीग आईडी केवल तभी जोड़ें जब यह प्रदाता उन्हें मांगता है।</string>
+ <string name="settings_sports_custom_scopes_hint">कस्टम JSON प्रदाता के लिए sport/league प्रारूप में स्कोप दर्ज करें और उन्हें कॉमा से अलग करें।</string>
<string name="nav_sports">खेल</string>
<string name="settings_sports_settings_description">जुड़े हुए खेल डेटा प्रदाताओं को प्रबंधित करें।</string>
<string name="settings_sports_data_providers_title">खेल डेटा प्रदाता</string>
@@ -933,4 +934,8 @@
<string name="settings_sports_custom_definition_example_action">उदाहरण डालें</string>
<string name="settings_sports_custom_definition_placeholder">प्रदाता JSON पेस्ट करें</string>
<string name="settings_open_source_licenses">ओपन-सोर्स लाइसेंस और सूचनाएँ</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">JSON फ़ाइल लोड करें</string>
+ <string name="settings_sports_custom_definition_file_too_large">JSON फ़ाइल 32 KB की सीमा से बड़ी है</string>
+ <string name="settings_sports_custom_definition_file_error">यह JSON फ़ाइल लोड नहीं की जा सकी</string>
+ <string name="settings_experimental_badge">प्रायोगिक</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-hr/strings.xml b/feature/settings/src/main/res/values-hr/strings.xml
index 8873d2d1..36249b67 100644
--- a/feature/settings/src/main/res/values-hr/strings.xml
+++ b/feature/settings/src/main/res/values-hr/strings.xml
@@ -875,6 +875,7 @@
<string name="settings_sports_event_source_epg">TV vodič / EPG</string>
<string name="settings_sports_provider_league_ids">ID-jevi liga</string>
<string name="settings_sports_provider_league_ids_hint">Neobavezno. Dodajte ID-jeve liga samo ako ih ovaj pružatelj zahtijeva.</string>
+ <string name="settings_sports_custom_scopes_hint">Za prilagođenog JSON pružatelja unesite opsege u obliku sport/league, odvojene zarezima.</string>
<string name="nav_sports">Sport</string>
<string name="settings_sports_settings_description">Upravljajte povezanim pružateljima sportskih podataka.</string>
<string name="settings_sports_data_providers_title">Pružatelji sportskih podataka</string>
@@ -936,4 +937,8 @@
<string name="settings_sports_custom_definition_example_action">Umetni primjer</string>
<string name="settings_sports_custom_definition_placeholder">Zalijepite JSON pružatelja</string>
<string name="settings_open_source_licenses">Licence i obavijesti otvorenog koda</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">Učitaj JSON datoteku</string>
+ <string name="settings_sports_custom_definition_file_too_large">JSON datoteka premašuje ograničenje od 32 KB</string>
+ <string name="settings_sports_custom_definition_file_error">Nije moguće učitati ovu JSON datoteku</string>
+ <string name="settings_experimental_badge">Eksperimentalno</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-hu/strings.xml b/feature/settings/src/main/res/values-hu/strings.xml
index 8f763904..19d52557 100644
--- a/feature/settings/src/main/res/values-hu/strings.xml
+++ b/feature/settings/src/main/res/values-hu/strings.xml
@@ -874,6 +874,7 @@
<string name="settings_sports_event_source_epg">TV-műsorújság / EPG</string>
<string name="settings_sports_provider_league_ids">Bajnokságazonosítók</string>
<string name="settings_sports_provider_league_ids_hint">Nem kötelező. Csak akkor adjon meg bajnokságazonosítókat, ha ez a szolgáltató kéri őket.</string>
+ <string name="settings_sports_custom_scopes_hint">Egyéni JSON-szolgáltatónál vesszővel elválasztva, sport/league formátumban adja meg a hatóköröket.</string>
<string name="nav_sports">Sport</string>
<string name="settings_sports_settings_description">Kezeld a csatlakoztatott sportadat-szolgáltatókat.</string>
<string name="settings_sports_data_providers_title">Sportadat-szolgáltatók</string>
@@ -935,4 +936,8 @@
<string name="settings_sports_custom_definition_example_action">Példa beszúrása</string>
<string name="settings_sports_custom_definition_placeholder">Illeszd be a szolgáltató JSON-adatait</string>
<string name="settings_open_source_licenses">Nyílt forráskódú licencek és közlemények</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">JSON-fájl betöltése</string>
+ <string name="settings_sports_custom_definition_file_too_large">A JSON-fájl meghaladja a 32 KB-os korlátot</string>
+ <string name="settings_sports_custom_definition_file_error">Ez a JSON-fájl nem tölthető be</string>
+ <string name="settings_experimental_badge">Kísérleti</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-in/strings.xml b/feature/settings/src/main/res/values-in/strings.xml
index e0a1c29d..aa18da60 100644
--- a/feature/settings/src/main/res/values-in/strings.xml
+++ b/feature/settings/src/main/res/values-in/strings.xml
@@ -874,6 +874,7 @@
<string name="settings_sports_event_source_epg">Panduan TV / EPG</string>
<string name="settings_sports_provider_league_ids">ID liga</string>
<string name="settings_sports_provider_league_ids_hint">Opsional. Tambahkan ID liga hanya jika penyedia ini memerlukannya.</string>
+ <string name="settings_sports_custom_scopes_hint">Untuk penyedia JSON kustom, masukkan cakupan dengan format sport/league yang dipisahkan koma.</string>
<string name="nav_sports">Olahraga</string>
<string name="settings_sports_settings_description">Kelola penyedia data olahraga yang terhubung.</string>
<string name="settings_sports_data_providers_title">Penyedia data olahraga</string>
@@ -935,4 +936,8 @@
<string name="settings_sports_custom_definition_example_action">Sisipkan contoh</string>
<string name="settings_sports_custom_definition_placeholder">Tempel JSON penyedia</string>
<string name="settings_open_source_licenses">Lisensi dan pemberitahuan sumber terbuka</string>
+ <string name="settings_sports_custom_definition_load_file">Muat file JSON</string>
+ <string name="settings_sports_custom_definition_file_too_large">File JSON melebihi batas 32 KB</string>
+ <string name="settings_sports_custom_definition_file_error">File JSON ini tidak dapat dimuat</string>
+ <string name="settings_experimental_badge">Eksperimental</string>
</resources>
diff --git a/feature/settings/src/main/res/values-it/strings.xml b/feature/settings/src/main/res/values-it/strings.xml
index 689980dc..fcaff4d5 100644
--- a/feature/settings/src/main/res/values-it/strings.xml
+++ b/feature/settings/src/main/res/values-it/strings.xml
@@ -870,6 +870,7 @@
<string name="settings_sports_event_source_epg">Guida TV / EPG</string>
<string name="settings_sports_provider_league_ids">ID delle leghe</string>
<string name="settings_sports_provider_league_ids_hint">Facoltativo. Inserisci gli ID delle leghe solo se richiesti da questo provider.</string>
+ <string name="settings_sports_custom_scopes_hint">Per un provider JSON personalizzato, inserisci gli ambiti nel formato sport/league, separati da virgole.</string>
<string name="nav_sports">Sport</string>
<string name="settings_sports_settings_description">Gestisci i provider connessi di dati sportivi.</string>
<string name="settings_sports_data_providers_title">Provider di dati sportivi</string>
@@ -931,4 +932,8 @@
<string name="settings_sports_custom_definition_example_action">Inserisci esempio</string>
<string name="settings_sports_custom_definition_placeholder">Incolla il JSON del provider</string>
<string name="settings_open_source_licenses">Licenze e avvisi open source</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">Carica file JSON</string>
+ <string name="settings_sports_custom_definition_file_too_large">Il file JSON supera il limite di 32 KB</string>
+ <string name="settings_sports_custom_definition_file_error">Impossibile caricare questo file JSON</string>
+ <string name="settings_experimental_badge">Sperimentale</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-iw/strings.xml b/feature/settings/src/main/res/values-iw/strings.xml
index 6fe48763..357cfd9b 100644
--- a/feature/settings/src/main/res/values-iw/strings.xml
+++ b/feature/settings/src/main/res/values-iw/strings.xml
@@ -877,6 +877,7 @@
<string name="settings_sports_event_source_epg">מדריך טלוויזיה / EPG</string>
<string name="settings_sports_provider_league_ids">מזהי ליגות</string>
<string name="settings_sports_provider_league_ids_hint">לא חובה. יש להוסיף מזהי ליגות רק אם הספק הזה דורש זאת.</string>
+ <string name="settings_sports_custom_scopes_hint">בספק JSON מותאם אישית, יש להזין תחומים בפורמט sport/league ולהפריד ביניהם בפסיקים.</string>
<string name="nav_sports">ספורט</string>
<string name="settings_sports_settings_description">ניהול ספקי נתוני ספורט מחוברים.</string>
<string name="settings_sports_data_providers_title">ספקי נתוני ספורט</string>
@@ -938,4 +939,8 @@
<string name="settings_sports_custom_definition_example_action">הוספת דוגמה</string>
<string name="settings_sports_custom_definition_placeholder">הדביקו JSON של ספק</string>
<string name="settings_open_source_licenses">רישיונות והודעות של קוד פתוח</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">טען קובץ JSON</string>
+ <string name="settings_sports_custom_definition_file_too_large">קובץ JSON חורג מהמגבלה של 32 KB</string>
+ <string name="settings_sports_custom_definition_file_error">לא ניתן לטעון את קובץ ה-JSON הזה</string>
+ <string name="settings_experimental_badge">ניסיוני</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-ja/strings.xml b/feature/settings/src/main/res/values-ja/strings.xml
index 3bb57214..064dc1ba 100644
--- a/feature/settings/src/main/res/values-ja/strings.xml
+++ b/feature/settings/src/main/res/values-ja/strings.xml
@@ -872,6 +872,7 @@
<string name="settings_sports_event_source_epg">テレビ番組表 / EPG</string>
<string name="settings_sports_provider_league_ids">リーグ ID</string>
<string name="settings_sports_provider_league_ids_hint">任意。このプロバイダーで必要な場合にのみリーグ ID を入力してください。</string>
+ <string name="settings_sports_custom_scopes_hint">カスタム JSON プロバイダーでは、sport/league 形式のスコープをコンマ区切りで入力します。</string>
<string name="nav_sports">スポーツ</string>
<string name="settings_sports_settings_description">接続済みのスポーツデータプロバイダーを管理します。</string>
<string name="settings_sports_data_providers_title">スポーツデータプロバイダー</string>
@@ -933,4 +934,8 @@
<string name="settings_sports_custom_definition_example_action">例を挿入</string>
<string name="settings_sports_custom_definition_placeholder">プロバイダーのJSONを貼り付け</string>
<string name="settings_open_source_licenses">オープンソースライセンスと通知</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">JSON ファイルを読み込む</string>
+ <string name="settings_sports_custom_definition_file_too_large">JSON ファイルが 32 KB の上限を超えています</string>
+ <string name="settings_sports_custom_definition_file_error">この JSON ファイルを読み込めませんでした</string>
+ <string name="settings_experimental_badge">試験運用</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-ko/strings.xml b/feature/settings/src/main/res/values-ko/strings.xml
index dd0a5302..c7f70447 100644
--- a/feature/settings/src/main/res/values-ko/strings.xml
+++ b/feature/settings/src/main/res/values-ko/strings.xml
@@ -870,6 +870,7 @@
<string name="settings_sports_event_source_epg">TV 편성표 / EPG</string>
<string name="settings_sports_provider_league_ids">리그 ID</string>
<string name="settings_sports_provider_league_ids_hint">선택사항입니다. 이 제공업체에서 필요한 경우에만 리그 ID를 입력하세요.</string>
+ <string name="settings_sports_custom_scopes_hint">사용자 지정 JSON 제공업체의 범위는 sport/league 형식으로 입력하고 쉼표로 구분하세요.</string>
<string name="nav_sports">스포츠</string>
<string name="settings_sports_settings_description">연결된 스포츠 데이터 제공자를 관리합니다.</string>
<string name="settings_sports_data_providers_title">스포츠 데이터 제공자</string>
@@ -931,4 +932,8 @@
<string name="settings_sports_custom_definition_example_action">예시 삽입</string>
<string name="settings_sports_custom_definition_placeholder">제공업체 JSON 붙여넣기</string>
<string name="settings_open_source_licenses">오픈 소스 라이선스 및 고지</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">JSON 파일 불러오기</string>
+ <string name="settings_sports_custom_definition_file_too_large">JSON 파일이 32KB 제한을 초과합니다</string>
+ <string name="settings_sports_custom_definition_file_error">이 JSON 파일을 불러오지 못했습니다</string>
+ <string name="settings_experimental_badge">실험적 기능</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-mk/strings.xml b/feature/settings/src/main/res/values-mk/strings.xml
index 96dee423..b4f5bef6 100644
--- a/feature/settings/src/main/res/values-mk/strings.xml
+++ b/feature/settings/src/main/res/values-mk/strings.xml
@@ -872,6 +872,7 @@
<string name="settings_sports_event_source_epg">ТВ-програма / EPG</string>
<string name="settings_sports_provider_league_ids">ИД-а на лиги</string>
<string name="settings_sports_provider_league_ids_hint">Изборно. Внесете ИД-а на лиги само ако ги бара овој добавувач.</string>
+ <string name="settings_sports_custom_scopes_hint">За приспособен JSON добавувач внесете опсези во формат sport/league, одделени со запирки.</string>
<string name="nav_sports">Спорт</string>
<string name="settings_sports_settings_description">Управувајте со поврзаните даватели на спортски податоци.</string>
<string name="settings_sports_data_providers_title">Даватели на спортски податоци</string>
@@ -933,4 +934,8 @@
<string name="settings_sports_custom_definition_example_action">Вметни пример</string>
<string name="settings_sports_custom_definition_placeholder">Залепете JSON од провајдерот</string>
<string name="settings_open_source_licenses">Лиценци и известувања за софтвер со отворен код</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">Вчитај JSON датотека</string>
+ <string name="settings_sports_custom_definition_file_too_large">JSON-датотеката ја надминува границата од 32 KB</string>
+ <string name="settings_sports_custom_definition_file_error">Оваа JSON-датотека не може да се вчита</string>
+ <string name="settings_experimental_badge">Експериментално</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-ms/strings.xml b/feature/settings/src/main/res/values-ms/strings.xml
index cf7ba36c..d9d02273 100644
--- a/feature/settings/src/main/res/values-ms/strings.xml
+++ b/feature/settings/src/main/res/values-ms/strings.xml
@@ -869,6 +869,7 @@
<string name="settings_sports_event_source_epg">Panduan TV / EPG</string>
<string name="settings_sports_provider_league_ids">ID liga</string>
<string name="settings_sports_provider_league_ids_hint">Pilihan. Masukkan ID liga hanya jika diperlukan oleh penyedia ini.</string>
+ <string name="settings_sports_custom_scopes_hint">Untuk penyedia JSON tersuai, masukkan skop dalam format sport/league dan pisahkan dengan koma.</string>
<string name="nav_sports">Sukan</string>
<string name="settings_sports_settings_description">Urus penyedia data sukan yang disambungkan.</string>
<string name="settings_sports_data_providers_title">Penyedia data sukan</string>
@@ -930,4 +931,8 @@
<string name="settings_sports_custom_definition_example_action">Sisipkan contoh</string>
<string name="settings_sports_custom_definition_placeholder">Tampal JSON penyedia</string>
<string name="settings_open_source_licenses">Lesen dan notis sumber terbuka</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">Muatkan fail JSON</string>
+ <string name="settings_sports_custom_definition_file_too_large">Fail JSON melebihi had 32 KB</string>
+ <string name="settings_sports_custom_definition_file_error">Fail JSON ini tidak dapat dimuatkan</string>
+ <string name="settings_experimental_badge">Eksperimen</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-nb/strings.xml b/feature/settings/src/main/res/values-nb/strings.xml
index 76f743a4..f1ab2ccc 100644
--- a/feature/settings/src/main/res/values-nb/strings.xml
+++ b/feature/settings/src/main/res/values-nb/strings.xml
@@ -874,6 +874,7 @@
<string name="settings_sports_event_source_epg">TV-guide / EPG</string>
<string name="settings_sports_provider_league_ids">Liga-ID-er</string>
<string name="settings_sports_provider_league_ids_hint">Valgfritt. Legg bare til liga-ID-er hvis denne leverandøren krever dem.</string>
+ <string name="settings_sports_custom_scopes_hint">For en egendefinert JSON-leverandør angir du omfang i formatet sport/league, atskilt med komma.</string>
<string name="nav_sports">Sport</string>
<string name="settings_sports_settings_description">Administrer tilkoblede leverandører av sportsdata.</string>
<string name="settings_sports_data_providers_title">Leverandører av sportsdata</string>
@@ -935,4 +936,8 @@
<string name="settings_sports_custom_definition_example_action">Sett inn eksempel</string>
<string name="settings_sports_custom_definition_placeholder">Lim inn leverandørens JSON</string>
<string name="settings_open_source_licenses">Lisenser og merknader for åpen kildekode</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">Last inn JSON-fil</string>
+ <string name="settings_sports_custom_definition_file_too_large">JSON-filen overskrider grensen på 32 kB</string>
+ <string name="settings_sports_custom_definition_file_error">Denne JSON-filen kunne ikke lastes inn</string>
+ <string name="settings_experimental_badge">Eksperimentell</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-nl/strings.xml b/feature/settings/src/main/res/values-nl/strings.xml
index 4901e25c..ab79881a 100644
--- a/feature/settings/src/main/res/values-nl/strings.xml
+++ b/feature/settings/src/main/res/values-nl/strings.xml
@@ -874,6 +874,7 @@
<string name="settings_sports_event_source_epg">Tv-gids / EPG</string>
<string name="settings_sports_provider_league_ids">Competitie-ID’s</string>
<string name="settings_sports_provider_league_ids_hint">Optioneel. Voeg alleen competitie-ID’s toe als deze provider ze vereist.</string>
+ <string name="settings_sports_custom_scopes_hint">Voer voor een aangepaste JSON-provider scopes in de vorm sport/league in, gescheiden door komma’s.</string>
<string name="nav_sports">Sport</string>
<string name="settings_sports_settings_description">Beheer verbonden aanbieders van sportgegevens.</string>
<string name="settings_sports_data_providers_title">Aanbieders van sportgegevens</string>
@@ -935,4 +936,8 @@
<string name="settings_sports_custom_definition_example_action">Voorbeeld invoegen</string>
<string name="settings_sports_custom_definition_placeholder">Plak de JSON van de provider</string>
<string name="settings_open_source_licenses">Open-sourcelicenties en kennisgevingen</string>
+ <string name="settings_sports_custom_definition_load_file">JSON-bestand laden</string>
+ <string name="settings_sports_custom_definition_file_too_large">Het JSON-bestand is groter dan de limiet van 32 KB</string>
+ <string name="settings_sports_custom_definition_file_error">Dit JSON-bestand kon niet worden geladen</string>
+ <string name="settings_experimental_badge">Experimenteel</string>
</resources>
diff --git a/feature/settings/src/main/res/values-pl/strings.xml b/feature/settings/src/main/res/values-pl/strings.xml
index 8f128f54..8868bd38 100644
--- a/feature/settings/src/main/res/values-pl/strings.xml
+++ b/feature/settings/src/main/res/values-pl/strings.xml
@@ -880,6 +880,7 @@
<string name="settings_sports_event_source_epg">Przewodnik TV / EPG</string>
<string name="settings_sports_provider_league_ids">Identyfikatory lig</string>
<string name="settings_sports_provider_league_ids_hint">Opcjonalnie. Dodaj identyfikatory lig tylko wtedy, gdy wymaga ich ten dostawca.</string>
+ <string name="settings_sports_custom_scopes_hint">W przypadku niestandardowego dostawcy JSON wpisz zakresy w formacie sport/league, oddzielone przecinkami.</string>
<string name="nav_sports">Sport</string>
<string name="settings_sports_settings_description">Zarządzaj połączonymi dostawcami danych sportowych.</string>
<string name="settings_sports_data_providers_title">Dostawcy danych sportowych</string>
@@ -941,4 +942,8 @@
<string name="settings_sports_custom_definition_example_action">Wstaw przykład</string>
<string name="settings_sports_custom_definition_placeholder">Wklej JSON dostawcy</string>
<string name="settings_open_source_licenses">Licencje i informacje o oprogramowaniu open source</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">Wczytaj plik JSON</string>
+ <string name="settings_sports_custom_definition_file_too_large">Plik JSON przekracza limit 32 KB</string>
+ <string name="settings_sports_custom_definition_file_error">Nie można wczytać tego pliku JSON</string>
+ <string name="settings_experimental_badge">Eksperymentalne</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-pt/strings.xml b/feature/settings/src/main/res/values-pt/strings.xml
index 68d32016..fb942e40 100644
--- a/feature/settings/src/main/res/values-pt/strings.xml
+++ b/feature/settings/src/main/res/values-pt/strings.xml
@@ -870,6 +870,7 @@
<string name="settings_sports_event_source_epg">Guia de TV / EPG</string>
<string name="settings_sports_provider_league_ids">IDs das ligas</string>
<string name="settings_sports_provider_league_ids_hint">Opcional. Adicione IDs das ligas apenas se este fornecedor os exigir.</string>
+ <string name="settings_sports_custom_scopes_hint">Para um fornecedor JSON personalizado, introduza âmbitos no formato sport/league, separados por vírgulas.</string>
<string name="nav_sports">Desporto</string>
<string name="settings_sports_settings_description">Gerencie provedores conectados de dados esportivos.</string>
<string name="settings_sports_data_providers_title">Provedores de dados esportivos</string>
@@ -931,4 +932,8 @@
<string name="settings_sports_custom_definition_example_action">Inserir exemplo</string>
<string name="settings_sports_custom_definition_placeholder">Cole o JSON do provedor</string>
<string name="settings_open_source_licenses">Licenças e avisos de código aberto</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">Carregar arquivo JSON</string>
+ <string name="settings_sports_custom_definition_file_too_large">O arquivo JSON excede o limite de 32 KB</string>
+ <string name="settings_sports_custom_definition_file_error">Não foi possível carregar este arquivo JSON</string>
+ <string name="settings_experimental_badge">Experimental</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-ro/strings.xml b/feature/settings/src/main/res/values-ro/strings.xml
index ae823e84..f0b32d25 100644
--- a/feature/settings/src/main/res/values-ro/strings.xml
+++ b/feature/settings/src/main/res/values-ro/strings.xml
@@ -877,6 +877,7 @@
<string name="settings_sports_event_source_epg">Ghid TV / EPG</string>
<string name="settings_sports_provider_league_ids">ID-uri de ligi</string>
<string name="settings_sports_provider_league_ids_hint">Opțional. Adăugați ID-uri de ligi doar dacă acest furnizor le solicită.</string>
+ <string name="settings_sports_custom_scopes_hint">Pentru un furnizor JSON personalizat, introduceți domenii în formatul sport/league, separate prin virgule.</string>
<string name="nav_sports">Sport</string>
<string name="settings_sports_settings_description">Gestionează furnizorii conectați de date sportive.</string>
<string name="settings_sports_data_providers_title">Furnizori de date sportive</string>
@@ -938,4 +939,8 @@
<string name="settings_sports_custom_definition_example_action">Inserează exemplu</string>
<string name="settings_sports_custom_definition_placeholder">Lipește JSON-ul furnizorului</string>
<string name="settings_open_source_licenses">Licențe și notificări pentru software open-source</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">Încarcă fișier JSON</string>
+ <string name="settings_sports_custom_definition_file_too_large">Fișierul JSON depășește limita de 32 KB</string>
+ <string name="settings_sports_custom_definition_file_error">Acest fișier JSON nu a putut fi încărcat</string>
+ <string name="settings_experimental_badge">Experimental</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-ru/strings.xml b/feature/settings/src/main/res/values-ru/strings.xml
index d0f70296..0b2c3d3c 100644
--- a/feature/settings/src/main/res/values-ru/strings.xml
+++ b/feature/settings/src/main/res/values-ru/strings.xml
@@ -880,6 +880,7 @@
<string name="settings_sports_event_source_epg">ТВ-программа / EPG</string>
<string name="settings_sports_provider_league_ids">Идентификаторы лиг</string>
<string name="settings_sports_provider_league_ids_hint">Необязательно. Добавляйте идентификаторы лиг, только если они нужны этому провайдеру.</string>
+ <string name="settings_sports_custom_scopes_hint">Для пользовательского JSON-провайдера укажите области в формате sport/league через запятую.</string>
<string name="nav_sports">Спорт</string>
<string name="settings_sports_settings_description">Управляйте подключёнными поставщиками спортивных данных.</string>
<string name="settings_sports_data_providers_title">Поставщики спортивных данных</string>
@@ -941,4 +942,8 @@
<string name="settings_sports_custom_definition_example_action">Вставить пример</string>
<string name="settings_sports_custom_definition_placeholder">Вставьте JSON провайдера</string>
<string name="settings_open_source_licenses">Лицензии и уведомления об открытом исходном коде</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">Загрузить файл JSON</string>
+ <string name="settings_sports_custom_definition_file_too_large">Файл JSON превышает ограничение 32 КБ</string>
+ <string name="settings_sports_custom_definition_file_error">Не удалось загрузить этот файл JSON</string>
+ <string name="settings_experimental_badge">Экспериментально</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-sk/strings.xml b/feature/settings/src/main/res/values-sk/strings.xml
index cc174841..6177d736 100644
--- a/feature/settings/src/main/res/values-sk/strings.xml
+++ b/feature/settings/src/main/res/values-sk/strings.xml
@@ -878,6 +878,7 @@
<string name="settings_sports_event_source_epg">TV program / EPG</string>
<string name="settings_sports_provider_league_ids">ID ligy</string>
<string name="settings_sports_provider_league_ids_hint">Voliteľné. ID ligy zadajte iba vtedy, ak ich tento poskytovateľ vyžaduje.</string>
+ <string name="settings_sports_custom_scopes_hint">Pre vlastného poskytovateľa JSON zadajte rozsahy vo formáte sport/league oddelené čiarkami.</string>
<string name="nav_sports">Šport</string>
<string name="settings_sports_settings_description">Spravujte pripojených poskytovateľov športových údajov.</string>
<string name="settings_sports_data_providers_title">Poskytovatelia športových údajov</string>
@@ -939,4 +940,8 @@
<string name="settings_sports_custom_definition_example_action">Vložiť príklad</string>
<string name="settings_sports_custom_definition_placeholder">Vložte JSON poskytovateľa</string>
<string name="settings_open_source_licenses">Licencie a oznámenia o otvorenom kóde</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">Načítať súbor JSON</string>
+ <string name="settings_sports_custom_definition_file_too_large">Súbor JSON prekračuje limit 32 kB</string>
+ <string name="settings_sports_custom_definition_file_error">Tento súbor JSON sa nepodarilo načítať</string>
+ <string name="settings_experimental_badge">Experimentálne</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-sq/strings.xml b/feature/settings/src/main/res/values-sq/strings.xml
index 7be57cde..ee4e9bc1 100644
--- a/feature/settings/src/main/res/values-sq/strings.xml
+++ b/feature/settings/src/main/res/values-sq/strings.xml
@@ -872,6 +872,7 @@
<string name="settings_sports_event_source_epg">Udhëzuesi TV / EPG</string>
<string name="settings_sports_provider_league_ids">ID-të e ligave</string>
<string name="settings_sports_provider_league_ids_hint">Opsionale. Shtoni ID-të e ligave vetëm nëse i kërkon ky ofrues.</string>
+ <string name="settings_sports_custom_scopes_hint">Për një ofrues JSON të personalizuar, vendosni fushat në formatin sport/league, të ndara me presje.</string>
<string name="nav_sports">Sport</string>
<string name="settings_sports_settings_description">Menaxhoni ofruesit e lidhur të të dhënave sportive.</string>
<string name="settings_sports_data_providers_title">Ofrues të të dhënave sportive</string>
@@ -933,4 +934,8 @@
<string name="settings_sports_custom_definition_example_action">Fut shembullin</string>
<string name="settings_sports_custom_definition_placeholder">Ngjitni JSON-in e ofruesit</string>
<string name="settings_open_source_licenses">Licencat dhe njoftimet e burimit të hapur</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">Ngarko skedarin JSON</string>
+ <string name="settings_sports_custom_definition_file_too_large">Skedari JSON tejkalon kufirin prej 32 KB</string>
+ <string name="settings_sports_custom_definition_file_error">Ky skedar JSON nuk mund të ngarkohej</string>
+ <string name="settings_experimental_badge">Eksperimentale</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-sr/strings.xml b/feature/settings/src/main/res/values-sr/strings.xml
index ca45647d..9a769ccf 100644
--- a/feature/settings/src/main/res/values-sr/strings.xml
+++ b/feature/settings/src/main/res/values-sr/strings.xml
@@ -875,6 +875,7 @@
<string name="settings_sports_event_source_epg">ТВ водич / EPG</string>
<string name="settings_sports_provider_league_ids">ИД-јеви лига</string>
<string name="settings_sports_provider_league_ids_hint">Опционално. Унесите ИД-јеве лига само ако их овај добављач захтева.</string>
+ <string name="settings_sports_custom_scopes_hint">За прилагођеног JSON добављача унесите опсеге у формату sport/league, раздвојене зарезима.</string>
<string name="nav_sports">Спорт</string>
<string name="settings_sports_settings_description">Управљајте повезаним добављачима спортских података.</string>
<string name="settings_sports_data_providers_title">Добављачи спортских података</string>
@@ -936,4 +937,8 @@
<string name="settings_sports_custom_definition_example_action">Уметни пример</string>
<string name="settings_sports_custom_definition_placeholder">Налепите JSON добављача</string>
<string name="settings_open_source_licenses">Лиценце и обавештења о софтверу отвореног кода</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">Учитај JSON датотеку</string>
+ <string name="settings_sports_custom_definition_file_too_large">JSON датотека премашује ограничење од 32 KB</string>
+ <string name="settings_sports_custom_definition_file_error">Није могуће учитати ову JSON датотеку</string>
+ <string name="settings_experimental_badge">Експериментално</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-sv/strings.xml b/feature/settings/src/main/res/values-sv/strings.xml
index 61109041..98a75ae5 100644
--- a/feature/settings/src/main/res/values-sv/strings.xml
+++ b/feature/settings/src/main/res/values-sv/strings.xml
@@ -874,6 +874,7 @@
<string name="settings_sports_event_source_epg">TV-guide / EPG</string>
<string name="settings_sports_provider_league_ids">Liga-ID:n</string>
<string name="settings_sports_provider_league_ids_hint">Valfritt. Lägg bara till liga-ID:n om den här leverantören kräver dem.</string>
+ <string name="settings_sports_custom_scopes_hint">För en anpassad JSON-leverantör anger du omfång i formatet sport/league, separerade med kommatecken.</string>
<string name="nav_sports">Sport</string>
<string name="settings_sports_settings_description">Hantera anslutna leverantörer av sportdata.</string>
<string name="settings_sports_data_providers_title">Leverantörer av sportdata</string>
@@ -935,4 +936,8 @@
<string name="settings_sports_custom_definition_example_action">Infoga exempel</string>
<string name="settings_sports_custom_definition_placeholder">Klistra in leverantörens JSON</string>
<string name="settings_open_source_licenses">Licenser och meddelanden för öppen källkod</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">Läs in JSON-fil</string>
+ <string name="settings_sports_custom_definition_file_too_large">JSON-filen överskrider gränsen på 32 kB</string>
+ <string name="settings_sports_custom_definition_file_error">Det gick inte att läsa in den här JSON-filen</string>
+ <string name="settings_experimental_badge">Experimentell</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-th/strings.xml b/feature/settings/src/main/res/values-th/strings.xml
index ffa5fd03..08e63aae 100644
--- a/feature/settings/src/main/res/values-th/strings.xml
+++ b/feature/settings/src/main/res/values-th/strings.xml
@@ -869,6 +869,7 @@
<string name="settings_sports_event_source_epg">ผังรายการทีวี / EPG</string>
<string name="settings_sports_provider_league_ids">รหัสลีก</string>
<string name="settings_sports_provider_league_ids_hint">ไม่บังคับ เพิ่มรหัสลีกเฉพาะเมื่อผู้ให้บริการนี้กำหนดให้ใช้</string>
+ <string name="settings_sports_custom_scopes_hint">สำหรับผู้ให้บริการ JSON แบบกำหนดเอง ให้ป้อนขอบเขตในรูปแบบ sport/league โดยคั่นด้วยจุลภาค</string>
<string name="nav_sports">กีฬา</string>
<string name="settings_sports_settings_description">จัดการผู้ให้บริการข้อมูลกีฬาที่เชื่อมต่อแล้ว</string>
<string name="settings_sports_data_providers_title">ผู้ให้บริการข้อมูลกีฬา</string>
@@ -930,4 +931,8 @@
<string name="settings_sports_custom_definition_example_action">แทรกตัวอย่าง</string>
<string name="settings_sports_custom_definition_placeholder">วาง JSON ของผู้ให้บริการ</string>
<string name="settings_open_source_licenses">ใบอนุญาตและประกาศเกี่ยวกับซอฟต์แวร์โอเพนซอร์ส</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">โหลดไฟล์ JSON</string>
+ <string name="settings_sports_custom_definition_file_too_large">ไฟล์ JSON มีขนาดเกินขีดจำกัด 32 KB</string>
+ <string name="settings_sports_custom_definition_file_error">ไม่สามารถโหลดไฟล์ JSON นี้ได้</string>
+ <string name="settings_experimental_badge">ฟีเจอร์ทดลอง</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-tr/strings.xml b/feature/settings/src/main/res/values-tr/strings.xml
index 0d25119e..7f992051 100644
--- a/feature/settings/src/main/res/values-tr/strings.xml
+++ b/feature/settings/src/main/res/values-tr/strings.xml
@@ -874,6 +874,7 @@
<string name="settings_sports_event_source_epg">TV rehberi / EPG</string>
<string name="settings_sports_provider_league_ids">Lig kimlikleri</string>
<string name="settings_sports_provider_league_ids_hint">İsteğe bağlı. Lig kimliklerini yalnızca bu sağlayıcı gerektiriyorsa ekleyin.</string>
+ <string name="settings_sports_custom_scopes_hint">Özel JSON sağlayıcısı için kapsamları sport/league biçiminde ve virgülle ayırarak girin.</string>
<string name="nav_sports">Spor</string>
<string name="settings_sports_settings_description">Bağlı spor verisi sağlayıcılarını yönetin.</string>
<string name="settings_sports_data_providers_title">Spor verisi sağlayıcıları</string>
@@ -935,4 +936,8 @@
<string name="settings_sports_custom_definition_example_action">Örneği ekle</string>
<string name="settings_sports_custom_definition_placeholder">Sağlayıcı JSON verisini yapıştırın</string>
<string name="settings_open_source_licenses">Açık kaynak lisansları ve bildirimleri</string>
+ <string name="settings_sports_custom_definition_load_file">JSON dosyasını yükle</string>
+ <string name="settings_sports_custom_definition_file_too_large">JSON dosyası 32 KB sınırını aşıyor</string>
+ <string name="settings_sports_custom_definition_file_error">Bu JSON dosyası yüklenemedi</string>
+ <string name="settings_experimental_badge">Deneysel</string>
</resources>
diff --git a/feature/settings/src/main/res/values-uk/strings.xml b/feature/settings/src/main/res/values-uk/strings.xml
index d7b0368e..e1f87470 100644
--- a/feature/settings/src/main/res/values-uk/strings.xml
+++ b/feature/settings/src/main/res/values-uk/strings.xml
@@ -880,6 +880,7 @@
<string name="settings_sports_event_source_epg">Телепрограма / EPG</string>
<string name="settings_sports_provider_league_ids">Ідентифікатори ліг</string>
<string name="settings_sports_provider_league_ids_hint">Необов’язково. Додавайте ідентифікатори ліг, лише якщо вони потрібні цьому провайдеру.</string>
+ <string name="settings_sports_custom_scopes_hint">Для власного постачальника JSON введіть області у форматі sport/league через кому.</string>
<string name="nav_sports">Спорт</string>
<string name="settings_sports_settings_description">Керуйте підключеними постачальниками спортивних даних.</string>
<string name="settings_sports_data_providers_title">Постачальники спортивних даних</string>
@@ -941,4 +942,8 @@
<string name="settings_sports_custom_definition_example_action">Вставити приклад</string>
<string name="settings_sports_custom_definition_placeholder">Вставте JSON провайдера</string>
<string name="settings_open_source_licenses">Ліцензії та повідомлення про відкрите програмне забезпечення</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">Завантажити файл JSON</string>
+ <string name="settings_sports_custom_definition_file_too_large">Файл JSON перевищує обмеження 32 КБ</string>
+ <string name="settings_sports_custom_definition_file_error">Не вдалося завантажити цей файл JSON</string>
+ <string name="settings_experimental_badge">Експериментально</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-vi/strings.xml b/feature/settings/src/main/res/values-vi/strings.xml
index 33de77f5..2a456554 100644
--- a/feature/settings/src/main/res/values-vi/strings.xml
+++ b/feature/settings/src/main/res/values-vi/strings.xml
@@ -871,6 +871,7 @@
<string name="settings_sports_event_source_epg">Hướng dẫn TV / EPG</string>
<string name="settings_sports_provider_league_ids">ID giải đấu</string>
<string name="settings_sports_provider_league_ids_hint">Không bắt buộc. Chỉ thêm ID giải đấu nếu nhà cung cấp này yêu cầu.</string>
+ <string name="settings_sports_custom_scopes_hint">Với nhà cung cấp JSON tùy chỉnh, hãy nhập các phạm vi theo định dạng sport/league và phân tách bằng dấu phẩy.</string>
<string name="nav_sports">Thể thao</string>
<string name="settings_sports_settings_description">Quản lý các nhà cung cấp dữ liệu thể thao đã kết nối.</string>
<string name="settings_sports_data_providers_title">Nhà cung cấp dữ liệu thể thao</string>
@@ -932,4 +933,8 @@
<string name="settings_sports_custom_definition_example_action">Chèn ví dụ</string>
<string name="settings_sports_custom_definition_placeholder">Dán JSON của nhà cung cấp</string>
<string name="settings_open_source_licenses">Giấy phép và thông báo mã nguồn mở</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">Tải tệp JSON</string>
+ <string name="settings_sports_custom_definition_file_too_large">Tệp JSON vượt quá giới hạn 32 KB</string>
+ <string name="settings_sports_custom_definition_file_error">Không thể tải tệp JSON này</string>
+ <string name="settings_experimental_badge">Thử nghiệm</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-zh-rTW/strings.xml b/feature/settings/src/main/res/values-zh-rTW/strings.xml
index f973b476..b6eb6098 100644
--- a/feature/settings/src/main/res/values-zh-rTW/strings.xml
+++ b/feature/settings/src/main/res/values-zh-rTW/strings.xml
@@ -869,6 +869,7 @@
<string name="settings_sports_event_source_epg">電視節目指南 / EPG</string>
<string name="settings_sports_provider_league_ids">聯賽 ID</string>
<string name="settings_sports_provider_league_ids_hint">選填。只有此供應商要求時才新增聯賽 ID。</string>
+ <string name="settings_sports_custom_scopes_hint">自訂 JSON 提供者請以 sport/league 格式輸入範圍,並以逗號分隔。</string>
<string name="nav_sports">體育</string>
<string name="settings_sports_settings_description">管理已連線的體育資料提供者。</string>
<string name="settings_sports_data_providers_title">體育資料提供者</string>
@@ -930,4 +931,8 @@
<string name="settings_sports_custom_definition_example_action">插入範例</string>
<string name="settings_sports_custom_definition_placeholder">貼上提供者 JSON</string>
<string name="settings_open_source_licenses">開放原始碼授權與聲明</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">載入 JSON 檔案</string>
+ <string name="settings_sports_custom_definition_file_too_large">JSON 檔案超過 32 KB 上限</string>
+ <string name="settings_sports_custom_definition_file_error">無法載入此 JSON 檔案</string>
+ <string name="settings_experimental_badge">實驗性</string>
+</resources>
diff --git a/feature/settings/src/main/res/values-zh/strings.xml b/feature/settings/src/main/res/values-zh/strings.xml
index 933d38e3..1290799a 100644
--- a/feature/settings/src/main/res/values-zh/strings.xml
+++ b/feature/settings/src/main/res/values-zh/strings.xml
@@ -870,6 +870,7 @@
<string name="settings_sports_event_source_epg">电视节目指南 / EPG</string>
<string name="settings_sports_provider_league_ids">联赛 ID</string>
<string name="settings_sports_provider_league_ids_hint">可选。仅当此提供商要求时才添加联赛 ID。</string>
+ <string name="settings_sports_custom_scopes_hint">对于自定义 JSON 提供方,请按 sport/league 格式输入范围,并用逗号分隔。</string>
<string name="nav_sports">体育</string>
<string name="settings_sports_settings_description">管理已连接的体育数据提供方。</string>
<string name="settings_sports_data_providers_title">体育数据提供方</string>
@@ -931,4 +932,8 @@
<string name="settings_sports_custom_definition_example_action">插入示例</string>
<string name="settings_sports_custom_definition_placeholder">粘贴提供商 JSON</string>
<string name="settings_open_source_licenses">开源许可证和声明</string>
-</resources>
\ No newline at end of file
+ <string name="settings_sports_custom_definition_load_file">加载 JSON 文件</string>
+ <string name="settings_sports_custom_definition_file_too_large">JSON 文件超过 32 KB 限制</string>
+ <string name="settings_sports_custom_definition_file_error">无法加载此 JSON 文件</string>
+ <string name="settings_experimental_badge">实验性</string>
+</resources>
diff --git a/feature/settings/src/main/res/values/strings.xml b/feature/settings/src/main/res/values/strings.xml
index 2d923973..764ed0cb 100644
--- a/feature/settings/src/main/res/values/strings.xml
+++ b/feature/settings/src/main/res/values/strings.xml
@@ -949,6 +949,7 @@
<string name="settings_sports_event_source_epg">TV Guide / EPG</string>
<string name="settings_sports_provider_league_ids">League IDs</string>
<string name="settings_sports_provider_league_ids_hint">Optional. Add league IDs only when this provider requires them.</string>
+ <string name="settings_sports_custom_scopes_hint">For a Custom JSON provider, enter scopes as sport/league, separated by commas.</string>
<string name="nav_sports">Sports</string>
<string name="settings_sports_settings_description">Manage connected sports data providers.</string>
<string name="settings_sports_data_providers_title">Sports data providers</string>
@@ -1010,4 +1011,8 @@
<string name="settings_sports_custom_definition_example_action">Insert example</string>
<string name="settings_sports_custom_definition_placeholder">Paste provider JSON</string>
<string name="settings_open_source_licenses">Open-source licenses and notices</string>
+ <string name="settings_sports_custom_definition_load_file">Load JSON file</string>
+ <string name="settings_sports_custom_definition_file_too_large">The JSON file is larger than the 32 KB limit</string>
+ <string name="settings_sports_custom_definition_file_error">Could not load this JSON file</string>
+ <string name="settings_experimental_badge">Experimental</string>
</resources>
diff --git a/feature/settings/src/test/java/com/streamvault/feature/settings/presentation/SettingsDestinationTest.kt b/feature/settings/src/test/java/com/streamvault/feature/settings/presentation/SettingsDestinationTest.kt
index 08bbd680..7a4120b1 100644
--- a/feature/settings/src/test/java/com/streamvault/feature/settings/presentation/SettingsDestinationTest.kt
+++ b/feature/settings/src/test/java/com/streamvault/feature/settings/presentation/SettingsDestinationTest.kt
@@ -17,6 +17,12 @@ class SettingsDestinationTest {
assertTrue(SettingsCategory.entries.none { it.name == "BROWSING" })
}
+ @Test fun `about is last in the navigation list after independent feature settings`() {
+ assertEquals(SettingsCategory.ABOUT, SettingsCategory.entries.last())
+ assertTrue(SettingsCategory.entries.indexOf(SettingsCategory.TRAKT) < SettingsCategory.entries.indexOf(SettingsCategory.ABOUT))
+ assertTrue(SettingsCategory.entries.indexOf(SettingsCategory.SPORTS) < SettingsCategory.entries.indexOf(SettingsCategory.ABOUT))
+ }
+
@Test fun `playback has short focused pages and remote has its own home`() {
assertTrue(SettingsPage.entries.count { it.categoryId == 1 } in 5..8)
assertEquals(SettingsCategory.APP.legacyId, SettingsPage.REMOTE.categoryId)