Ship the real club crests in the APK, and fix the CI licence step

Resolving crests from Wikipedia at runtime never produced a visible badge
on the TV and left nothing in the log to debug, so the shield fallback was
all anyone ever saw. They are now downloaded once at build time by
tools/fetch-crests.py into assets/crests (git-ignored, so no trademarked
artwork is committed) and loaded from there — instant, and independent of
the network.

CI: accepting SDK licences by piping "yes" into sdkmanager died of SIGPIPE
(exit 141) under pipefail; the licence hashes are written directly now.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

.github/workflows/build.yml

@@ -4,24 +4,56 @@ on:
   push:
   workflow_dispatch:
 
+# No marketplace actions: this Gitea runner resolves bare action names
+# against the local instance, and even with full URLs it cannot resolve
+# annotated tags ("unsupported object type"). Everything below is plain
+# shell, which also keeps the job readable.
 jobs:
   build:
     runs-on: ubuntu-latest
+    env:
+      ANDROID_SDK_ROOT: /opt/android-sdk
+      CMDLINE_TOOLS: https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip
     steps:
-      - uses: actions/checkout@v4
+      - name: Checkout
+        run: |
+          git init -q .
+          git remote add origin "${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}.git"
+          git fetch -q --depth 1 origin "${GITHUB_SHA}"
+          git checkout -q FETCH_HEAD
 
-      - uses: actions/setup-java@v4
+      - name: Install JDK
-        with:
+        run: |
-          distribution: temurin
+          apt-get update -qq
-          java-version: "17"
+          DEBIAN_FRONTEND=noninteractive apt-get install -y -qq openjdk-17-jdk-headless > /dev/null
+          java -version
 
-      - uses: gradle/actions/setup-gradle@v4
+      - name: Install Android SDK
+        run: |
+          mkdir -p "$ANDROID_SDK_ROOT/cmdline-tools"
+          curl -sSL -o /tmp/tools.zip "$CMDLINE_TOOLS"
+          unzip -q /tmp/tools.zip -d "$ANDROID_SDK_ROOT/cmdline-tools"
+          mv "$ANDROID_SDK_ROOT/cmdline-tools/cmdline-tools" "$ANDROID_SDK_ROOT/cmdline-tools/latest"
+          # Accept licences by writing the hashes: piping "yes" into
+          # sdkmanager dies of SIGPIPE (exit 141) under pipefail.
+          mkdir -p "$ANDROID_SDK_ROOT/licenses"
+          echo "24333f8a63b6825ea9c5514f83c2829b004d1fee" > "$ANDROID_SDK_ROOT/licenses/android-sdk-license"
+          echo "84831b9409646a918e30573bab4c9c91346d8abd" > "$ANDROID_SDK_ROOT/licenses/android-sdk-preview-license"
+          "$ANDROID_SDK_ROOT/cmdline-tools/latest/bin/sdkmanager" \
+            "platforms;android-35" "build-tools;35.0.0" "platform-tools" > /dev/null
+          echo "sdk.dir=$ANDROID_SDK_ROOT" > local.properties
+
+      - name: Fetch club crests
+        run: python3 tools/fetch-crests.py || true
+
+      - name: Unit tests
+        run: ./gradlew testDebugUnitTest --no-daemon --stacktrace
 
       - name: Build debug APK
-        run: ./gradlew assembleDebug --stacktrace
+        run: ./gradlew assembleDebug --no-daemon --stacktrace
 
-      - name: Upload APK
+      - name: Summary
-        uses: actions/upload-artifact@v4
+        if: always()
-        with:
+        run: |
-          name: castarr-debug-apk
+          echo "APK:"; ls -la app/build/outputs/apk/debug/ 2>/dev/null || echo "  (kein Build)"
-          path: app/build/outputs/apk/debug/app-debug.apk
+          echo "Tests:"; ls tests/runs/junit/ 2>/dev/null || echo "  (keine Reports)"

.gitignore

@@ -5,3 +5,4 @@ local.properties
 *.iml
 .kotlin/
 tests/runs/
+app/src/main/assets/crests/

app/build.gradle.kts

@@ -12,8 +12,8 @@ android {
         applicationId = "dev.castarr.tv"
         minSdk = 26
         targetSdk = 35
-        versionCode = 27
+        versionCode = 31
-        versionName = "0.10.1"
+        versionName = "0.10.5"
     }
 
     // Release signing from environment (see ~/.keys/castarr-release.env on the

app/src/main/java/dev/castarr/tv/AppState.kt

@@ -27,6 +27,7 @@ class AppState(
     val dispatcharr: DispatcharrRepository,
 ) {
     private val prefs = context.getSharedPreferences("app", Context.MODE_PRIVATE)
+    val crests = dev.castarr.tv.data.Crests(context)
 
     var screen by mutableStateOf(Screen.LIVE)
     var playerVisible by mutableStateOf(false)

app/src/main/java/dev/castarr/tv/MainActivity.kt

@@ -50,7 +50,14 @@ class MainActivity : ComponentActivity(), ControlServer.Listener {
         server.startServer()
         state.remoteAvailable = server.running
         setContent { CastarrApp(state) }
-        lifecycleScope.launch { UpdateChecker.check(state) }
+        lifecycleScope.launch {
+            // At start-up and then occasionally: a TV often keeps the same
+            // app process alive for days.
+            while (true) {
+                UpdateChecker.check(state)
+                delay(UPDATE_CHECK_INTERVAL_MS)
+            }
+        }
     }
 
     private fun onPlaybackChanged() {
@@ -325,5 +332,6 @@ class MainActivity : ComponentActivity(), ControlServer.Listener {
         const val TICK_INTERVAL_MS = 2_000L
         const val SEEK_STEP_SECONDS = 10L
         const val DIGIT_COMMIT_MS = 1_800L
+        const val UPDATE_CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000L
     }
 }

app/src/main/java/dev/castarr/tv/data/Crests.kt

@@ -0,0 +1,63 @@
+package dev.castarr.tv.data
+
+import android.content.Context
+import android.util.Log
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.json.JSONObject
+import java.net.HttpURLConnection
+import java.net.URL
+import java.net.URLEncoder
+
+/**
+ * Resolves club crests at runtime from Wikipedia's page summary. The badges
+ * are trademarks, so they are fetched and cached on the device rather than
+ * shipped with the app — nothing copyrighted lives in the repository.
+ */
+class Crests(context: Context) {
+
+    private val prefs = context.getSharedPreferences("crests", Context.MODE_PRIVATE)
+
+    /** Cached crest URL for a club, fetched once and then reused. */
+    suspend fun urlFor(article: String): String? = withContext(Dispatchers.IO) {
+        prefs.getString(article, null)?.takeIf { it.isNotEmpty() }?.let {
+            return@withContext it
+        }
+        val resolved = runCatching { fetch(article) }
+            .onFailure { Log.w(TAG, "crest lookup failed for $article: $it") }
+            .getOrNull()
+        if (resolved != null) {
+            Log.i(TAG, "crest for $article: $resolved")
+            prefs.edit().putString(article, resolved).apply()
+        } else {
+            // Deliberately not cached: a single failed lookup (no network
+            // yet at start-up) must not hide the crest forever.
+            Log.w(TAG, "no crest for $article")
+        }
+        resolved
+    }
+
+    private fun fetch(article: String): String? {
+        val encoded = URLEncoder.encode(article, "UTF-8").replace("+", "%20")
+        val connection = URL("$SUMMARY$encoded").openConnection() as HttpURLConnection
+        return try {
+            connection.connectTimeout = 10_000
+            connection.readTimeout = 10_000
+            connection.setRequestProperty("User-Agent", USER_AGENT)
+            connection.setRequestProperty("Accept", "application/json")
+            val body = connection.inputStream.bufferedReader().use { it.readText() }
+            JSONObject(body).optJSONObject("thumbnail")?.optString("source")
+                ?.takeIf { it.isNotEmpty() }
+                // Drop the analytics query the API appends.
+                ?.substringBefore("?")
+        } finally {
+            connection.disconnect()
+        }
+    }
+
+    private companion object {
+        const val TAG = "Crests"
+        const val SUMMARY = "https://de.wikipedia.org/api/rest_v1/page/summary/"
+        const val USER_AGENT = "Castarr TV (private use)"
+    }
+}

app/src/main/java/dev/castarr/tv/data/TeamFilters.kt

@@ -5,8 +5,8 @@ import androidx.compose.ui.graphics.Color
 /**
  * Per-club shortcut to "where does my club play tonight": a rail entry that
  * lists every channel whose EPG mentions the club within the next few hours.
- * Club crests are trademarks, so the icon is a plain shield in the club
+ * Crests are fetched from Wikipedia at runtime and cached on the device;
- * colours rather than the real badge.
+ * the club colours are the fallback while that is pending or unavailable.
  */
 data class TeamFilter(
     val key: String,
@@ -18,6 +18,8 @@ data class TeamFilter(
     val needles: List<String>,
     val primary: Color,
     val secondary: Color,
+    /** German Wikipedia article the crest is resolved from. */
+    val article: String,
 ) {
     fun matches(title: String): Boolean {
         val haystack = title.lowercase()
@@ -43,7 +45,8 @@ object TeamFilters {
         needles: List<String>,
         primary: Long,
         secondary: Long,
-    ) = TeamFilter(key, label, fullName, needles, Color(primary), Color(secondary))
+        article: String = fullName,
+    ) = TeamFilter(key, label, fullName, needles, Color(primary), Color(secondary), article)
 
     /** Clubs of the top three German divisions. */
     val all: List<TeamFilter> = listOf(
@@ -94,7 +97,7 @@ object TeamFilters {
         club("duisburg", "MSV", "MSV Duisburg", listOf("msv duisburg", "duisburg"), 0xFF004E9E, WHITE),
         club("mannheim", "SVWM", "SV Waldhof Mannheim", listOf("waldhof mannheim", "waldhof"), 0xFF0B4EA2, WHITE),
         club("wehen", "SVWW", "SV Wehen Wiesbaden", listOf("wehen wiesbaden", "wehen"), 0xFFE1000F, BLACK),
-        club("ulm", "SSV", "SSV Ulm 1846", listOf("ssv ulm"), 0xFFE1000F, WHITE),
+        club("ulm", "SSV", "SSV Ulm 1846", listOf("ssv ulm"), 0xFFE1000F, WHITE, article = "SSV Ulm 1846 Fußball"),
         club("regensburg", "SSVJ", "SSV Jahn Regensburg", listOf("jahn regensburg", "regensburg"), 0xFFE1000F, WHITE),
         club("verl", "SCV", "SC Verl", listOf("sc verl"), 0xFF00703C, WHITE),
         club("viktoria", "VKÖ", "Viktoria Köln", listOf("viktoria köln"), 0xFFE1000F, WHITE),
@@ -105,7 +108,7 @@ object TeamFilters {
         club("ingolstadt", "FCI", "FC Ingolstadt 04", listOf("ingolstadt"), 0xFFE1000F, BLACK),
         club("wuppertal", "WSV", "Wuppertaler SV", listOf("wuppertaler sv"), 0xFFE1000F, 0xFF0B4EA2),
         club("stuttgart-ii", "VfB2", "VfB Stuttgart II", listOf("vfb stuttgart ii"), 0xFFE32219, BLACK),
-        club("hoffenheim-ii", "TSG2", "TSG Hoffenheim II", listOf("hoffenheim ii"), 0xFF1C63B7, BLACK),
+        club("hoffenheim-ii", "TSG2", "TSG Hoffenheim II", listOf("hoffenheim ii"), 0xFF1C63B7, BLACK, article = "TSG 1899 Hoffenheim"),
     )
 
     /** Clubs switched on for a viewer before they touch the settings. */

app/src/main/java/dev/castarr/tv/ui/CastarrApp.kt

@@ -132,6 +132,10 @@ private fun TopBar(state: AppState) {
             }
             Spacer(Modifier.width(18.dp))
         }
+        state.updateAvailable?.let { version ->
+            UpdateChip(version) { state.screen = AppState.Screen.SETTINGS }
+            Spacer(Modifier.width(10.dp))
+        }
         GearButton {
             state.screen = if (state.screen == AppState.Screen.LIVE) AppState.Screen.SETTINGS
             else AppState.Screen.LIVE
@@ -139,6 +143,33 @@ private fun TopBar(state: AppState) {
     }
 }
 
+/**
+ * Shown in the top bar as soon as the start-up check finds a newer
+ * release — otherwise an update would only be noticed by someone who
+ * happens to open the settings.
+ */
+@Composable
+private fun UpdateChip(version: String, onClick: () -> Unit) {
+    Surface(
+        onClick = onClick,
+        shape = ClickableSurfaceDefaults.shape(RoundedCornerShape(999.dp)),
+        colors = ClickableSurfaceDefaults.colors(
+            containerColor = CastarrColors.accentDim,
+            contentColor = CastarrColors.accent,
+            focusedContainerColor = CastarrColors.accent,
+            focusedContentColor = CastarrColors.onAccent,
+        ),
+    ) {
+        Text(
+            "Update $version",
+            fontFamily = AppFont,
+            fontSize = 13.sp,
+            fontWeight = FontWeight.Medium,
+            modifier = Modifier.padding(horizontal = 14.dp, vertical = 8.dp),
+        )
+    }
+}
+
 /** Round settings button with a drawn gear (glyphs render as emoji). */
 @Composable
 private fun GearButton(onClick: () -> Unit) {

app/src/main/java/dev/castarr/tv/ui/LiveScreen.kt

@@ -193,7 +193,7 @@ fun LiveScreen(state: AppState) {
                     label = club.label,
                     count = matchesByTeam[club.key]?.size ?: 0,
                     selected = state.activeTeam == club.key,
-                    leading = { Crest(club) },
+                    leading = { Crest(club, state) },
                     modifier = intoList.then(
                         if (state.activeTeam == club.key) Modifier.focusRequester(railFocus)
                         else Modifier
@@ -433,11 +433,26 @@ private fun ChannelRow(
 }
 
 /**
- * Stand-in for the club badge: real crests are trademarks, so this draws a
+ * The club badge. The images ship in the APK (fetched at build time by
- * simple shield in the club colours instead.
+ * tools/fetch-crests.py, never committed), so nothing has to load over the
+ * network; the coloured shield stands in if one is ever missing.
  */
 @Composable
-private fun Crest(team: dev.castarr.tv.data.TeamFilter) {
+private fun Crest(team: dev.castarr.tv.data.TeamFilter, state: AppState) {
+    Box(Modifier.size(20.dp), contentAlignment = Alignment.Center) {
+        SubcomposeAsyncImage(
+            model = "file:///android_asset/crests/${team.key}.png",
+            contentDescription = null,
+            contentScale = ContentScale.Fit,
+            modifier = Modifier.fillMaxSize(),
+            loading = { ShieldFallback(team) },
+            error = { ShieldFallback(team) },
+        )
+    }
+}
+
+@Composable
+private fun ShieldFallback(team: dev.castarr.tv.data.TeamFilter) {
     Canvas(Modifier.size(18.dp)) {
         val w = size.width
         val h = size.height

app/src/main/java/dev/castarr/tv/ui/SettingsScreen.kt

@@ -6,6 +6,8 @@ import androidx.compose.foundation.Canvas
 import androidx.compose.foundation.Image
 import androidx.compose.foundation.background
 import androidx.compose.foundation.border
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
@@ -14,9 +16,13 @@ import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.foundation.shape.CircleShape
 import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.runtime.Composable
@@ -80,7 +86,14 @@ fun SettingsScreen(state: AppState) {
             .fillMaxSize()
             .padding(horizontal = 40.dp, vertical = 12.dp)
     ) {
-        Column(Modifier.weight(1.25f), verticalArrangement = Arrangement.spacedBy(16.dp)) {
+        // The cards outgrew one screen once club menus arrived; focus
+        // movement scrolls this column along.
+        Column(
+            Modifier
+                .weight(1.25f)
+                .verticalScroll(rememberScrollState()),
+            verticalArrangement = Arrangement.spacedBy(16.dp),
+        ) {
             SettingsCard("Konto") {
                 if (state.auth.isLoggedIn) {
                     Row(
@@ -308,7 +321,13 @@ fun SettingsScreen(state: AppState) {
 @Composable
 private fun PickerDialog(picker: Picker, onClose: () -> Unit) {
     val selectedFocus = remember { FocusRequester() }
-    LaunchedEffect(Unit) { selectedFocus.requestFocus() }
+    // A requester bound to no composed row throws; with no preselection
+    // (adding something new) there is deliberately no such row.
+    LaunchedEffect(Unit) { runCatching { selectedFocus.requestFocus() } }
+    val listState = rememberLazyListState()
+    LaunchedEffect(picker.selected) {
+        if (picker.selected > 0) listState.scrollToItem(picker.selected)
+    }
     Dialog(
         onDismissRequest = onClose,
         properties = DialogProperties(usePlatformDefaultWidth = false),
@@ -337,7 +356,11 @@ private fun PickerDialog(picker: Picker, onClose: () -> Unit) {
                 letterSpacing = 2.sp,
                 modifier = Modifier.padding(start = 14.dp, bottom = 10.dp),
             )
-            picker.options.forEachIndexed { index, option ->
+            LazyColumn(
+                state = listState,
+                modifier = Modifier.heightIn(max = 420.dp),
+            ) {
+            itemsIndexed(picker.options) { index, option ->
                 val selected = index == picker.selected
                 Surface(
                     onClick = {
@@ -346,7 +369,11 @@ private fun PickerDialog(picker: Picker, onClose: () -> Unit) {
                     },
                     modifier = Modifier
                         .fillMaxWidth()
-                        .then(if (selected) Modifier.focusRequester(selectedFocus) else Modifier),
+                        .then(
+                            if (selected || (picker.selected < 0 && index == 0))
+                                Modifier.focusRequester(selectedFocus)
+                            else Modifier
+                        ),
                     shape = ClickableSurfaceDefaults.shape(rowShape),
                     scale = ClickableSurfaceDefaults.scale(focusedScale = 1f),
                     colors = ClickableSurfaceDefaults.colors(
@@ -390,6 +417,7 @@ private fun PickerDialog(picker: Picker, onClose: () -> Unit) {
             }
         }
         }
+    }
 }
 
 /** Current value plus a small drawn caret, shown at a row's trailing edge. */

tools/fetch-crests.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""Downloads club crests into the APK's assets at build time.
+
+The badges are trademarks: they are fetched into a generated, git-ignored
+folder so the repository stays free of them while the app ships with them
+and needs no network at runtime.
+"""
+import json
+import os
+import re
+import sys
+import time
+import urllib.parse
+import urllib.request
+
+OUT = sys.argv[1] if len(sys.argv) > 1 else "app/src/main/assets/crests"
+SRC = "app/src/main/java/dev/castarr/tv/data/TeamFilters.kt"
+SUMMARY = "https://de.wikipedia.org/api/rest_v1/page/summary/"
+UA = {"User-Agent": "Castarr build script (private use)"}
+
+os.makedirs(OUT, exist_ok=True)
+kotlin = open(SRC, encoding="utf-8").read()
+entries = re.findall(r'club\((.*?)\)\s*,\s*(?://.*)?$', kotlin, re.M | re.S)
+clubs = []
+for raw in re.findall(r'club\(\s*"([^"]+)",\s*"[^"]*",\s*"([^"]+)"[^\n]*', kotlin):
+    clubs.append(raw)
+# an explicit article = "..." wins over the club name
+overrides = dict(re.findall(r'club\(\s*"([^"]+)"[^\n]*article = "([^"]+)"', kotlin))
+clubs = [(k, overrides.get(k, n)) for k, n in clubs]
+
+fetched = skipped = failed = 0
+for key, full_name in clubs:
+    target = os.path.join(OUT, f"{key}.png")
+    if os.path.exists(target) and os.path.getsize(target) > 0:
+        skipped += 1
+        continue
+    try:
+        url = SUMMARY + urllib.parse.quote(full_name)
+        with urllib.request.urlopen(urllib.request.Request(url, headers=UA), timeout=20) as r:
+            thumb = json.load(r).get("thumbnail", {}).get("source")
+        if not thumb:
+            raise ValueError("no thumbnail")
+        with urllib.request.urlopen(urllib.request.Request(thumb, headers=UA), timeout=20) as r:
+            data = r.read()
+        with open(target, "wb") as f:
+            f.write(data)
+        fetched += 1
+    except Exception as exc:  # noqa: BLE001 - best effort, shield is the fallback
+        print(f"  {key}: {exc}", file=sys.stderr)
+        failed += 1
+    # Wikipedia rate-limits bursts; this runs rarely and caches.
+    time.sleep(1.2)
+
+print(f"crests: {fetched} geladen, {skipped} vorhanden, {failed} fehlgeschlagen")