From e80fa4252c6471eda4ec184188b1f35dac2c8ed3 Mon Sep 17 00:00:00 2001 From: Kayos Date: Sun, 24 May 2026 17:54:41 -0700 Subject: [PATCH 01/72] =?UTF-8?q?Clean=20cutover=20=E2=80=94=20Kotlin=20of?= =?UTF-8?q?f=20NewPipeExtractor,=20onto=20uniffi.strawcore?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Brings the Phase U Android-side integration onto a feature branch where the rust wrapper now bridges to strawcore-core (the new NPE port) instead of rustypipe. * strawApp/build.gradle.kts — JNA dep + cargoBuild + cargoBuildHost + uniffiBindgen + the merge/compile task wiring. libs.newpipe .extractor dropped. * StrawApp.kt — uniffi.strawcore.initLogging(); NewPipe.init() gone * 5 ViewModels (Search/VideoDetail/Player/Channel/Subscriptions) swapped to call uniffi.strawcore.{search,streamInfo,channelInfo} * PlayerScreen + PlaybackService adjusted for the new StreamInfo shape (dash_mpd_url / hls_url instead of NPE's manifests) * IosSafeHttpDataSource carried forward — strawcore-core gives us Android-primary URLs so the iOS cap path is mostly dead code, but kept as belt-and-suspenders for the rare HLS-fallback * NewPipeDownloader.kt + util/Thumbnails.kt deleted Files taken wholesale from sulkta branch — the wrapper's UniFFI surface is identical between sulkta (rustypipe-backed) and the current Phase-7-bridged-to-strawcore-core code, so Kotlin doesn't care which extractor is under the hood. --- strawApp/build.gradle.kts | 95 +++++++++- .../main/kotlin/com/sulkta/straw/StrawApp.kt | 14 +- .../straw/extractor/NewPipeDownloader.kt | 96 ---------- .../straw/feature/channel/ChannelViewModel.kt | 62 ++----- .../straw/feature/detail/VideoDetailScreen.kt | 52 ++++-- .../feature/detail/VideoDetailViewModel.kt | 105 +++++------ .../feature/feed/SubscriptionFeedViewModel.kt | 96 +++++----- .../straw/feature/player/PlaybackService.kt | 14 +- .../straw/feature/player/PlayerScreen.kt | 32 +++- .../straw/feature/player/PlayerViewModel.kt | 41 ++--- .../straw/feature/search/SearchViewModel.kt | 44 ++--- .../main/kotlin/com/sulkta/straw/net/Http.kt | 25 +++ .../sulkta/straw/net/IosSafeHttpDataSource.kt | 173 ++++++++++++++++++ .../kotlin/com/sulkta/straw/net/RydClient.kt | 5 +- .../sulkta/straw/net/SponsorBlockClient.kt | 5 +- .../com/sulkta/straw/util/Thumbnails.kt | 24 --- 16 files changed, 516 insertions(+), 367 deletions(-) delete mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/extractor/NewPipeDownloader.kt create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/net/IosSafeHttpDataSource.kt delete mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/util/Thumbnails.kt diff --git a/strawApp/build.gradle.kts b/strawApp/build.gradle.kts index 13ef39dde..774719420 100644 --- a/strawApp/build.gradle.kts +++ b/strawApp/build.gradle.kts @@ -95,7 +95,9 @@ dependencies { implementation(libs.coil.network.okhttp) // NewPipeExtractor (JVM/Android-only) + its OkHttp dep - implementation(libs.newpipe.extractor) + // libs.newpipe.extractor — REMOVED in Path C-6. Extractor is now strawcore + // (Rust + rustypipe via UniFFI). See rust/strawcore/ + the cargoBuild + + // uniffiBindgen Gradle tasks below. implementation(libs.squareup.okhttp) // JSON for SponsorBlock + Return YouTube Dislike clients @@ -110,4 +112,95 @@ dependencies { implementation("androidx.media3:media3-session:1.4.1") // Guava ListenableFuture support for awaiting MediaController connect. implementation("androidx.concurrent:concurrent-futures-ktx:1.2.0") + + // strawcore — Rust YouTube extractor via UniFFI/JNA. Built by the + // cargoBuild + uniffiBindgen tasks below; phase U-2+ exposes search / + // streamInfo / channelInfo to replace NewPipeExtractor. + implementation("net.java.dev.jna:jna:5.14.0@aar") } + +// ============================================================================= +// Phase U-1 / Path-C-2 — Rust core build glue. +// +// Two tasks chain into the Android build: +// cargoBuild — cross-compiles rust/strawcore for the four Android ABIs +// via cargo-ndk and drops the .so files in strawApp/src/main/jniLibs/. +// uniffiBindgen — generates the Kotlin bindings from the freshly-built lib +// into strawApp/src/main/java/uniffi/strawcore/. +// +// Both depend on: +// - cargo + rustup with the four Android targets installed +// - cargo-ndk on PATH +// - ANDROID_NDK_HOME pointing at an NDK with the right toolchains +// All of that lives in the crafting-table container. +// ============================================================================= + +val rustRoot = file("../rust").absolutePath +val jniLibsDir = file("src/main/jniLibs").absolutePath +val bindingsDir = file("src/main/java").absolutePath + +val cargoHome: String = System.getenv("CARGO_HOME") ?: "/caches/cargo" +val cargoBin: String = "$cargoHome/bin/cargo" +val ndkHome: String = System.getenv("ANDROID_NDK_HOME") + ?: System.getenv("ANDROID_NDK_ROOT") + ?: "/caches/android-sdk/ndk/27.2.12479018" +// Honor CARGO_TARGET_DIR if set (we redirect it to /caches on crafting-table +// because the container's writable rootfs hits 100% before the cross-compile +// for 4 ABIs finishes). Falls back to the default `/target`. +val cargoTargetDir: String = System.getenv("CARGO_TARGET_DIR") + ?: "$rustRoot/target" + +val cargoBuild by tasks.registering(Exec::class) { + group = "rust" + description = "Cross-compile strawcore for all Android ABIs via cargo-ndk." + workingDir = file(rustRoot) + environment("ANDROID_NDK_HOME", ndkHome) + environment("PATH", "$cargoHome/bin:${System.getenv("PATH") ?: ""}") + commandLine = listOf( + cargoBin, "ndk", + "-t", "arm64-v8a", + "-t", "armeabi-v7a", + "-t", "x86", + "-t", "x86_64", + "-o", jniLibsDir, + "build", "--release", "-p", "strawcore", + ) + standardOutput = System.out + errorOutput = System.err +} + +val cargoBuildHost by tasks.registering(Exec::class) { + group = "rust" + description = "Build host-arch debug strawcore so bindgen can read its UniFFI metadata." + workingDir = file(rustRoot) + environment("PATH", "$cargoHome/bin:${System.getenv("PATH") ?: ""}") + commandLine = listOf(cargoBin, "build", "-p", "strawcore") + standardOutput = System.out + errorOutput = System.err +} + +val uniffiBindgen by tasks.registering(Exec::class) { + group = "rust" + description = "Generate Kotlin bindings for strawcore via uniffi-bindgen." + dependsOn(cargoBuildHost) + workingDir = file(rustRoot) + environment("PATH", "$cargoHome/bin:${System.getenv("PATH") ?: ""}") + commandLine = listOf( + cargoBin, "run", "--quiet", "--bin", "uniffi-bindgen", "--", + "generate", + "--library", "$cargoTargetDir/debug/libstrawcore.so", + "--crate", "strawcore", + "--language", "kotlin", + "--no-format", + "--out-dir", bindingsDir, + ) + standardOutput = System.out + errorOutput = System.err +} + +// Make sure Android's JNI-libs merge picks up the freshly built .so files, +// and Kotlin compilation can resolve the generated bindings. +tasks.matching { it.name.startsWith("merge") && it.name.endsWith("JniLibFolders") } + .configureEach { dependsOn(cargoBuild) } +tasks.matching { it.name.startsWith("compile") && it.name.endsWith("Kotlin") } + .configureEach { dependsOn(uniffiBindgen) } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt index 6d8a1defc..7444f3ab8 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt @@ -9,19 +9,15 @@ import android.app.Application import com.sulkta.straw.data.History import com.sulkta.straw.data.Settings import com.sulkta.straw.data.Subscriptions -import com.sulkta.straw.extractor.NewPipeDownloader -import org.schabi.newpipe.extractor.NewPipe -import org.schabi.newpipe.extractor.localization.ContentCountry -import org.schabi.newpipe.extractor.localization.Localization class StrawApp : Application() { override fun onCreate() { super.onCreate() - NewPipe.init( - NewPipeDownloader.init(), - Localization("en", "US"), - ContentCountry("US"), - ) + // Path C-7: route Rust `log::*` calls into Android logcat under tag + // "strawcore". Without this, every log line emitted from rustypipe / + // strawcore is silently dropped, making playback regressions invisible + // from `adb logcat`. + uniffi.strawcore.initLogging() History.init(this) Settings.init(this) Subscriptions.init(this) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/extractor/NewPipeDownloader.kt b/strawApp/src/main/kotlin/com/sulkta/straw/extractor/NewPipeDownloader.kt deleted file mode 100644 index bc185b5e0..000000000 --- a/strawApp/src/main/kotlin/com/sulkta/straw/extractor/NewPipeDownloader.kt +++ /dev/null @@ -1,96 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2026 Sulkta-Coop - * SPDX-License-Identifier: GPL-3.0-or-later - * - * Minimal OkHttp-backed implementation of NewPipeExtractor's Downloader. - * No cookies, no recaptcha handling — anonymous browsing only. Modeled after - * NewPipe's DownloaderImpl but trimmed down for fork scope. - */ - -package com.sulkta.straw.extractor - -import com.sulkta.straw.net.NEWPIPE_MAX_BYTES -import com.sulkta.straw.net.cappedString -import okhttp3.OkHttpClient -import okhttp3.RequestBody.Companion.toRequestBody -import org.schabi.newpipe.extractor.downloader.Downloader -import org.schabi.newpipe.extractor.downloader.Request -import org.schabi.newpipe.extractor.downloader.Response -import java.io.IOException -import java.util.concurrent.TimeUnit - -class NewPipeDownloader private constructor( - private val client: OkHttpClient, -) : Downloader() { - - override fun execute(request: Request): Response { - val httpMethod = request.httpMethod() - val url = request.url() - val headers = request.headers() - val data: ByteArray? = request.dataToSend() - - val requestBody = data?.toRequestBody(null) - - val okBuilder = okhttp3.Request.Builder() - .method(httpMethod, requestBody) - .url(url) - - // AUD-HIGH: copy NPE headers BEFORE adding our explicit UA so the - // explicit UA wins; guard against header values containing \r/\n - // which OkHttp's addHeader rejects via IAE (turning a poisoned - // response into an app crash). - headers.forEach { (name, values) -> - if (name.equals("User-Agent", ignoreCase = true)) return@forEach - okBuilder.removeHeader(name) - values.forEach { value -> - runCatching { okBuilder.addHeader(name, value) } - } - } - okBuilder.removeHeader("User-Agent") - okBuilder.addHeader("User-Agent", USER_AGENT) - - val okResponse = client.newCall(okBuilder.build()).execute() - val body = okResponse.body - // AUD-HIGH: bounded read to defend against OOM via gigabyte response. - val bodyString = body?.cappedString(NEWPIPE_MAX_BYTES) ?: "" - val responseHeaders = okResponse.headers.toMultimap() - val latestUrl = okResponse.request.url.toString() - if (okResponse.code == 429) { - okResponse.close() - throw IOException("HTTP 429 — rate limited") - } - okResponse.close() - - return Response( - okResponse.code, - okResponse.message, - responseHeaders, - bodyString, - latestUrl, - ) - } - - companion object { - const val USER_AGENT = - "Mozilla/5.0 (Linux; Android 14) AppleWebKit/537.36 (KHTML, like Gecko) " + - "Chrome/120.0.0.0 Mobile Safari/537.36" - - @Volatile private var instance: NewPipeDownloader? = null - - fun init(builder: OkHttpClient.Builder? = null): NewPipeDownloader { - val client = (builder ?: OkHttpClient.Builder()) - .connectTimeout(30, TimeUnit.SECONDS) - .readTimeout(30, TimeUnit.SECONDS) - .writeTimeout(30, TimeUnit.SECONDS) - .build() - val d = NewPipeDownloader(client) - instance = d - return d - } - - fun get(): NewPipeDownloader = instance - ?: error("NewPipeDownloader not initialized — call init() first") - - fun client(): OkHttpClient = get().client - } -} diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt index e3cb6b2e4..90dd8ea05 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt @@ -1,6 +1,10 @@ /* * SPDX-FileCopyrightText: 2026 Sulkta-Coop * SPDX-License-Identifier: GPL-3.0-or-later + * + * Phase U-4 / Path C-5: ChannelInfo + Videos tab moved to strawcore + * (rustypipe). The two separate ChannelInfo.getInfo + ChannelTabInfo.getInfo + * calls collapse into one Rust round-trip. */ package com.sulkta.straw.feature.channel @@ -8,19 +12,10 @@ package com.sulkta.straw.feature.channel import androidx.lifecycle.ViewModel import androidx.lifecycle.viewModelScope import com.sulkta.straw.feature.search.StreamItem -import com.sulkta.straw.util.bestThumbnail -import kotlinx.coroutines.Dispatchers -import org.schabi.newpipe.extractor.NewPipe -import org.schabi.newpipe.extractor.ServiceList import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.asStateFlow import kotlinx.coroutines.launch -import kotlinx.coroutines.withContext -import org.schabi.newpipe.extractor.channel.ChannelInfo -import org.schabi.newpipe.extractor.channel.tabs.ChannelTabInfo -import org.schabi.newpipe.extractor.channel.tabs.ChannelTabs -import org.schabi.newpipe.extractor.stream.StreamInfoItem data class ChannelUiState( val loading: Boolean = true, @@ -40,43 +35,24 @@ class ChannelViewModel : ViewModel() { _ui.value = ChannelUiState(loading = true) viewModelScope.launch { try { - val service = NewPipe.getService(ServiceList.YouTube.serviceId) - val info = withContext(Dispatchers.IO) { - ChannelInfo.getInfo(service, channelUrl) + val ch = uniffi.strawcore.channelInfo(channelUrl) + val videos = ch.videos.map { v -> + StreamItem( + url = v.url, + title = v.title.ifBlank { "(no title)" }, + uploader = v.uploader, + uploaderUrl = v.uploaderUrl, + thumbnail = v.thumbnail, + durationSeconds = v.durationSeconds, + viewCount = v.viewCount, + ) } - // AUD-HIGH: pick the Videos tab specifically rather than - // info.tabs.firstOrNull() which is YouTube's "Home" (a - // curated mix that mostly drops via filterIsInstance). - val videosTab = info.tabs.firstOrNull { - it.contentFilters.contains(ChannelTabs.VIDEOS) - } ?: info.tabs.firstOrNull() - val videos: List = if (videosTab != null) { - withContext(Dispatchers.IO) { - runCatching { - ChannelTabInfo.getInfo(service, videosTab) - .relatedItems - .filterIsInstance() - .map { - StreamItem( - url = it.url, - title = it.name ?: "(no title)", - uploader = it.uploaderName ?: info.name ?: "", - uploaderUrl = it.uploaderUrl ?: channelUrl, - thumbnail = bestThumbnail(it.thumbnails), - durationSeconds = it.duration, - viewCount = it.viewCount, - ) - } - }.getOrDefault(emptyList()) - } - } else emptyList() - _ui.value = ChannelUiState( loading = false, - name = info.name ?: "", - subscriberCount = info.subscriberCount, - banner = bestThumbnail(info.banners), - avatar = bestThumbnail(info.avatars), + name = ch.name, + subscriberCount = ch.subscriberCount, + banner = ch.banner, + avatar = ch.avatar, videos = videos, ) } catch (t: Throwable) { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index 1720dd4da..ecb92d66e 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -69,7 +69,7 @@ import androidx.media3.exoplayer.source.MergingMediaSource import androidx.media3.exoplayer.source.ProgressiveMediaSource import androidx.media3.ui.PlayerView import coil3.compose.AsyncImage -import com.sulkta.straw.extractor.NewPipeDownloader +import com.sulkta.straw.net.STRAW_USER_AGENT import com.sulkta.straw.util.formatCount import com.sulkta.straw.util.formatViews import com.sulkta.straw.util.stripHtml @@ -284,10 +284,8 @@ fun VideoDetailScreen( confirmButton = { Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) { Button(onClick = { - val audio = info?.audioStreams - ?.filter { it.content?.isNotBlank() == true } - ?.maxByOrNull { it.bitrate ?: 0 } - ?.content + // info is now uniffi.strawcore.StreamInfo (Path C-4). + val audio = info?.audioOnly?.maxByOrNull { it.bitrate }?.url if (audio != null) { val id = Downloader.enqueue(context, audio, d.title, DownloadKind.Audio) val msg = if (id > 0) "audio queued" else "download refused (bad URL)" @@ -298,14 +296,8 @@ fun VideoDetailScreen( showDownloadDialog = false }) { Text("Audio") } Button(onClick = { - val video = info?.videoStreams - ?.filter { it.content?.isNotBlank() == true } - ?.maxByOrNull { it.bitrate ?: 0 } - ?.content - ?: info?.videoOnlyStreams - ?.filter { it.content?.isNotBlank() == true } - ?.maxByOrNull { it.bitrate ?: 0 } - ?.content + val video = info?.combined?.maxByOrNull { it.bitrate }?.url + ?: info?.videoOnly?.maxByOrNull { it.bitrate }?.url if (video != null) { val id = Downloader.enqueue(context, video, d.title, DownloadKind.Video) val msg = if (id > 0) "video queued" else "download refused (bad URL)" @@ -409,16 +401,35 @@ private fun InlinePlayer( .build() } - DisposableEffect(Unit) { - onDispose { exoPlayer.release() } + // Path C-7: surface ExoPlayer failures into UI state. Without this an + // HTTP 403 / source error showed as a stuck black box with the pause + // controls visible — directly enabled a false-positive in the prior + // verification pass. + var playbackError by remember { mutableStateOf(null) } + DisposableEffect(exoPlayer) { + val listener = object : androidx.media3.common.Player.Listener { + override fun onPlayerError(error: androidx.media3.common.PlaybackException) { + playbackError = + "${error.errorCodeName}: ${error.message ?: "(no message)"}" + } + } + exoPlayer.addListener(listener) + onDispose { + exoPlayer.removeListener(listener) + exoPlayer.release() + } } val resolved = state.resolved LaunchedEffect(resolved) { val r = resolved ?: return@LaunchedEffect - val dataSourceFactory = DefaultHttpDataSource.Factory() - .setUserAgent(NewPipeDownloader.USER_AGENT) - .setAllowCrossProtocolRedirects(true) + // Path C-7: chunk open-ended Range requests so iOS googlevideo URLs + // don't 403 on first byte. See net/IosSafeHttpDataSource.kt. + val dataSourceFactory = com.sulkta.straw.net.IosSafeHttpDataSource.Factory( + DefaultHttpDataSource.Factory() + .setUserAgent(STRAW_USER_AGENT) + .setAllowCrossProtocolRedirects(true) + ) val source = when { r.dashMpdUrl != null -> DashMediaSource.Factory(dataSourceFactory) .createMediaSource(MediaItem.fromUri(r.dashMpdUrl)) @@ -452,6 +463,11 @@ private fun InlinePlayer( color = MaterialTheme.colorScheme.error, modifier = Modifier.padding(16.dp), ) + playbackError != null -> Text( + "playback error: $playbackError", + color = MaterialTheme.colorScheme.error, + modifier = Modifier.padding(16.dp), + ) resolved?.isPlayable != true -> Text( "no playable stream", color = Color.White, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt index 06ee83b6c..63dea79c3 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt @@ -1,6 +1,10 @@ /* * SPDX-FileCopyrightText: 2026 Sulkta-Coop * SPDX-License-Identifier: GPL-3.0-or-later + * + * Phase U-3 / Path C-4: streamInfo() moves from NewPipeExtractor (Java) to + * strawcore (Rust + rustypipe via UniFFI). Channel fetch for + * `moreFromChannel` stays on NPE until C-5. */ package com.sulkta.straw.feature.detail @@ -13,20 +17,12 @@ import com.sulkta.straw.data.WatchHistoryItem import com.sulkta.straw.net.RydClient import com.sulkta.straw.net.RydVotes import com.sulkta.straw.net.SponsorBlockClient -import com.sulkta.straw.util.bestThumbnail import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.asStateFlow import kotlinx.coroutines.launch import kotlinx.coroutines.withContext -import org.schabi.newpipe.extractor.NewPipe -import org.schabi.newpipe.extractor.ServiceList -import org.schabi.newpipe.extractor.channel.ChannelInfo -import org.schabi.newpipe.extractor.channel.tabs.ChannelTabInfo -import org.schabi.newpipe.extractor.channel.tabs.ChannelTabs -import org.schabi.newpipe.extractor.stream.StreamInfo -import org.schabi.newpipe.extractor.stream.StreamInfoItem data class VideoDetail( val id: String, @@ -48,8 +44,8 @@ data class VideoDetailUiState( val loading: Boolean = true, val detail: VideoDetail? = null, val error: String? = null, - // Stored on success for handoff to player. Not in UI. - val streamInfo: StreamInfo? = null, + // Stored on success for handoff to the player + Download dialog. Not in UI. + val streamInfo: uniffi.strawcore.StreamInfo? = null, ) class VideoDetailViewModel : ViewModel() { @@ -66,11 +62,12 @@ class VideoDetailViewModel : ViewModel() { _ui.value = VideoDetailUiState(loading = true) viewModelScope.launch { try { - val info = withContext(Dispatchers.IO) { StreamInfo.getInfo(streamUrl) } + // strawcore.streamInfo is suspend on tokio; no Dispatchers.IO wrap. + val info = uniffi.strawcore.streamInfo(streamUrl) val videoId = info.id - val thumb = bestThumbnail(info.thumbnails) - val title = info.name ?: "(no title)" - val uploader = info.uploaderName ?: "" + val thumb = info.thumbnail + val title = info.title.ifBlank { "(no title)" } + val uploader = info.uploader runCatching { History.get().recordWatch( @@ -92,51 +89,43 @@ class VideoDetailViewModel : ViewModel() { val sbCount = if (sbCats.isEmpty()) 0 else withContext(Dispatchers.IO) { runCatching { SponsorBlockClient.fetch(videoId, sbCats).size }.getOrDefault(0) } - val related = info.relatedItems - ?.filterIsInstance() - ?.map { it -> - com.sulkta.straw.feature.search.StreamItem( - url = it.url, - title = it.name ?: "(no title)", - uploader = it.uploaderName ?: "", - uploaderUrl = it.uploaderUrl, - thumbnail = bestThumbnail(it.thumbnails), - durationSeconds = it.duration, - viewCount = it.viewCount, - ) - } ?: emptyList() - // More from this channel — anchored to the uploader the user - // already chose. Best-effort: empty if the fetch fails so the - // detail screen still renders. Filters out the current video. + // strawcore returns `related` as List. Map to the + // Kotlin StreamItem shape used elsewhere. + val related = info.related.map { r -> + com.sulkta.straw.feature.search.StreamItem( + url = r.url, + title = r.title.ifBlank { "(no title)" }, + uploader = r.uploader, + uploaderUrl = r.uploaderUrl, + thumbnail = r.thumbnail, + durationSeconds = r.durationSeconds, + viewCount = r.viewCount, + ) + } + + // More from this channel via strawcore.channelInfo — one + // Rust round-trip returns the channel's Videos tab pre-mapped. + val uploaderUrl = info.uploaderUrl val moreFromChannel: List = - if (info.uploaderUrl.isNullOrBlank()) emptyList() - else withContext(Dispatchers.IO) { - runCatching { - val service = NewPipe.getService(ServiceList.YouTube.serviceId) - val ch = ChannelInfo.getInfo(service, info.uploaderUrl) - val videosTab = ch.tabs.firstOrNull { - it.contentFilters.contains(ChannelTabs.VIDEOS) - } ?: ch.tabs.firstOrNull() - if (videosTab == null) emptyList() - else ChannelTabInfo.getInfo(service, videosTab) - .relatedItems - .filterIsInstance() - .filter { it.url != streamUrl } - .take(20) - .map { si -> - com.sulkta.straw.feature.search.StreamItem( - url = si.url, - title = si.name ?: "(no title)", - uploader = si.uploaderName ?: uploader, - uploaderUrl = si.uploaderUrl ?: info.uploaderUrl, - thumbnail = bestThumbnail(si.thumbnails), - durationSeconds = si.duration, - viewCount = si.viewCount, - ) - } - }.getOrDefault(emptyList()) - } + if (uploaderUrl.isNullOrBlank()) emptyList() + else runCatching { + val ch = uniffi.strawcore.channelInfo(uploaderUrl) + ch.videos + .filter { it.url != streamUrl } + .take(20) + .map { v -> + com.sulkta.straw.feature.search.StreamItem( + url = v.url, + title = v.title.ifBlank { "(no title)" }, + uploader = v.uploader.ifBlank { uploader }, + uploaderUrl = v.uploaderUrl ?: uploaderUrl, + thumbnail = v.thumbnail, + durationSeconds = v.durationSeconds, + viewCount = v.viewCount, + ) + } + }.getOrDefault(emptyList()) _ui.value = VideoDetailUiState( loading = false, @@ -146,7 +135,7 @@ class VideoDetailViewModel : ViewModel() { uploader = uploader, uploaderUrl = info.uploaderUrl, viewCount = info.viewCount, - description = info.description?.content ?: "", + description = info.description, thumbnail = thumb, ryd = ryd, sbSegmentCount = sbCount, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt index 93ca74467..d7f27b11c 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt @@ -3,8 +3,12 @@ * SPDX-License-Identifier: GPL-3.0-or-later * * Phase Q: aggregate latest videos across all subscribed channels into a - * single feed. Fans out per-channel ChannelInfo + ChannelTabs.VIDEOS - * fetches in parallel, merges by view count desc, caps at 200 items. + * single feed. Fans out per-channel channelInfo() fetches in parallel, + * merges by view count desc, caps at 200 items. + * + * Path C-5: each per-channel fetch is now ONE strawcore.channelInfo() + * call instead of two NewPipeExtractor round-trips (ChannelInfo.getInfo + + * ChannelTabInfo.getInfo). Halves the network work for the feed. * * Audit fixes (2026-05-24 pass #2): * HIGH-6: cancel any prior in-flight refresh when a new one starts, cap @@ -20,9 +24,7 @@ import androidx.lifecycle.ViewModel import androidx.lifecycle.viewModelScope import com.sulkta.straw.data.Subscriptions import com.sulkta.straw.feature.search.StreamItem -import com.sulkta.straw.util.bestThumbnail import com.sulkta.straw.util.strawLogW -import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.Job import kotlinx.coroutines.async import kotlinx.coroutines.awaitAll @@ -34,14 +36,7 @@ import kotlinx.coroutines.flow.update import kotlinx.coroutines.launch import kotlinx.coroutines.sync.Semaphore import kotlinx.coroutines.sync.withPermit -import kotlinx.coroutines.withContext import kotlinx.coroutines.withTimeoutOrNull -import org.schabi.newpipe.extractor.NewPipe -import org.schabi.newpipe.extractor.ServiceList -import org.schabi.newpipe.extractor.channel.ChannelInfo -import org.schabi.newpipe.extractor.channel.tabs.ChannelTabInfo -import org.schabi.newpipe.extractor.channel.tabs.ChannelTabs -import org.schabi.newpipe.extractor.stream.StreamInfoItem data class SubscriptionFeedUiState( val loading: Boolean = false, @@ -82,55 +77,46 @@ class SubscriptionFeedViewModel : ViewModel() { _ui.update { it.copy(loading = true, error = null) } inFlight = viewModelScope.launch { try { - val items = withContext(Dispatchers.IO) { - val service = NewPipe.getService(ServiceList.YouTube.serviceId) - val perChannelMax = 5 - val gate = Semaphore(parallelism) - coroutineScope { - val deferreds = channels.map { ch -> - async { - gate.withPermit { - withTimeoutOrNull(perChannelTimeoutMs) { - runCatching { - val info = ChannelInfo.getInfo(service, ch.url) - val tab = info.tabs.firstOrNull { - it.contentFilters.contains(ChannelTabs.VIDEOS) - } ?: info.tabs.firstOrNull() - ?: return@runCatching emptyList() - ChannelTabInfo.getInfo(service, tab) - .relatedItems - .filterIsInstance() - .take(perChannelMax) - .map { si -> - StreamItem( - url = si.url, - title = si.name ?: "(no title)", - uploader = si.uploaderName ?: ch.name, - uploaderUrl = si.uploaderUrl ?: ch.url, - thumbnail = bestThumbnail(si.thumbnails), - durationSeconds = si.duration, - viewCount = si.viewCount, - ) - } - }.onFailure { - strawLogW("StrawFeed") { "channel fetch failed for ${ch.url}: ${it.message}" } - }.getOrDefault(emptyList()) - } ?: run { - strawLogW("StrawFeed") { "channel fetch timed out: ${ch.url}" } - emptyList() - } + val perChannelMax = 5 + val gate = Semaphore(parallelism) + val items = coroutineScope { + val deferreds = channels.map { ch -> + async { + gate.withPermit { + withTimeoutOrNull(perChannelTimeoutMs) { + runCatching { + val info = uniffi.strawcore.channelInfo(ch.url) + info.videos + .take(perChannelMax) + .map { v -> + StreamItem( + url = v.url, + title = v.title.ifBlank { "(no title)" }, + uploader = v.uploader.ifBlank { ch.name }, + uploaderUrl = v.uploaderUrl ?: ch.url, + thumbnail = v.thumbnail, + durationSeconds = v.durationSeconds, + viewCount = v.viewCount, + ) + } + }.onFailure { + strawLogW("StrawFeed") { "channel fetch failed for ${ch.url}: ${it.message}" } + }.getOrDefault(emptyList()) + } ?: run { + strawLogW("StrawFeed") { "channel fetch timed out: ${ch.url}" } + emptyList() } } } - deferreds.awaitAll() } - .flatten() - // No reliable upload-timestamp from extractor's StreamInfoItem - // in all cases — sort by view count desc as a soft proxy for - // recency-popularity within the recent window. - .sortedByDescending { it.viewCount } - .take(200) + deferreds.awaitAll() } + .flatten() + // No reliable upload-timestamp on the search-item shape — sort + // by view count desc as a soft proxy for recency-popularity + // within the recent window. + .sortedByDescending { it.viewCount } + .take(200) _ui.update { SubscriptionFeedUiState( loading = false, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt index 40b4083c0..5cf85506c 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt @@ -50,7 +50,8 @@ import androidx.media3.exoplayer.source.DefaultMediaSourceFactory import androidx.media3.session.MediaSession import androidx.media3.session.MediaSessionService import com.sulkta.straw.StrawActivity -import com.sulkta.straw.extractor.NewPipeDownloader +import com.sulkta.straw.net.IosSafeHttpDataSource +import com.sulkta.straw.net.STRAW_USER_AGENT @UnstableApi class PlaybackService : MediaSessionService() { @@ -62,9 +63,14 @@ class PlaybackService : MediaSessionService() { super.onCreate() ensureChannel() - val httpFactory = DefaultHttpDataSource.Factory() - .setUserAgent(NewPipeDownloader.USER_AGENT) - .setAllowCrossProtocolRedirects(true) + // Path C-7: wrap in IosSafeHttpDataSource so ExoPlayer's open-ended + // Range requests get chunked into bounded reads. iOS-bound googlevideo + // URLs 403 on `Range: bytes=N-` but accept `Range: bytes=N-M`. + val httpFactory = IosSafeHttpDataSource.Factory( + DefaultHttpDataSource.Factory() + .setUserAgent(STRAW_USER_AGENT) + .setAllowCrossProtocolRedirects(true) + ) val mediaSourceFactory = DefaultMediaSourceFactory(this) .setDataSourceFactory(httpFactory) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt index 1478ca857..caf3d79ef 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt @@ -70,7 +70,7 @@ import androidx.media3.exoplayer.hls.HlsMediaSource import androidx.media3.exoplayer.source.MergingMediaSource import androidx.media3.exoplayer.source.ProgressiveMediaSource import androidx.media3.ui.PlayerView -import com.sulkta.straw.extractor.NewPipeDownloader +import com.sulkta.straw.net.STRAW_USER_AGENT import com.sulkta.straw.net.SbSegment import com.sulkta.straw.util.strawLogI import kotlinx.coroutines.delay @@ -114,6 +114,20 @@ fun PlayerScreen( MediaSession.Builder(context, exoPlayer).build() } + // Path C-7: surface ExoPlayer failures so they don't read as "stuck spinner" + // (Audit Finding 2). Posts to playbackError state which the UI renders. + var playbackError by remember { mutableStateOf(null) } + DisposableEffect(exoPlayer) { + val listener = object : androidx.media3.common.Player.Listener { + override fun onPlayerError(error: androidx.media3.common.PlaybackException) { + playbackError = + "${error.errorCodeName}: ${error.message ?: "(no message)"}" + } + } + exoPlayer.addListener(listener) + onDispose { exoPlayer.removeListener(listener) } + } + DisposableEffect(Unit) { onDispose { mediaSession.release() @@ -168,9 +182,13 @@ fun PlayerScreen( LaunchedEffect(resolved) { val r = resolved ?: return@LaunchedEffect - val dataSourceFactory = DefaultHttpDataSource.Factory() - .setUserAgent(NewPipeDownloader.USER_AGENT) - .setAllowCrossProtocolRedirects(true) + // Path C-7: chunk open-ended Range requests so iOS googlevideo URLs + // don't 403 on first byte. + val dataSourceFactory = com.sulkta.straw.net.IosSafeHttpDataSource.Factory( + DefaultHttpDataSource.Factory() + .setUserAgent(STRAW_USER_AGENT) + .setAllowCrossProtocolRedirects(true) + ) val source = when { r.dashMpdUrl != null -> DashMediaSource.Factory(dataSourceFactory) @@ -251,6 +269,12 @@ fun PlayerScreen( modifier = Modifier.padding(16.dp), ) + playbackError != null -> Text( + "playback error: $playbackError", + color = MaterialTheme.colorScheme.error, + modifier = Modifier.padding(16.dp), + ) + resolved?.isPlayable != true -> Text( "no playable stream found", modifier = Modifier.padding(16.dp), diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerViewModel.kt index ee523f634..5dd9eeaa3 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerViewModel.kt @@ -1,13 +1,16 @@ /* * SPDX-FileCopyrightText: 2026 Sulkta-Coop * SPDX-License-Identifier: GPL-3.0-or-later + * + * Phase U-3 / Path C-4: extractor moved from NewPipeExtractor (Java) to + * strawcore (Rust + rustypipe via UniFFI). PlayerScreen still calls + * vm.resolve(url) the same way — the engine underneath flipped. */ package com.sulkta.straw.feature.player import androidx.lifecycle.ViewModel import androidx.lifecycle.viewModelScope -import com.sulkta.straw.data.MaxResolution import com.sulkta.straw.data.Settings import com.sulkta.straw.net.SbSegment import com.sulkta.straw.net.SponsorBlockClient @@ -17,7 +20,6 @@ import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.asStateFlow import kotlinx.coroutines.launch import kotlinx.coroutines.withContext -import org.schabi.newpipe.extractor.stream.StreamInfo data class ResolvedPlayback( val title: String, @@ -48,8 +50,11 @@ class PlayerViewModel : ViewModel() { _ui.value = PlayerUiState(loading = true) viewModelScope.launch { try { - val info = withContext(Dispatchers.IO) { StreamInfo.getInfo(streamUrl) } + // strawcore.streamInfo is a suspend fun running on the tokio + // runtime baked into libstrawcore.so — no Dispatchers.IO needed. + val info = uniffi.strawcore.streamInfo(streamUrl) val videoId = info.id + val sbCategories = Settings.get().sbCategories.value.map { it.key } val segments = if (sbCategories.isEmpty()) { emptyList() @@ -61,32 +66,24 @@ class PlayerViewModel : ViewModel() { } val maxRes = Settings.get().maxResolution.value.ceiling - fun heightOf(q: String?): Int = - q?.removeSuffix("p")?.takeWhile { it.isDigit() }?.toIntOrNull() ?: 0 - // Audit HIGH-8: when no stream is under the resolution ceiling - // (e.g. user picked 144p but the video only has 360p+), fall - // back to the lowest-resolution available instead of returning - // null and showing a black-screen player. - fun pickVideo(streams: List?): String? { - if (streams.isNullOrEmpty()) return null - val withContent = streams.filter { it.content?.isNotBlank() == true } - val filtered = withContent.filter { heightOf(it.getResolution()) <= maxRes } - val pool = filtered.ifEmpty { withContent } - return pool.maxByOrNull { it.bitrate ?: 0 }?.content + // Audit HIGH-8 carry-over: filter by max resolution but fall + // back to lowest available if the ceiling excludes everything. + fun pickVideo(streams: List): String? { + if (streams.isEmpty()) return null + val filtered = streams.filter { it.height <= maxRes } + val pool = filtered.ifEmpty { streams } + return pool.maxByOrNull { it.bitrate }?.url } - val combined = pickVideo(info.videoStreams) - val videoOnly = pickVideo(info.videoOnlyStreams) - val audioOnly = info.audioStreams - ?.filter { it.content?.isNotBlank() == true } - ?.maxByOrNull { it.bitrate ?: 0 } - ?.content + val combined = pickVideo(info.combined) + val videoOnly = pickVideo(info.videoOnly) + val audioOnly = info.audioOnly.maxByOrNull { it.bitrate }?.url _ui.value = PlayerUiState( loading = false, resolved = ResolvedPlayback( - title = info.name ?: "", + title = info.title, videoUrl = videoOnly, audioUrl = audioOnly, combinedUrl = combined, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt index 5ef859be4..338388af9 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt @@ -8,17 +8,10 @@ package com.sulkta.straw.feature.search import androidx.lifecycle.ViewModel import androidx.lifecycle.viewModelScope import com.sulkta.straw.data.History -import com.sulkta.straw.util.bestThumbnail -import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.asStateFlow import kotlinx.coroutines.launch -import kotlinx.coroutines.withContext -import org.schabi.newpipe.extractor.NewPipe -import org.schabi.newpipe.extractor.ServiceList -import org.schabi.newpipe.extractor.search.SearchInfo -import org.schabi.newpipe.extractor.stream.StreamInfoItem data class SearchUiState( val query: String = "", @@ -52,7 +45,23 @@ class SearchViewModel : ViewModel() { _ui.value = _ui.value.copy(loading = true, error = null, results = emptyList()) viewModelScope.launch { try { - val items = withContext(Dispatchers.IO) { search(q) } + // Phase U-2 / Path C-3: rustypipe via UniFFI. The bindgen-generated + // `search()` is already a suspend fun running on the tokio runtime + // baked into libstrawcore.so — no Dispatchers.IO wrapper needed, + // the JNI call returns to us on the caller dispatcher when the + // future completes. + val rustItems = uniffi.strawcore.search(q) + val items = rustItems.map { r -> + StreamItem( + url = r.url, + title = r.title.ifBlank { "(no title)" }, + uploader = r.uploader, + uploaderUrl = r.uploaderUrl, + thumbnail = r.thumbnail, + durationSeconds = r.durationSeconds, + viewCount = r.viewCount, + ) + } _ui.value = _ui.value.copy(loading = false, results = items) } catch (t: Throwable) { _ui.value = _ui.value.copy( @@ -62,23 +71,4 @@ class SearchViewModel : ViewModel() { } } } - - private fun search(query: String): List { - val service = NewPipe.getService(ServiceList.YouTube.serviceId) - val qh = service.searchQHFactory.fromQuery(query, emptyList(), "") - val info = SearchInfo.getInfo(service, qh) - return info.relatedItems - .filterIsInstance() - .map { - StreamItem( - url = it.url, - title = it.name ?: "(no title)", - uploader = it.uploaderName ?: "", - uploaderUrl = it.uploaderUrl, - thumbnail = bestThumbnail(it.thumbnails), - durationSeconds = it.duration, - viewCount = it.viewCount, - ) - } - } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/net/Http.kt b/strawApp/src/main/kotlin/com/sulkta/straw/net/Http.kt index 4a3524a61..a8d629d86 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/net/Http.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/net/Http.kt @@ -13,9 +13,34 @@ package com.sulkta.straw.net +import okhttp3.OkHttpClient import okhttp3.ResponseBody import okio.Buffer import java.io.IOException +import java.util.concurrent.TimeUnit + +/** + * Path C-6 / Phase U-5: USER_AGENT + shared OkHttpClient that previously + * lived on NewPipeDownloader. After ripping NewPipeExtractor, the RYD + + * SponsorBlock + ExoPlayer HTTP factories still need both. One shared + * client is fine. + */ +const val STRAW_USER_AGENT: String = + "Mozilla/5.0 (Linux; Android 14) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Mobile Safari/537.36 Straw/1.0" + +@Volatile +private var sharedClient: OkHttpClient? = null + +fun strawHttpClient(): OkHttpClient = + sharedClient ?: synchronized(STRAW_USER_AGENT) { + sharedClient ?: OkHttpClient.Builder() + .connectTimeout(15, TimeUnit.SECONDS) + .readTimeout(30, TimeUnit.SECONDS) + .followRedirects(true) + .followSslRedirects(true) + .build() + .also { sharedClient = it } + } fun ResponseBody.cappedString(maxBytes: Long): String { val cl = contentLength() diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/net/IosSafeHttpDataSource.kt b/strawApp/src/main/kotlin/com/sulkta/straw/net/IosSafeHttpDataSource.kt new file mode 100644 index 000000000..ffb92672f --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/net/IosSafeHttpDataSource.kt @@ -0,0 +1,173 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Path C-7 (post-audit): wrap DefaultHttpDataSource so each open() that + * lacks a bounded length turns into a sequence of bounded Range requests + * (default 1 MiB chunks). + * + * Background: rustypipe's iOS InnerTube client returns pre-signed + * googlevideo URLs. Those URLs reject an open-ended `Range: bytes=N-` + * with HTTP 403 — they only accept bounded `Range: bytes=N-M`. ExoPlayer + * issues open-ended Range requests by default, which made every non-HLS + * iOS-origin video 403 on first byte. This shim makes ExoPlayer + * iOS-shaped without touching media-source selection. + * + * Verified via 2026-05-24 emulator audit (memory/audit-straw-vc16-emulator-2026-05-24.md): + * curl -r 0-1023 → 206 OK + * curl -H "Range: bytes=0-" → 403 (any UA) + * curl no Range → 403 + */ + +package com.sulkta.straw.net + +import android.util.Log +import androidx.media3.common.C +import androidx.media3.common.util.UnstableApi +import androidx.media3.datasource.DataSpec +import androidx.media3.datasource.HttpDataSource + +private const val TAG = "IosSafeDS" + +@UnstableApi +class IosSafeHttpDataSource( + private val inner: HttpDataSource, + private val chunkBytes: Long = DEFAULT_CHUNK_BYTES, +) : HttpDataSource by inner { + + /** The original (caller-supplied) spec — kept so we can compute the next chunk. */ + private var originalSpec: DataSpec? = null + + /** How many bytes have been read since the caller's open(). */ + private var totalRead: Long = 0 + + /** Bytes left in the current inner-open chunk. -1 = unknown end. */ + private var chunkRemaining: Long = 0 + + override fun open(dataSpec: DataSpec): Long { + // When length is set, respect it but still cap the first inner-open to + // chunkBytes. When length is unset, request a chunk and we'll roll + // forward on subsequent reads. + val requestLen = if (dataSpec.length == C.LENGTH_UNSET.toLong()) { + chunkBytes + } else { + minOf(dataSpec.length, chunkBytes) + } + // NOTE: DataSpec.subrange(offset, length) ADDS offset to the existing + // position — so subrange(position, length) doubles the position. Use + // buildUpon().setLength(...) which preserves position and only bounds + // the byte length. This is what makes ExoPlayer's first Range header + // come out as `bytes=N-M` (closed, accepted by googlevideo iOS URLs) + // instead of `bytes=N-` (open, rejected with 403). + val bounded = dataSpec.buildUpon().setLength(requestLen).build() + // Surface itag + mime from query so we can tell video vs audio apart in logs. + val u = dataSpec.uri + val itag = u.getQueryParameter("itag") + val mime = u.getQueryParameter("mime") + Log.i( + TAG, + "open: pos=${bounded.position} len=${bounded.length} " + + "(origLen=${dataSpec.length}, chunkBytes=$chunkBytes) " + + "itag=$itag mime=$mime host=${u.host}", + ) + Log.i(TAG, "open url=${u.toString()}") + originalSpec = dataSpec + totalRead = 0 + // inner.open() returns the BOUNDED chunk's length. Track it so we + // know when to roll to the next chunk. + chunkRemaining = try { + inner.open(bounded) + } catch (t: Throwable) { + Log.w(TAG, "open failed: ${t.javaClass.simpleName}: ${t.message}") + throw t + } + Log.i(TAG, "open: inner returned chunkRemaining=$chunkRemaining") + // Report the original (potentially unbounded) length to the caller — + // ExoPlayer cares about the overall length, not our internal chunking. + return if (dataSpec.length == C.LENGTH_UNSET.toLong()) { + C.LENGTH_UNSET.toLong() + } else { + dataSpec.length + } + } + + override fun read(buffer: ByteArray, offset: Int, length: Int): Int { + if (length == 0) return 0 + // Need a fresh chunk? + if (chunkRemaining == 0L) { + val spec = originalSpec ?: return C.RESULT_END_OF_INPUT + inner.close() + val nextPos = spec.position + totalRead + val remainingOverall = if (spec.length == C.LENGTH_UNSET.toLong()) { + Long.MAX_VALUE + } else { + spec.length - totalRead + } + if (remainingOverall <= 0L) return C.RESULT_END_OF_INPUT + val nextLen = remainingOverall.coerceAtMost(chunkBytes) + // Same as in open() — use buildUpon().setPosition/setLength rather + // than subrange() so the absolute position stays meaningful. + val nextSpec = spec.buildUpon() + .setPosition(nextPos) + .setLength(nextLen) + .build() + chunkRemaining = inner.open(nextSpec) + } + // Cap the read against what's left in this chunk. + val toRead = if (chunkRemaining < 0L) { + // Inner doesn't know its end either; just read what was asked. + length + } else { + length.toLong().coerceAtMost(chunkRemaining).toInt() + } + val read = inner.read(buffer, offset, toRead) + if (read != C.RESULT_END_OF_INPUT) { + totalRead += read.toLong() + if (chunkRemaining > 0L) chunkRemaining -= read.toLong() + // If chunkRemaining hits 0 here, the next read() call will roll + // to the next chunk via the block at the top. + } else if (chunkRemaining > 0L) { + // Inner ran out before its advertised end. Force chunk roll on + // next read() so we re-open at the next position. + chunkRemaining = 0L + } + return read + } + + override fun close() { + try { + inner.close() + } finally { + originalSpec = null + totalRead = 0 + chunkRemaining = 0 + } + } + + /** Factory: wrap any inner HttpDataSource.Factory. */ + @UnstableApi + class Factory( + private val innerFactory: HttpDataSource.Factory, + private val chunkBytes: Long = DEFAULT_CHUNK_BYTES, + ) : HttpDataSource.Factory { + override fun createDataSource(): HttpDataSource = + IosSafeHttpDataSource(innerFactory.createDataSource(), chunkBytes) + + override fun setDefaultRequestProperties( + defaultRequestProperties: Map, + ): HttpDataSource.Factory { + innerFactory.setDefaultRequestProperties(defaultRequestProperties) + return this + } + } + + companion object { + // YT's iOS-bound googlevideo URLs accept bounded `Range: bytes=N-M` + // requests up to roughly 900 KiB before flipping to 403. Empirically + // measured 2026-05-24 on Lucy egress: bytes=0-917503 (~896 KiB) → 206; + // bytes=0-999999 (~977 KiB) → 403. 512 KiB gives a 2× safety margin — + // small enough to survive future tightening, large enough to keep the + // open() round-trip count tolerable for a long video. + const val DEFAULT_CHUNK_BYTES: Long = 512L * 1024 + } +} diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/net/RydClient.kt b/strawApp/src/main/kotlin/com/sulkta/straw/net/RydClient.kt index 7c684b4ac..817597596 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/net/RydClient.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/net/RydClient.kt @@ -8,7 +8,6 @@ package com.sulkta.straw.net -import com.sulkta.straw.extractor.NewPipeDownloader import com.sulkta.straw.util.strawLogD import com.sulkta.straw.util.strawLogW import kotlinx.serialization.Serializable @@ -34,11 +33,11 @@ object RydClient { strawLogD(TAG) { "fetch start: $videoId → $url" } val req = Request.Builder() .url(url) - .header("User-Agent", NewPipeDownloader.USER_AGENT) + .header("User-Agent", STRAW_USER_AGENT) .header("Accept", "application/json") .build() return runCatching { - NewPipeDownloader.client().newCall(req).execute().use { r -> + strawHttpClient().newCall(req).execute().use { r -> val code = r.code // AUD-HIGH: bounded body read to defend against OOM. val bodyStr = r.body?.cappedString(RYD_MAX_BYTES) ?: "" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/net/SponsorBlockClient.kt b/strawApp/src/main/kotlin/com/sulkta/straw/net/SponsorBlockClient.kt index a5bd4b555..9979e58f8 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/net/SponsorBlockClient.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/net/SponsorBlockClient.kt @@ -8,7 +8,6 @@ package com.sulkta.straw.net -import com.sulkta.straw.extractor.NewPipeDownloader import com.sulkta.straw.util.strawLogD import com.sulkta.straw.util.strawLogW import kotlinx.serialization.Serializable @@ -47,11 +46,11 @@ object SponsorBlockClient { strawLogD(TAG) { "fetch: videoId=$videoId prefix=$prefix url=$urlStr" } val req = Request.Builder() .url(urlStr) - .header("User-Agent", NewPipeDownloader.USER_AGENT) + .header("User-Agent", STRAW_USER_AGENT) .header("Accept", "application/json") .build() return runCatching { - NewPipeDownloader.client().newCall(req).execute().use { r -> + strawHttpClient().newCall(req).execute().use { r -> val code = r.code // AUD-HIGH: bounded body read. val bodyStr = r.body?.cappedString(SB_MAX_BYTES) ?: "" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/util/Thumbnails.kt b/strawApp/src/main/kotlin/com/sulkta/straw/util/Thumbnails.kt deleted file mode 100644 index 6d47e386b..000000000 --- a/strawApp/src/main/kotlin/com/sulkta/straw/util/Thumbnails.kt +++ /dev/null @@ -1,24 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2026 Sulkta-Coop - * SPDX-License-Identifier: GPL-3.0-or-later - * - * NewPipeExtractor returns thumbnails as a List with width/height - * fields. Calling .firstOrNull() picks the smallest (the list is sorted - * ascending) — which gave us pixelated thumbnails. This helper picks the - * largest by pixel area instead. - */ - -package com.sulkta.straw.util - -import org.schabi.newpipe.extractor.Image - -fun bestThumbnail(images: List?): String? { - if (images.isNullOrEmpty()) return null - return images - .maxByOrNull { - val w = it.width.takeIf { v -> v > 0 } ?: 0 - val h = it.height.takeIf { v -> v > 0 } ?: 0 - w.toLong() * h.toLong() - } - ?.url -} From f70b8b71b9a876a77d5923dbe9bbdddc26ea34f5 Mon Sep 17 00:00:00 2001 From: Kayos Date: Sun, 24 May 2026 18:45:35 -0700 Subject: [PATCH 02/72] v0.1.0-AE (vc=19): rust pipeline cutover MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit NCS Spektrem + Rick Astley both play through Rust → ExoPlayer h264 MediaCodec on android-emulator. 4s frame-diff verified, zero PlaybackException. Phase 7 + Phase 8 of the NPE port arc done. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 8577a49eb..ed530789d 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -15,6 +15,12 @@ const val NEWPIPE_APPLICATION_ID_OLD = "org.schabi.newpipe" const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // Sulkta fork — Straw -const val STRAW_VERSION_CODE = 18 -const val STRAW_VERSION_NAME = "0.1.0-AD" +// +// vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction goes through +// strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no +// NewPipeExtractor in the runtime path. Verified end-to-end on +// android-emulator: NCS Spektrem + Rick Astley both play; 4s frame-diff +// confirmed; zero PlaybackException. +const val STRAW_VERSION_CODE = 19 +const val STRAW_VERSION_NAME = "0.1.0-AE" const val STRAW_APPLICATION_ID = "com.sulkta.straw" From 709af57f42dd186c76a51e88a34d6ae6541a6676 Mon Sep 17 00:00:00 2001 From: Kayos Date: Sun, 24 May 2026 20:07:04 -0700 Subject: [PATCH 03/72] v0.1.0-AF (vc=20): channel-videos fix for subscription feed MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit vc=19 shipped with empty subscription feeds because strawcore-core's channel_info was parsing the wrong tab + the wrong renderer type. strawcore-core e6fbbb7 fixes both — second-browse to the Videos tab + parse lockupViewModel. This bump pulls that in. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 15 +++++++++------ 1 file changed, 9 insertions(+), 6 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index ed530789d..1552677c7 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -16,11 +16,14 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // Sulkta fork — Straw // -// vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction goes through +// vc=20 / 0.1.0-AF — channel-videos fix on top of the rust pipeline +// cutover. vc=19 returned empty subscription feeds because +// strawcore-core's channel_info wasn't doing the second browse for the +// Videos tab AND wasn't parsing the new lockupViewModel shape. +// +// vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no -// NewPipeExtractor in the runtime path. Verified end-to-end on -// android-emulator: NCS Spektrem + Rick Astley both play; 4s frame-diff -// confirmed; zero PlaybackException. -const val STRAW_VERSION_CODE = 19 -const val STRAW_VERSION_NAME = "0.1.0-AE" +// NewPipeExtractor in the runtime path. +const val STRAW_VERSION_CODE = 20 +const val STRAW_VERSION_NAME = "0.1.0-AF" const val STRAW_APPLICATION_ID = "com.sulkta.straw" From 599d299b2a0d146d207793e67b57a52b8ae4cd37 Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 03:55:39 +0000 Subject: [PATCH 04/72] =?UTF-8?q?vc=3D21:=20seamless=20background-audio=20?= =?UTF-8?q?handoff=20on=20=F0=9F=8E=A7=20+=20HOME=20vc=3D20=20fixed=20chan?= =?UTF-8?q?nel=20videos=20but=20left=20two=20player=20rough=20edges=20that?= =?UTF-8?q?=20Cobb=20called=20out=20on=20the=20phone:?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Tapping 🎧 (background audio) restarted the stream from the beginning instead of picking up where the foreground player was. * Pressing HOME on the player auto-entered Picture-in-Picture; what Cobb wants is seamless background audio. Both paths now share one handoff: capture exoPlayer.currentPosition, stop the activity player, start PlaybackService with EXTRA_POSITION_MS, and seekTo(position) on setMediaItem. Verified on emulator: 🎧 tap from ~34s in-track resumes service at position=34821ms. HOME-on-player triggers the same path via StrawActivity.onUserLeaveHint → PlayerLeaveHandler.handler (a tiny registry the active PlayerScreen registers in a DisposableEffect; cleared on dispose so the hook is a no-op anywhere else in the app). The previous DisposableEffect that called setAutoEnterEnabled(true) is gone; manual PiP via the ⊟ overlay button stays — that one is still useful and user-triggered. Also fixes a latent IllegalStateException that the new HOME path exposed: PlaybackService and PlayerScreen both built MediaSession with the default empty ID, which the system rejects when both live in the same process. Service now sets .setId("straw-bg") so the two sessions can coexist during the brief activity-vs-service overlap during handoff. Smoke (emulator 1440x3040): * Subscriptions feed renders (vc=20 fix carries over). * 🎧 from ~34s in NCS / Different Heaven → service playing position=34821ms, no session-ID crash. * HOME from PlayerScreen → focus moves to NexusLauncher, PlaybackService running with isForeground=true, pictureInPictureParams=null on the activity (no PiP). --- buildSrc/src/main/kotlin/ProjectConfig.kt | 12 ++++- .../kotlin/com/sulkta/straw/StrawActivity.kt | 11 +++++ .../straw/feature/player/PlaybackService.kt | 10 ++++- .../feature/player/PlayerLeaveHandler.kt | 17 +++++++ .../straw/feature/player/PlayerScreen.kt | 44 ++++++++++--------- 5 files changed, 70 insertions(+), 24 deletions(-) create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerLeaveHandler.kt diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 1552677c7..15a86913b 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -16,6 +16,14 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // Sulkta fork — Straw // +// vc=21 / 0.1.0-AG — player hand-off polish: +// * 🎧 background-audio button now captures the current position and +// resumes the foreground service from there instead of restarting. +// * HOME / recents button while on the player now hands off seamlessly +// to background audio (same position-preserving path) instead of +// auto-entering Picture-in-Picture. Manual PiP via the ⊟ overlay +// button is unchanged. +// // vc=20 / 0.1.0-AF — channel-videos fix on top of the rust pipeline // cutover. vc=19 returned empty subscription feeds because // strawcore-core's channel_info wasn't doing the second browse for the @@ -24,6 +32,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 20 -const val STRAW_VERSION_NAME = "0.1.0-AF" +const val STRAW_VERSION_CODE = 21 +const val STRAW_VERSION_NAME = "0.1.0-AG" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt index 670db54e3..57746b38c 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt @@ -21,6 +21,7 @@ import androidx.compose.runtime.DisposableEffect import androidx.compose.ui.Modifier import com.sulkta.straw.feature.channel.ChannelScreen import com.sulkta.straw.feature.detail.VideoDetailScreen +import com.sulkta.straw.feature.player.PlayerLeaveHandler import com.sulkta.straw.feature.player.PlayerScreen import com.sulkta.straw.feature.search.SearchScreen import com.sulkta.straw.feature.settings.SettingsScreen @@ -109,6 +110,16 @@ class StrawActivity : ComponentActivity() { } } + /** + * HOME / recents → seamless hand-off to background audio when the + * player screen is active. PlayerScreen registers the handler; any + * other screen leaves it null and home behaves normally. + */ + override fun onUserLeaveHint() { + super.onUserLeaveHint() + PlayerLeaveHandler.handler?.invoke() + } + /** Pull a YouTube URL out of an incoming Intent (VIEW or SEND). */ private fun pickYouTubeUrl(intent: Intent?): String? { intent ?: return null diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt index 5cf85506c..8e20dfb04 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt @@ -101,7 +101,12 @@ class PlaybackService : MediaSessionService() { PendingIntent.FLAG_IMMUTABLE, ) + // Distinct session ID so we don't collide with the activity-side + // MediaSession (also in this process) when the user hands off from + // PlayerScreen → background audio. Default ID is "" which throws + // IllegalStateException("Session ID must be unique. ID="). mediaSession = MediaSession.Builder(this, player) + .setId(MEDIA_SESSION_ID) .setSessionActivity(sessionActivityIntent) .build() } @@ -122,6 +127,7 @@ class PlaybackService : MediaSessionService() { val url = intent?.getStringExtra(EXTRA_URL)?.takeIf { isAllowedAudioUrl(it) } val title = intent?.getStringExtra(EXTRA_TITLE) val uploader = intent?.getStringExtra(EXTRA_UPLOADER) + val startPositionMs = intent?.getLongExtra(EXTRA_POSITION_MS, 0L)?.coerceAtLeast(0L) ?: 0L val player = mediaSession?.player if (url == null || player == null) { // HIGH-2: nothing to play (likely a re-launch with null intent @@ -139,7 +145,7 @@ class PlaybackService : MediaSessionService() { .build(), ) .build() - player.setMediaItem(item) + player.setMediaItem(item, startPositionMs) player.prepare() player.playWhenReady = true return START_NOT_STICKY @@ -231,8 +237,10 @@ class PlaybackService : MediaSessionService() { const val EXTRA_URL = "com.sulkta.straw.extra.URL" const val EXTRA_TITLE = "com.sulkta.straw.extra.TITLE" const val EXTRA_UPLOADER = "com.sulkta.straw.extra.UPLOADER" + const val EXTRA_POSITION_MS = "com.sulkta.straw.extra.POSITION_MS" private const val NOTIF_CHANNEL_ID = "straw.playback" private const val NOTIF_ID = 4242 + private const val MEDIA_SESSION_ID = "straw-bg" } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerLeaveHandler.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerLeaveHandler.kt new file mode 100644 index 000000000..e7f57495a --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerLeaveHandler.kt @@ -0,0 +1,17 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Bridge between StrawActivity.onUserLeaveHint() (HOME / recents button) + * and the active PlayerScreen. When the user leaves the player by pressing + * HOME, we want a seamless hand-off to the background-audio foreground + * service — not Picture-in-Picture. PlayerScreen registers a handler on + * compose, clears it on dispose; the activity calls it from the OS hook. + */ + +package com.sulkta.straw.feature.player + +object PlayerLeaveHandler { + @Volatile + var handler: (() -> Unit)? = null +} diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt index caf3d79ef..8a7e6c1ad 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt @@ -135,29 +135,29 @@ fun PlayerScreen( } } - // PiP setup: on Android 12+ tell the OS this activity can auto-enter - // PiP, so when the user presses Home or swipes away the video shrinks - // into a floating window instead of pausing/exiting. Aspect ratio is - // set eagerly so the system can sample it before the first transition. - val activity = context as? Activity - DisposableEffect(activity) { - if (activity != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) { - val params = PictureInPictureParams.Builder() - .setAspectRatio(Rational(16, 9)) - .setAutoEnterEnabled(true) - .build() - runCatching { activity.setPictureInPictureParams(params) } - } - onDispose { - // Disable auto-enter when leaving the player so the rest of the - // app doesn't accidentally PiP on background. - if (activity != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) { - val off = PictureInPictureParams.Builder() - .setAutoEnterEnabled(false) - .build() - runCatching { activity.setPictureInPictureParams(off) } + // Home / recents button → seamless hand-off to background audio service + // instead of Picture-in-Picture. PiP is still available manually via the + // ⊟ overlay button. We register a handler that the activity calls from + // onUserLeaveHint(); the handler captures currentPosition so the audio + // service resumes from the same point. Same code path that the explicit + // 🎧 button uses. + val resolvedState = androidx.compose.runtime.rememberUpdatedState(state.resolved) + DisposableEffect(Unit) { + PlayerLeaveHandler.handler = handler@{ + val r = resolvedState.value ?: return@handler + val audio = r.audioUrl ?: r.combinedUrl ?: return@handler + val position = exoPlayer.currentPosition.coerceAtLeast(0L) + runCatching { exoPlayer.stop() } + runCatching { exoPlayer.clearMediaItems() } + val intent = Intent(context, PlaybackService::class.java).apply { + component = ComponentName(context, PlaybackService::class.java) + putExtra(PlaybackService.EXTRA_URL, audio) + putExtra(PlaybackService.EXTRA_TITLE, title) + putExtra(PlaybackService.EXTRA_POSITION_MS, position) } + ContextCompat.startForegroundService(context, intent) } + onDispose { PlayerLeaveHandler.handler = null } } // AUD-MED: pause playback when app goes to background. Without this, @@ -382,12 +382,14 @@ fun PlayerScreen( Toast.makeText(context, "no audio stream", Toast.LENGTH_SHORT).show() return@OverlayButton } + val position = exoPlayer.currentPosition.coerceAtLeast(0L) runCatching { exoPlayer.stop() } runCatching { exoPlayer.clearMediaItems() } val intent = Intent(context, PlaybackService::class.java).apply { component = ComponentName(context, PlaybackService::class.java) putExtra(PlaybackService.EXTRA_URL, audio) putExtra(PlaybackService.EXTRA_TITLE, title) + putExtra(PlaybackService.EXTRA_POSITION_MS, position) } ContextCompat.startForegroundService(context, intent) Toast.makeText( From e7d45aa6b4f9827b5ceaaef0a2c998b81ce86edd Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 15:57:56 +0000 Subject: [PATCH 05/72] =?UTF-8?q?vc=3D22:=20inline=E2=86=92fullscreen=20po?= =?UTF-8?q?sition=20handoff=20+=20local=20playlists?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- buildSrc/src/main/kotlin/ProjectConfig.kt | 13 +- .../src/main/kotlin/com/sulkta/straw/Nav.kt | 8 +- .../kotlin/com/sulkta/straw/StrawActivity.kt | 20 +- .../main/kotlin/com/sulkta/straw/StrawApp.kt | 2 + .../main/kotlin/com/sulkta/straw/StrawHome.kt | 11 + .../com/sulkta/straw/data/PlaylistsStore.kt | 126 +++++++++ .../straw/feature/detail/VideoDetailScreen.kt | 128 ++++++++- .../straw/feature/player/PlayerScreen.kt | 8 + .../straw/feature/playlist/PlaylistsScreen.kt | 267 ++++++++++++++++++ 9 files changed, 575 insertions(+), 8 deletions(-) create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/data/PlaylistsStore.kt create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/feature/playlist/PlaylistsScreen.kt diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 15a86913b..3106cdb6b 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -16,6 +16,15 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // Sulkta fork — Straw // +// vc=22 / 0.1.0-AH — V-2 player polish + local playlists: +// * Inline → fullscreen now hands off seek position. Tap Play (or the +// ⛶ pill on the inline player) while the inline is mid-track and +// the fullscreen Player picks up at the same point. Same handoff +// pattern as fullscreen → background from vc=21. +// * Local playlists: drawer entry "Playlists", "Save" button on +// VideoDetail. SharedPreferences-backed, no queue/autoplay yet +// (tap an entry to open VideoDetail as normal). +// // vc=21 / 0.1.0-AG — player hand-off polish: // * 🎧 background-audio button now captures the current position and // resumes the foreground service from there instead of restarting. @@ -32,6 +41,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 21 -const val STRAW_VERSION_NAME = "0.1.0-AG" +const val STRAW_VERSION_CODE = 22 +const val STRAW_VERSION_NAME = "0.1.0-AH" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/Nav.kt b/strawApp/src/main/kotlin/com/sulkta/straw/Nav.kt index 02396749c..3e5c7edf6 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/Nav.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/Nav.kt @@ -16,9 +16,15 @@ sealed interface Screen { data object Home : Screen data object Search : Screen data object Settings : Screen + data object Playlists : Screen data class VideoDetail(val streamUrl: String, val title: String) : Screen - data class Player(val streamUrl: String, val title: String) : Screen + data class Player( + val streamUrl: String, + val title: String, + val startPositionMs: Long = 0L, + ) : Screen data class Channel(val channelUrl: String, val name: String) : Screen + data class PlaylistView(val playlistId: String, val name: String) : Screen } class Navigator(initial: Screen) { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt index 57746b38c..340dcf846 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt @@ -23,6 +23,8 @@ import com.sulkta.straw.feature.channel.ChannelScreen import com.sulkta.straw.feature.detail.VideoDetailScreen import com.sulkta.straw.feature.player.PlayerLeaveHandler import com.sulkta.straw.feature.player.PlayerScreen +import com.sulkta.straw.feature.playlist.PlaylistViewScreen +import com.sulkta.straw.feature.playlist.PlaylistsScreen import com.sulkta.straw.feature.search.SearchScreen import com.sulkta.straw.feature.settings.SettingsScreen @@ -67,6 +69,7 @@ class StrawActivity : ComponentActivity() { is Screen.Home -> StrawHome( onOpenSearch = { nav.push(Screen.Search) }, onOpenSettings = { nav.push(Screen.Settings) }, + onOpenPlaylists = { nav.push(Screen.Playlists) }, onOpenVideo = { url, title -> nav.push(Screen.VideoDetail(url, title)) }, @@ -83,8 +86,8 @@ class StrawActivity : ComponentActivity() { is Screen.VideoDetail -> VideoDetailScreen( streamUrl = s.streamUrl, initialTitle = s.title, - onPlay = { - nav.push(Screen.Player(s.streamUrl, s.title)) + onPlay = { startPositionMs -> + nav.push(Screen.Player(s.streamUrl, s.title, startPositionMs)) }, onOpenChannel = { url, name -> nav.push(Screen.Channel(url, name)) @@ -103,6 +106,19 @@ class StrawActivity : ComponentActivity() { is Screen.Player -> PlayerScreen( streamUrl = s.streamUrl, title = s.title, + startPositionMs = s.startPositionMs, + ) + is Screen.Playlists -> PlaylistsScreen( + onOpenPlaylist = { id, name -> + nav.push(Screen.PlaylistView(id, name)) + }, + ) + is Screen.PlaylistView -> PlaylistViewScreen( + playlistId = s.playlistId, + initialName = s.name, + onOpenVideo = { url, title -> + nav.push(Screen.VideoDetail(url, title)) + }, ) } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt index 7444f3ab8..ca36407c9 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt @@ -7,6 +7,7 @@ package com.sulkta.straw import android.app.Application import com.sulkta.straw.data.History +import com.sulkta.straw.data.Playlists import com.sulkta.straw.data.Settings import com.sulkta.straw.data.Subscriptions @@ -21,5 +22,6 @@ class StrawApp : Application() { History.init(this) Settings.init(this) Subscriptions.init(this) + Playlists.init(this) } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt index 31e1f2452..2e72d6ab6 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt @@ -78,6 +78,7 @@ private enum class HomeView { Subs, History } fun StrawHome( onOpenSearch: () -> Unit, onOpenSettings: () -> Unit, + onOpenPlaylists: () -> Unit, onOpenVideo: (url: String, title: String) -> Unit, onOpenChannel: (channelUrl: String, name: String) -> Unit, feedVm: SubscriptionFeedViewModel = viewModel(), @@ -125,6 +126,16 @@ fun StrawHome( }, modifier = Modifier.padding(horizontal = 12.dp), ) + NavigationDrawerItem( + label = { Text("Playlists") }, + icon = { Text("📃") }, + selected = false, + onClick = { + scope.launch { drawerState.close() } + onOpenPlaylists() + }, + modifier = Modifier.padding(horizontal = 12.dp), + ) HorizontalDivider(modifier = Modifier.padding(vertical = 12.dp)) NavigationDrawerItem( label = { Text("Settings") }, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/PlaylistsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/PlaylistsStore.kt new file mode 100644 index 000000000..cf72bd597 --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/PlaylistsStore.kt @@ -0,0 +1,126 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * SharedPreferences-lite local playlists. User creates a playlist + * ("study music", "boss fight rage"), saves videos to it from + * VideoDetailScreen, and replays them later from the drawer. Same + * persistence pattern as SubscriptionsStore — JSON blob in + * SharedPreferences, atomic updates via updateAndGet so concurrent + * "save to playlist" taps don't lose entries. + * + * No queue-autoplay yet — tapping a video in a playlist navigates to + * VideoDetail like normal. Queue handoff would be its own task. + */ + +package com.sulkta.straw.data + +import android.content.Context +import android.content.SharedPreferences +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.updateAndGet +import kotlinx.serialization.Serializable +import kotlinx.serialization.json.Json +import java.util.UUID + +@Serializable +data class PlaylistItem( + val streamUrl: String, + val title: String, + val thumbnail: String? = null, + val uploader: String = "", + val addedAt: Long = 0L, +) + +@Serializable +data class Playlist( + val id: String, + val name: String, + val createdAt: Long, + val items: List = emptyList(), +) + +private const val PREFS = "straw_playlists" +private const val KEY = "playlists_v1" + +class PlaylistsStore(context: Context) { + private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) + private val json = Json { ignoreUnknownKeys = true; isLenient = true } + + private val _playlists = MutableStateFlow(load()) + val playlists: StateFlow> = _playlists.asStateFlow() + + fun create(name: String): Playlist { + val pl = Playlist( + id = UUID.randomUUID().toString(), + name = name.trim().ifBlank { "Untitled" }, + createdAt = System.currentTimeMillis(), + ) + val next = _playlists.updateAndGet { it + pl } + persist(next) + return pl + } + + fun delete(id: String) { + val next = _playlists.updateAndGet { cur -> cur.filterNot { it.id == id } } + persist(next) + } + + fun rename(id: String, newName: String) { + val trimmed = newName.trim().ifBlank { return } + val next = _playlists.updateAndGet { cur -> + cur.map { if (it.id == id) it.copy(name = trimmed) else it } + } + persist(next) + } + + fun addItem(playlistId: String, item: PlaylistItem) { + val stamped = item.copy(addedAt = System.currentTimeMillis()) + val next = _playlists.updateAndGet { cur -> + cur.map { pl -> + if (pl.id != playlistId) pl + else if (pl.items.any { it.streamUrl == stamped.streamUrl }) pl + else pl.copy(items = pl.items + stamped) + } + } + persist(next) + } + + fun removeItem(playlistId: String, streamUrl: String) { + val next = _playlists.updateAndGet { cur -> + cur.map { pl -> + if (pl.id != playlistId) pl + else pl.copy(items = pl.items.filterNot { it.streamUrl == streamUrl }) + } + } + persist(next) + } + + fun get(id: String): Playlist? = _playlists.value.firstOrNull { it.id == id } + + private fun persist(list: List) { + sp.edit().putString(KEY, json.encodeToString(list)).apply() + } + + private fun load(): List = runCatching { + val s = sp.getString(KEY, null) ?: return emptyList() + json.decodeFromString>(s) + }.getOrDefault(emptyList()) +} + +object Playlists { + @Volatile private var instance: PlaylistsStore? = null + + fun init(context: Context) { + if (instance == null) { + synchronized(this) { + if (instance == null) instance = PlaylistsStore(context.applicationContext) + } + } + } + + fun get(): PlaylistsStore = instance + ?: error("PlaylistsStore not initialized — call Playlists.init(context)") +} diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index ecb92d66e..01ea63ef1 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -27,18 +27,25 @@ import androidx.compose.material3.AssistChip import androidx.compose.material3.AssistChipDefaults import androidx.compose.material3.Button import androidx.compose.material3.CircularProgressIndicator +import androidx.compose.material3.HorizontalDivider import androidx.compose.material3.Icon import androidx.compose.material3.MaterialTheme import androidx.compose.material3.OutlinedButton +import androidx.compose.material3.OutlinedTextField import androidx.compose.material3.Text import android.content.Intent import android.widget.Toast import androidx.annotation.OptIn import androidx.compose.material3.AlertDialog import androidx.compose.runtime.DisposableEffect +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.mutableLongStateOf import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember import androidx.compose.runtime.setValue +import com.sulkta.straw.data.PlaylistItem +import com.sulkta.straw.data.Playlists +import kotlinx.coroutines.delay import androidx.compose.ui.platform.LocalContext import androidx.compose.ui.viewinterop.AndroidView import com.sulkta.straw.feature.download.DownloadKind @@ -78,7 +85,7 @@ import com.sulkta.straw.util.stripHtml fun VideoDetailScreen( streamUrl: String, initialTitle: String, - onPlay: () -> Unit, + onPlay: (startPositionMs: Long) -> Unit, onOpenChannel: (channelUrl: String, name: String) -> Unit, onOpenVideo: (url: String, title: String) -> Unit, vm: VideoDetailViewModel = viewModel(), @@ -86,9 +93,14 @@ fun VideoDetailScreen( val state by vm.ui.collectAsStateWithLifecycle() val context = LocalContext.current var showDownloadDialog by remember { mutableStateOf(false) } + var showSaveToPlaylistDialog by remember { mutableStateOf(false) } // Inline-play state. Resets when the user navigates to a different // video (keyed on streamUrl). var inlinePlaying by remember(streamUrl) { mutableStateOf(false) } + // V-2: inline player's current position, polled into here so the + // outer can pass it through when the user taps Play / ⛶. Resets to 0 + // when the inline player isn't active. + var inlinePositionMs by remember(streamUrl) { mutableLongStateOf(0L) } LaunchedEffect(streamUrl) { vm.load(streamUrl) } Column( @@ -117,7 +129,8 @@ fun VideoDetailScreen( if (inlinePlaying) { InlinePlayer( streamUrl = streamUrl, - onFullscreen = onPlay, + onFullscreen = { onPlay(inlinePositionMs) }, + onPositionChanged = { inlinePositionMs = it }, modifier = Modifier .fillMaxWidth() .aspectRatio(16f / 9f) @@ -209,7 +222,7 @@ fun VideoDetailScreen( Spacer(modifier = Modifier.height(16.dp)) Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) { - Button(onClick = onPlay) { Text("Play") } + Button(onClick = { onPlay(inlinePositionMs) }) { Text("Play") } OutlinedButton(onClick = { val send = Intent(Intent.ACTION_SEND).apply { type = "text/plain" @@ -221,6 +234,9 @@ fun VideoDetailScreen( OutlinedButton(onClick = { showDownloadDialog = true }) { Text("Download") } + OutlinedButton(onClick = { showSaveToPlaylistDialog = true }) { + Text("Save") + } } Spacer(modifier = Modifier.height(20.dp)) @@ -265,6 +281,18 @@ fun VideoDetailScreen( } } + if (showSaveToPlaylistDialog) { + SaveToPlaylistDialog( + item = PlaylistItem( + streamUrl = streamUrl, + title = d.title, + thumbnail = d.thumbnail, + uploader = d.uploader, + ), + onDismiss = { showSaveToPlaylistDialog = false }, + ) + } + if (showDownloadDialog) { val info = state.streamInfo AlertDialog( @@ -369,6 +397,90 @@ private fun RelatedRow( } } +@Composable +private fun SaveToPlaylistDialog( + item: PlaylistItem, + onDismiss: () -> Unit, +) { + val context = LocalContext.current + val store = Playlists.get() + val playlists by store.playlists.collectAsState() + var creatingNew by remember { mutableStateOf(false) } + var newName by remember { mutableStateOf("") } + + AlertDialog( + onDismissRequest = onDismiss, + title = { Text("Save to playlist") }, + text = { + Column { + if (playlists.isEmpty() && !creatingNew) { + Text( + "No playlists yet. Create one to save this video.", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + Spacer(modifier = Modifier.height(8.dp)) + } + playlists.forEach { pl -> + val already = pl.items.any { it.streamUrl == item.streamUrl } + Row( + modifier = Modifier + .fillMaxWidth() + .clickable(enabled = !already) { + store.addItem(pl.id, item) + Toast.makeText(context, "saved to ${pl.name}", Toast.LENGTH_SHORT).show() + onDismiss() + } + .padding(vertical = 12.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Text(if (already) "✓" else "○", modifier = Modifier.width(28.dp)) + Column(modifier = Modifier.weight(1f)) { + Text(pl.name, style = MaterialTheme.typography.bodyLarge) + Text( + "${pl.items.size} video${if (pl.items.size == 1) "" else "s"}", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } + HorizontalDivider() + } + if (creatingNew) { + Spacer(modifier = Modifier.height(8.dp)) + OutlinedTextField( + value = newName, + onValueChange = { newName = it }, + label = { Text("New playlist name") }, + modifier = Modifier.fillMaxWidth(), + singleLine = true, + ) + Spacer(modifier = Modifier.height(8.dp)) + Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) { + Button(onClick = { + val pl = store.create(newName) + store.addItem(pl.id, item) + Toast.makeText(context, "created ${pl.name} + saved", Toast.LENGTH_SHORT).show() + onDismiss() + }) { Text("Create + save") } + OutlinedButton(onClick = { creatingNew = false; newName = "" }) { + Text("Cancel") + } + } + } else { + Spacer(modifier = Modifier.height(12.dp)) + OutlinedButton(onClick = { creatingNew = true }) { + Text("+ New playlist") + } + } + } + }, + confirmButton = { + androidx.compose.material3.TextButton(onClick = onDismiss) { Text("Close") } + }, + ) +} + /** * Inline player embedded in the 16:9 thumbnail box on VideoDetailScreen. * Uses its own ExoPlayer + PlayerView (with the built-in controller for @@ -382,6 +494,7 @@ private fun RelatedRow( private fun InlinePlayer( streamUrl: String, onFullscreen: () -> Unit, + onPositionChanged: (Long) -> Unit, modifier: Modifier = Modifier, ) { val context = LocalContext.current @@ -455,6 +568,15 @@ private fun InlinePlayer( } } + // V-2: report inline position to the parent so the Play / ⛶ button + // can pick up where playback was when the user goes fullscreen. + LaunchedEffect(exoPlayer) { + while (true) { + onPositionChanged(exoPlayer.currentPosition.coerceAtLeast(0L)) + delay(500) + } + } + Box(modifier = modifier, contentAlignment = Alignment.Center) { when { state.loading -> CircularProgressIndicator(color = Color.White) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt index 8a7e6c1ad..748c61379 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt @@ -80,6 +80,7 @@ import kotlinx.coroutines.delay fun PlayerScreen( streamUrl: String, title: String, + startPositionMs: Long = 0L, vm: PlayerViewModel = viewModel(), ) { val context = LocalContext.current @@ -216,6 +217,13 @@ fun PlayerScreen( if (source != null) { exoPlayer.setMediaSource(source) + // V-2: when we navigate here from an inline player that was + // already playing, pick up at the same position instead of + // restarting. seekTo() before prepare() is allowed; the seek + // is queued and applied once the player is ready. + if (startPositionMs > 0) { + exoPlayer.seekTo(startPositionMs) + } exoPlayer.prepare() exoPlayer.playWhenReady = true } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/playlist/PlaylistsScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/playlist/PlaylistsScreen.kt new file mode 100644 index 000000000..44c1ad36f --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/playlist/PlaylistsScreen.kt @@ -0,0 +1,267 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Two-screen unit for local playlists: + * PlaylistsScreen — root list of all user playlists (drawer entry) + * PlaylistViewScreen — items inside one playlist, tap to open + */ + +package com.sulkta.straw.feature.playlist + +import androidx.compose.foundation.background +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +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.padding +import androidx.compose.foundation.layout.statusBarsPadding +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.AlertDialog +import androidx.compose.material3.Button +import androidx.compose.material3.HorizontalDivider +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.OutlinedButton +import androidx.compose.material3.OutlinedTextField +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import coil3.compose.AsyncImage +import com.sulkta.straw.data.Playlists + +@Composable +fun PlaylistsScreen( + onOpenPlaylist: (id: String, name: String) -> Unit, +) { + val store = Playlists.get() + val playlists by store.playlists.collectAsState() + var showCreate by remember { mutableStateOf(false) } + var newName by remember { mutableStateOf("") } + var pendingDelete by remember { mutableStateOf(null) } + + Column( + modifier = Modifier + .fillMaxSize() + .statusBarsPadding() + .padding(horizontal = 20.dp, vertical = 12.dp), + ) { + Row(verticalAlignment = Alignment.CenterVertically) { + Text( + "Playlists", + style = MaterialTheme.typography.titleLarge, + fontWeight = FontWeight.SemiBold, + modifier = Modifier.weight(1f), + ) + Button(onClick = { showCreate = true; newName = "" }) { Text("+ New") } + } + Spacer(modifier = Modifier.height(8.dp)) + Text( + "${playlists.size} playlist${if (playlists.size == 1) "" else "s"}", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + Spacer(modifier = Modifier.height(12.dp)) + + if (playlists.isEmpty()) { + Text( + "No playlists yet. Tap + New, or use the Save button on a video.", + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } else { + LazyColumn { + items(playlists, key = { it.id }) { pl -> + Row( + modifier = Modifier + .fillMaxWidth() + .clickable { onOpenPlaylist(pl.id, pl.name) } + .padding(vertical = 12.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Box( + modifier = Modifier + .width(56.dp) + .height(56.dp) + .clip(RoundedCornerShape(8.dp)) + .background(MaterialTheme.colorScheme.surfaceVariant), + contentAlignment = Alignment.Center, + ) { + Text("📃") + } + Spacer(modifier = Modifier.width(12.dp)) + Column(modifier = Modifier.weight(1f)) { + Text( + pl.name, + style = MaterialTheme.typography.bodyLarge, + fontWeight = FontWeight.SemiBold, + ) + Text( + "${pl.items.size} video${if (pl.items.size == 1) "" else "s"}", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + OutlinedButton(onClick = { pendingDelete = pl.id }) { + Text("Delete") + } + } + HorizontalDivider() + } + } + } + + if (showCreate) { + AlertDialog( + onDismissRequest = { showCreate = false }, + title = { Text("New playlist") }, + text = { + OutlinedTextField( + value = newName, + onValueChange = { newName = it }, + label = { Text("Name") }, + singleLine = true, + modifier = Modifier.fillMaxWidth(), + ) + }, + confirmButton = { + Button(onClick = { + store.create(newName) + showCreate = false + }) { Text("Create") } + }, + dismissButton = { + androidx.compose.material3.TextButton(onClick = { showCreate = false }) { + Text("Cancel") + } + }, + ) + } + + pendingDelete?.let { id -> + val name = store.get(id)?.name ?: "this playlist" + AlertDialog( + onDismissRequest = { pendingDelete = null }, + title = { Text("Delete \"$name\"?") }, + text = { Text("This removes the playlist and its saved video references. Doesn't delete any downloaded files.") }, + confirmButton = { + Button(onClick = { + store.delete(id) + pendingDelete = null + }) { Text("Delete") } + }, + dismissButton = { + androidx.compose.material3.TextButton(onClick = { pendingDelete = null }) { + Text("Cancel") + } + }, + ) + } + } +} + +@Composable +fun PlaylistViewScreen( + playlistId: String, + initialName: String, + onOpenVideo: (url: String, title: String) -> Unit, +) { + val store = Playlists.get() + val playlists by store.playlists.collectAsState() + val playlist = playlists.firstOrNull { it.id == playlistId } + + Column( + modifier = Modifier + .fillMaxSize() + .statusBarsPadding() + .padding(horizontal = 20.dp, vertical = 12.dp), + ) { + Text( + playlist?.name ?: initialName, + style = MaterialTheme.typography.titleLarge, + fontWeight = FontWeight.SemiBold, + ) + Spacer(modifier = Modifier.height(8.dp)) + if (playlist == null) { + Text( + "Playlist not found.", + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + return@Column + } + Text( + "${playlist.items.size} video${if (playlist.items.size == 1) "" else "s"}", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + Spacer(modifier = Modifier.height(12.dp)) + + if (playlist.items.isEmpty()) { + Text( + "Empty. Tap Save on a video to add it.", + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } else { + LazyColumn { + items(playlist.items, key = { it.streamUrl }) { item -> + Row( + modifier = Modifier + .fillMaxWidth() + .clickable { onOpenVideo(item.streamUrl, item.title) } + .padding(vertical = 8.dp), + verticalAlignment = Alignment.Top, + ) { + AsyncImage( + model = item.thumbnail, + contentDescription = null, + modifier = Modifier + .width(140.dp) + .height(80.dp) + .clip(RoundedCornerShape(6.dp)), + ) + Spacer(modifier = Modifier.width(10.dp)) + Column(modifier = Modifier.weight(1f)) { + Text( + item.title, + style = MaterialTheme.typography.bodyMedium, + fontWeight = FontWeight.SemiBold, + maxLines = 2, + overflow = TextOverflow.Ellipsis, + ) + Spacer(modifier = Modifier.height(2.dp)) + Text( + item.uploader, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + maxLines = 1, + ) + } + androidx.compose.material3.TextButton(onClick = { + store.removeItem(playlist.id, item.streamUrl) + }) { Text("×") } + } + HorizontalDivider() + } + } + } + } +} From 1be4c4265f2bce68dd53258b2803a23c6bbda35b Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 16:23:05 +0000 Subject: [PATCH 06/72] vc=23: minibar + MediaController unification + Downloads UI + green theme MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Real MediaController/MediaSessionService unification: a single ExoPlayer owned by PlaybackService, every UI surface is a MediaController client. Playback never restarts on screen transitions. Drops the per-screen ExoPlayer instances; drops the EXTRA_URL Intent-based handoff from vc=21. Minibar overlay: persistent strip pinned to the bottom of every non-Player screen whenever something is loaded. Tap to expand to fullscreen, x to stop and clear, play/pause toggles. Drag-down on the fullscreen player or the down-chevron overlay button minimizes into the minibar. Single source of truth for what is playing is NowPlaying — a process-wide StateFlow refreshed by whichever surface calls setPlayingFrom. Custom MediaSource.Factory in the service routes DASH/HLS/progressive by MIME, and merges video+audio progressives via a side-channel EXTRA_AUDIO_URL bundle on the MediaItem. SponsorBlock skip loop is now activity-scoped, hoisted out of PlayerScreen, so segments are skipped in minibar mode too. Downloads tab wired into the drawer. Reads DownloadManager every second, shows status + progress, tap to open, x to remove. Theme: forest-green primary palette replaces the M3 default lavender / NewPipe red. Modern, clean, distinct. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 18 +- .../src/main/kotlin/com/sulkta/straw/Nav.kt | 1 + .../kotlin/com/sulkta/straw/StrawActivity.kt | 78 +++- .../main/kotlin/com/sulkta/straw/StrawHome.kt | 11 + .../kotlin/com/sulkta/straw/StrawTheme.kt | 64 +++ .../straw/feature/detail/VideoDetailScreen.kt | 124 ++---- .../straw/feature/download/DownloadsScreen.kt | 247 ++++++++++ .../straw/feature/player/MinibarOverlay.kt | 141 ++++++ .../sulkta/straw/feature/player/NowPlaying.kt | 42 ++ .../straw/feature/player/PlaybackService.kt | 271 +++++------ .../straw/feature/player/PlayerScreen.kt | 420 +++++++----------- .../feature/player/StrawMediaController.kt | 144 ++++++ 12 files changed, 1067 insertions(+), 494 deletions(-) create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/StrawTheme.kt create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/feature/download/DownloadsScreen.kt create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/feature/player/MinibarOverlay.kt create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/feature/player/NowPlaying.kt create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 3106cdb6b..14969bfa5 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -16,6 +16,20 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // Sulkta fork — Straw // +// vc=23 / 0.1.0-AI — minibar + downloads UI + green theme: +// * MediaController/MediaSessionService unification — single ExoPlayer +// owned by PlaybackService, every UI surface is a controller client. +// Inline player on VideoDetail, fullscreen Player, and the new +// minibar overlay all drive the same underlying player; nothing +// restarts on screen transitions. +// * Persistent minibar overlay at the bottom of every non-Player +// screen whenever something is loaded. Tap → expand to fullscreen. +// Drag-down on fullscreen → minimize to minibar. ⌄ overlay button +// also minimizes. × on the minibar stops + clears. +// * Downloads page wired into the drawer. +// * Theme: forest-green primary palette in place of M3 default +// lavender / NewPipe red — modern, clean, distinct. +// // vc=22 / 0.1.0-AH — V-2 player polish + local playlists: // * Inline → fullscreen now hands off seek position. Tap Play (or the // ⛶ pill on the inline player) while the inline is mid-track and @@ -41,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 22 -const val STRAW_VERSION_NAME = "0.1.0-AH" +const val STRAW_VERSION_CODE = 23 +const val STRAW_VERSION_NAME = "0.1.0-AI" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/Nav.kt b/strawApp/src/main/kotlin/com/sulkta/straw/Nav.kt index 3e5c7edf6..bf91616fa 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/Nav.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/Nav.kt @@ -17,6 +17,7 @@ sealed interface Screen { data object Search : Screen data object Settings : Screen data object Playlists : Screen + data object Downloads : Screen data class VideoDetail(val streamUrl: String, val title: String) : Screen data class Player( val streamUrl: String, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt index 340dcf846..7d16e4650 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt @@ -12,17 +12,25 @@ import androidx.activity.OnBackPressedCallback import androidx.activity.compose.setContent import androidx.activity.enableEdgeToEdge import androidx.compose.foundation.isSystemInDarkTheme +import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Surface -import androidx.compose.material3.darkColorScheme -import androidx.compose.material3.lightColorScheme +import androidx.compose.runtime.Composable +import androidx.compose.runtime.CompositionLocalProvider import androidx.compose.runtime.DisposableEffect +import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier +import androidx.media3.common.util.UnstableApi import com.sulkta.straw.feature.channel.ChannelScreen import com.sulkta.straw.feature.detail.VideoDetailScreen +import com.sulkta.straw.feature.download.DownloadsScreen +import com.sulkta.straw.feature.player.LocalStrawController +import com.sulkta.straw.feature.player.MinibarOverlay import com.sulkta.straw.feature.player.PlayerLeaveHandler import com.sulkta.straw.feature.player.PlayerScreen +import com.sulkta.straw.feature.player.SponsorBlockSkipLoop +import com.sulkta.straw.feature.player.rememberStrawController import com.sulkta.straw.feature.playlist.PlaylistViewScreen import com.sulkta.straw.feature.playlist.PlaylistsScreen import com.sulkta.straw.feature.search.SearchScreen @@ -38,6 +46,7 @@ private val YT_URL_RE = Regex( ) class StrawActivity : ComponentActivity() { + @OptIn(UnstableApi::class) override fun onCreate(savedInstanceState: Bundle?) { enableEdgeToEdge() super.onCreate(savedInstanceState) @@ -45,8 +54,14 @@ class StrawActivity : ComponentActivity() { val startUrl = pickYouTubeUrl(intent) setContent { - val scheme = if (isSystemInDarkTheme()) darkColorScheme() else lightColorScheme() + val scheme = if (isSystemInDarkTheme()) strawDarkColors() else strawLightColors() + // Build one MediaController for the whole activity. Every screen + // pulls it via LocalStrawController, every PlayerView binds to + // it, and the minibar overlay (rendered below) uses it too. + // Single player, single source of truth. + val controller = rememberStrawController() MaterialTheme(colorScheme = scheme) { + CompositionLocalProvider(LocalStrawController provides controller) { Surface(modifier = Modifier.fillMaxSize()) { val initial: Screen = if (startUrl != null) Screen.VideoDetail(startUrl, "") else Screen.Home @@ -65,11 +80,47 @@ class StrawActivity : ComponentActivity() { onDispose { cb.remove() } } - when (val s = nav.current) { + // SponsorBlock skip loop runs at the activity level so it + // applies whether the user is fullscreen, in the minibar, + // or away from the player surface. + SponsorBlockSkipLoop() + + Box(modifier = Modifier.fillMaxSize()) { + ScreenContent(nav, s = nav.current) + // Persistent minibar overlay — visible on every screen + // except Player itself (fullscreen has its own UI). + if (nav.current !is Screen.Player) { + MinibarOverlay( + onExpand = { + val item = com.sulkta.straw.feature.player.NowPlaying.current.value + if (item != null) { + nav.push( + Screen.Player( + item.streamUrl, + item.title, + controller?.currentPosition ?: 0L, + ) + ) + } + }, + modifier = Modifier.align(Alignment.BottomCenter), + ) + } + } + } + } + } + } + } + + @Composable + private fun ScreenContent(nav: Navigator, s: Screen) { + when (s) { is Screen.Home -> StrawHome( onOpenSearch = { nav.push(Screen.Search) }, onOpenSettings = { nav.push(Screen.Settings) }, onOpenPlaylists = { nav.push(Screen.Playlists) }, + onOpenDownloads = { nav.push(Screen.Downloads) }, onOpenVideo = { url, title -> nav.push(Screen.VideoDetail(url, title)) }, @@ -77,6 +128,7 @@ class StrawActivity : ComponentActivity() { nav.push(Screen.Channel(url, name)) }, ) + is Screen.Downloads -> DownloadsScreen() is Screen.Settings -> SettingsScreen() is Screen.Search -> SearchScreen( onOpenVideo = { url, title -> @@ -107,22 +159,20 @@ class StrawActivity : ComponentActivity() { streamUrl = s.streamUrl, title = s.title, startPositionMs = s.startPositionMs, + onMinimize = { nav.pop() }, ) is Screen.Playlists -> PlaylistsScreen( onOpenPlaylist = { id, name -> nav.push(Screen.PlaylistView(id, name)) }, ) - is Screen.PlaylistView -> PlaylistViewScreen( - playlistId = s.playlistId, - initialName = s.name, - onOpenVideo = { url, title -> - nav.push(Screen.VideoDetail(url, title)) - }, - ) - } - } - } + is Screen.PlaylistView -> PlaylistViewScreen( + playlistId = s.playlistId, + initialName = s.name, + onOpenVideo = { url, title -> + nav.push(Screen.VideoDetail(url, title)) + }, + ) } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt index 2e72d6ab6..0512de4aa 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt @@ -79,6 +79,7 @@ fun StrawHome( onOpenSearch: () -> Unit, onOpenSettings: () -> Unit, onOpenPlaylists: () -> Unit, + onOpenDownloads: () -> Unit, onOpenVideo: (url: String, title: String) -> Unit, onOpenChannel: (channelUrl: String, name: String) -> Unit, feedVm: SubscriptionFeedViewModel = viewModel(), @@ -136,6 +137,16 @@ fun StrawHome( }, modifier = Modifier.padding(horizontal = 12.dp), ) + NavigationDrawerItem( + label = { Text("Downloads") }, + icon = { Text("⬇") }, + selected = false, + onClick = { + scope.launch { drawerState.close() } + onOpenDownloads() + }, + modifier = Modifier.padding(horizontal = 12.dp), + ) HorizontalDivider(modifier = Modifier.padding(vertical = 12.dp)) NavigationDrawerItem( label = { Text("Settings") }, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawTheme.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawTheme.kt new file mode 100644 index 000000000..74ad7be59 --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawTheme.kt @@ -0,0 +1,64 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Sulkta green palette for Straw. Replaces the M3 default lavender/red + * tints with a clean forest green primary — modern, clean, distinct from + * NewPipe / Tubular's red. Same Tonal Palette structure Material 3 uses + * internally so all the derived surfaces stay in harmony. + */ + +package com.sulkta.straw + +import androidx.compose.material3.ColorScheme +import androidx.compose.material3.darkColorScheme +import androidx.compose.material3.lightColorScheme +import androidx.compose.ui.graphics.Color + +private val GreenPrimary = Color(0xFF386A1F) +private val GreenOnPrimary = Color(0xFFFFFFFF) +private val GreenPrimaryContainer = Color(0xFFB6F397) +private val GreenOnPrimaryContainer = Color(0xFF0B2000) +private val GreenSecondary = Color(0xFF55624C) +private val GreenOnSecondary = Color(0xFFFFFFFF) +private val GreenSecondaryContainer = Color(0xFFD8E7CB) +private val GreenOnSecondaryContainer = Color(0xFF131F0D) +private val GreenTertiary = Color(0xFF386666) +private val GreenOnTertiary = Color(0xFFFFFFFF) + +private val DarkGreenPrimary = Color(0xFF9BD67D) +private val DarkGreenOnPrimary = Color(0xFF153800) +private val DarkGreenPrimaryContainer = Color(0xFF205107) +private val DarkGreenOnPrimaryContainer = Color(0xFFB6F397) +private val DarkGreenSecondary = Color(0xFFBDCBB0) +private val DarkGreenOnSecondary = Color(0xFF283420) +private val DarkGreenSecondaryContainer = Color(0xFF3E4A35) +private val DarkGreenOnSecondaryContainer = Color(0xFFD8E7CB) +private val DarkGreenTertiary = Color(0xFFA0CFD0) +private val DarkGreenOnTertiary = Color(0xFF003738) + +fun strawLightColors(): ColorScheme = lightColorScheme( + primary = GreenPrimary, + onPrimary = GreenOnPrimary, + primaryContainer = GreenPrimaryContainer, + onPrimaryContainer = GreenOnPrimaryContainer, + secondary = GreenSecondary, + onSecondary = GreenOnSecondary, + secondaryContainer = GreenSecondaryContainer, + onSecondaryContainer = GreenOnSecondaryContainer, + tertiary = GreenTertiary, + onTertiary = GreenOnTertiary, +) + +fun strawDarkColors(): ColorScheme = darkColorScheme( + primary = DarkGreenPrimary, + onPrimary = DarkGreenOnPrimary, + primaryContainer = DarkGreenPrimaryContainer, + onPrimaryContainer = DarkGreenOnPrimaryContainer, + secondary = DarkGreenSecondary, + onSecondary = DarkGreenOnSecondary, + secondaryContainer = DarkGreenSecondaryContainer, + onSecondaryContainer = DarkGreenOnSecondaryContainer, + tertiary = DarkGreenTertiary, + onTertiary = DarkGreenOnTertiary, +) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index 01ea63ef1..3f93f1df6 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -64,19 +64,13 @@ import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.unit.dp import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.lifecycle.viewmodel.compose.viewModel -import androidx.media3.common.AudioAttributes -import androidx.media3.common.C -import androidx.media3.common.MediaItem +import androidx.media3.common.Player import androidx.media3.common.util.UnstableApi -import androidx.media3.datasource.DefaultHttpDataSource -import androidx.media3.exoplayer.ExoPlayer -import androidx.media3.exoplayer.dash.DashMediaSource -import androidx.media3.exoplayer.hls.HlsMediaSource -import androidx.media3.exoplayer.source.MergingMediaSource -import androidx.media3.exoplayer.source.ProgressiveMediaSource import androidx.media3.ui.PlayerView import coil3.compose.AsyncImage -import com.sulkta.straw.net.STRAW_USER_AGENT +import com.sulkta.straw.feature.player.LocalStrawController +import com.sulkta.straw.feature.player.NowPlaying +import com.sulkta.straw.feature.player.setPlayingFrom import com.sulkta.straw.util.formatCount import com.sulkta.straw.util.formatViews import com.sulkta.straw.util.stripHtml @@ -129,6 +123,9 @@ fun VideoDetailScreen( if (inlinePlaying) { InlinePlayer( streamUrl = streamUrl, + title = d.title, + uploader = d.uploader, + thumbnail = d.thumbnail, onFullscreen = { onPlay(inlinePositionMs) }, onPositionChanged = { inlinePositionMs = it }, modifier = Modifier @@ -493,93 +490,63 @@ private fun SaveToPlaylistDialog( @Composable private fun InlinePlayer( streamUrl: String, + title: String, + uploader: String, + thumbnail: String?, onFullscreen: () -> Unit, onPositionChanged: (Long) -> Unit, modifier: Modifier = Modifier, ) { - val context = LocalContext.current + val controller = LocalStrawController.current val playerVm: PlayerViewModel = viewModel() val state by playerVm.ui.collectAsStateWithLifecycle() LaunchedEffect(streamUrl) { playerVm.resolve(streamUrl) } - val exoPlayer = remember { - ExoPlayer.Builder(context) - .setAudioAttributes( - AudioAttributes.Builder() - .setUsage(C.USAGE_MEDIA) - .setContentType(C.AUDIO_CONTENT_TYPE_MOVIE) - .build(), - /* handleAudioFocus = */ true, - ) - .build() - } - - // Path C-7: surface ExoPlayer failures into UI state. Without this an - // HTTP 403 / source error showed as a stuck black box with the pause - // controls visible — directly enabled a false-positive in the prior - // verification pass. - var playbackError by remember { mutableStateOf(null) } - DisposableEffect(exoPlayer) { - val listener = object : androidx.media3.common.Player.Listener { - override fun onPlayerError(error: androidx.media3.common.PlaybackException) { - playbackError = - "${error.errorCodeName}: ${error.message ?: "(no message)"}" - } - } - exoPlayer.addListener(listener) - onDispose { - exoPlayer.removeListener(listener) - exoPlayer.release() - } - } - + // As soon as we have a resolved stream AND the active video isn't + // already this URL, push it into the shared controller. The controller + // is the same one driving the fullscreen Player + the minibar overlay, + // so playback survives any nav transition unchanged. val resolved = state.resolved - LaunchedEffect(resolved) { + LaunchedEffect(controller, resolved, streamUrl) { + val c = controller ?: return@LaunchedEffect val r = resolved ?: return@LaunchedEffect - // Path C-7: chunk open-ended Range requests so iOS googlevideo URLs - // don't 403 on first byte. See net/IosSafeHttpDataSource.kt. - val dataSourceFactory = com.sulkta.straw.net.IosSafeHttpDataSource.Factory( - DefaultHttpDataSource.Factory() - .setUserAgent(STRAW_USER_AGENT) - .setAllowCrossProtocolRedirects(true) - ) - val source = when { - r.dashMpdUrl != null -> DashMediaSource.Factory(dataSourceFactory) - .createMediaSource(MediaItem.fromUri(r.dashMpdUrl)) - r.hlsUrl != null -> HlsMediaSource.Factory(dataSourceFactory) - .createMediaSource(MediaItem.fromUri(r.hlsUrl)) - r.combinedUrl != null -> ProgressiveMediaSource.Factory(dataSourceFactory) - .createMediaSource(MediaItem.fromUri(r.combinedUrl)) - r.videoUrl != null && r.audioUrl != null -> { - val v = ProgressiveMediaSource.Factory(dataSourceFactory) - .createMediaSource(MediaItem.fromUri(r.videoUrl)) - val a = ProgressiveMediaSource.Factory(dataSourceFactory) - .createMediaSource(MediaItem.fromUri(r.audioUrl)) - MergingMediaSource(v, a) - } - r.videoUrl != null -> ProgressiveMediaSource.Factory(dataSourceFactory) - .createMediaSource(MediaItem.fromUri(r.videoUrl)) - else -> null - } - if (source != null) { - exoPlayer.setMediaSource(source) - exoPlayer.prepare() - exoPlayer.playWhenReady = true + val activeUrl = NowPlaying.current.value?.streamUrl + if (activeUrl != streamUrl) { + c.setPlayingFrom( + streamUrl = streamUrl, + title = title, + uploader = uploader, + thumbnail = thumbnail, + resolved = r, + ) } } - // V-2: report inline position to the parent so the Play / ⛶ button - // can pick up where playback was when the user goes fullscreen. - LaunchedEffect(exoPlayer) { + // Report position to the parent on every tick so a Play / ⛶ tap picks + // up at the right spot if the active video is somehow desynced. + LaunchedEffect(controller) { + val c = controller ?: return@LaunchedEffect while (true) { - onPositionChanged(exoPlayer.currentPosition.coerceAtLeast(0L)) + onPositionChanged(c.currentPosition.coerceAtLeast(0L)) delay(500) } } + var playbackError by remember { mutableStateOf(null) } + DisposableEffect(controller) { + val c = controller + val listener = object : Player.Listener { + override fun onPlayerError(error: androidx.media3.common.PlaybackException) { + playbackError = "${error.errorCodeName}: ${error.message ?: "(no message)"}" + } + } + c?.addListener(listener) + onDispose { c?.removeListener(listener) } + } + Box(modifier = modifier, contentAlignment = Alignment.Center) { when { - state.loading -> CircularProgressIndicator(color = Color.White) + controller == null || state.loading -> CircularProgressIndicator(color = Color.White) state.error != null -> Text( "playback error: ${state.error}", color = MaterialTheme.colorScheme.error, @@ -599,10 +566,11 @@ private fun InlinePlayer( AndroidView( factory = { ctx -> PlayerView(ctx).apply { - player = exoPlayer + player = controller useController = true } }, + update = { it.player = controller }, modifier = Modifier.fillMaxSize(), ) // Top-right fullscreen pill — hops to the fullscreen diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/DownloadsScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/DownloadsScreen.kt new file mode 100644 index 000000000..f3262cd41 --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/DownloadsScreen.kt @@ -0,0 +1,247 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Downloads tab — lists everything Phase R's Downloader handed off to + * Android's DownloadManager. Reads live from DownloadManager.query() + * keyed by package owner, so we naturally show only this app's queue. + * + * Row shows: title, kind (audio / video), state (running / completed / + * failed), and progress / size. Tap a completed row → ACTION_VIEW + * intent to whatever player the user has registered. × removes the + * entry from the queue (and the file, per DownloadManager.remove + * semantics). + */ + +package com.sulkta.straw.feature.download + +import android.app.DownloadManager +import android.content.Context +import android.content.Intent +import android.net.Uri +import androidx.compose.foundation.background +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +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.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.statusBarsPadding +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.HorizontalDivider +import androidx.compose.material3.LinearProgressIndicator +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.OutlinedButton +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import kotlinx.coroutines.delay + +data class DownloadRow( + val id: Long, + val title: String, + val localUri: String?, + val mediaType: String?, + val status: Int, + val reason: Int, + val bytesSoFar: Long, + val totalBytes: Long, +) { + val progressFraction: Float? + get() = if (totalBytes > 0) (bytesSoFar.toFloat() / totalBytes).coerceIn(0f, 1f) else null + + val statusLabel: String + get() = when (status) { + DownloadManager.STATUS_RUNNING -> "downloading" + DownloadManager.STATUS_PENDING -> "pending" + DownloadManager.STATUS_PAUSED -> "paused" + DownloadManager.STATUS_SUCCESSFUL -> "done" + DownloadManager.STATUS_FAILED -> "failed" + else -> "unknown" + } +} + +@Composable +fun DownloadsScreen() { + val context = LocalContext.current + var rows by remember { mutableStateOf>(emptyList()) } + + // Poll DownloadManager every second while the screen is visible. + // DownloadManager doesn't broadcast progress, so polling is the + // standard pattern. Cheap query — single cursor across the app's own + // download queue. + LaunchedEffect(Unit) { + while (true) { + rows = queryDownloads(context) + delay(1000) + } + } + + Column( + modifier = Modifier + .fillMaxSize() + .statusBarsPadding() + .padding(horizontal = 20.dp, vertical = 12.dp), + ) { + Text( + "Downloads", + style = MaterialTheme.typography.titleLarge, + fontWeight = FontWeight.SemiBold, + ) + Spacer(modifier = Modifier.height(4.dp)) + Text( + "${rows.size} item${if (rows.size == 1) "" else "s"} · saved to app private storage", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + Spacer(modifier = Modifier.height(12.dp)) + + if (rows.isEmpty()) { + Text( + "Nothing here yet. Tap Download on any video.", + style = MaterialTheme.typography.bodyMedium, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } else { + LazyColumn { + items(rows, key = { it.id }) { row -> + DownloadRowView(row, context, onRemove = { + runCatching { + (context.getSystemService(Context.DOWNLOAD_SERVICE) as DownloadManager) + .remove(row.id) + } + rows = rows.filterNot { it.id == row.id } + }) + HorizontalDivider() + } + } + } + } +} + +@Composable +private fun DownloadRowView( + row: DownloadRow, + context: Context, + onRemove: () -> Unit, +) { + val openable = row.status == DownloadManager.STATUS_SUCCESSFUL && !row.localUri.isNullOrBlank() + Row( + modifier = Modifier + .fillMaxWidth() + .clickable(enabled = openable) { + row.localUri?.let { uri -> + val intent = Intent(Intent.ACTION_VIEW).apply { + setDataAndType(Uri.parse(uri), row.mediaType ?: "*/*") + addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION) + } + runCatching { context.startActivity(intent) } + } + } + .padding(vertical = 12.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Box( + modifier = Modifier + .size(width = 56.dp, height = 56.dp) + .clip(RoundedCornerShape(8.dp)) + .background(MaterialTheme.colorScheme.surfaceVariant), + contentAlignment = Alignment.Center, + ) { + Text(if (row.mediaType?.startsWith("audio") == true) "🎵" else "🎬") + } + Spacer(modifier = Modifier.width(12.dp)) + Column(modifier = Modifier.weight(1f)) { + Text( + row.title, + style = MaterialTheme.typography.bodyMedium, + fontWeight = FontWeight.SemiBold, + maxLines = 2, + overflow = TextOverflow.Ellipsis, + ) + Spacer(modifier = Modifier.height(2.dp)) + Text( + buildString { + append(row.statusLabel) + if (row.totalBytes > 0) { + append(" · ") + append(formatBytes(row.bytesSoFar)) + append(" / ") + append(formatBytes(row.totalBytes)) + } else if (row.bytesSoFar > 0) { + append(" · ") + append(formatBytes(row.bytesSoFar)) + } + }, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + row.progressFraction?.takeIf { row.status != DownloadManager.STATUS_SUCCESSFUL } + ?.let { p -> + Spacer(modifier = Modifier.height(4.dp)) + LinearProgressIndicator( + progress = { p }, + modifier = Modifier.fillMaxWidth(), + ) + } + } + TextButton(onClick = onRemove) { Text("×") } + } +} + +private fun queryDownloads(context: Context): List { + val dm = context.getSystemService(Context.DOWNLOAD_SERVICE) as? DownloadManager + ?: return emptyList() + val query = DownloadManager.Query() + val out = mutableListOf() + runCatching { dm.query(query) }.getOrNull()?.use { c -> + val idIdx = c.getColumnIndex(DownloadManager.COLUMN_ID) + val titleIdx = c.getColumnIndex(DownloadManager.COLUMN_TITLE) + val uriIdx = c.getColumnIndex(DownloadManager.COLUMN_LOCAL_URI) + val mimeIdx = c.getColumnIndex(DownloadManager.COLUMN_MEDIA_TYPE) + val statusIdx = c.getColumnIndex(DownloadManager.COLUMN_STATUS) + val reasonIdx = c.getColumnIndex(DownloadManager.COLUMN_REASON) + val soFarIdx = c.getColumnIndex(DownloadManager.COLUMN_BYTES_DOWNLOADED_SO_FAR) + val totalIdx = c.getColumnIndex(DownloadManager.COLUMN_TOTAL_SIZE_BYTES) + while (c.moveToNext()) { + out += DownloadRow( + id = c.getLong(idIdx), + title = c.getString(titleIdx) ?: "(no title)", + localUri = c.getString(uriIdx), + mediaType = c.getString(mimeIdx), + status = c.getInt(statusIdx), + reason = c.getInt(reasonIdx), + bytesSoFar = c.getLong(soFarIdx), + totalBytes = c.getLong(totalIdx), + ) + } + } + return out.sortedByDescending { it.id } +} + +private fun formatBytes(b: Long): String = when { + b < 1024 -> "$b B" + b < 1024L * 1024 -> "${b / 1024} KB" + b < 1024L * 1024 * 1024 -> "%.1f MB".format(b.toDouble() / (1024 * 1024)) + else -> "%.2f GB".format(b.toDouble() / (1024L * 1024 * 1024)) +} diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/MinibarOverlay.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/MinibarOverlay.kt new file mode 100644 index 000000000..b1d98bcb6 --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/MinibarOverlay.kt @@ -0,0 +1,141 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * The minibar: a thin persistent strip pinned to the bottom of every + * non-Player screen whenever a video is loaded into the MediaController. + * Tap to expand back to fullscreen. The × clears playback and dismisses. + * + * The actual player + audio lives in PlaybackService — this composable + * is purely UI on top of the MediaController. Pause/play toggles the + * controller, which is the same player feeding the fullscreen surface + * and the inline detail player. There is only ever one player. + */ + +package com.sulkta.straw.feature.player + +import androidx.compose.foundation.background +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.HorizontalDivider +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.DisposableEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import androidx.media3.common.Player +import androidx.media3.common.util.UnstableApi +import coil3.compose.AsyncImage + +@OptIn(UnstableApi::class) +@Composable +fun MinibarOverlay( + onExpand: () -> Unit, + modifier: Modifier = Modifier, +) { + val controller = LocalStrawController.current + val item by NowPlaying.current.collectAsStateWithLifecycle() + if (controller == null || item == null) return + val cur = item ?: return + + // Reflect the controller's play state in the play/pause icon. Listening + // is the only reliable way; isPlaying snapshots stale between events. + var isPlaying by remember { mutableStateOf(controller.isPlaying) } + DisposableEffect(controller) { + val listener = object : Player.Listener { + override fun onIsPlayingChanged(playing: Boolean) { + isPlaying = playing + } + } + controller.addListener(listener) + isPlaying = controller.isPlaying + onDispose { controller.removeListener(listener) } + } + + Column(modifier = modifier.fillMaxWidth()) { + HorizontalDivider() + Surface( + color = MaterialTheme.colorScheme.surfaceVariant, + modifier = Modifier + .fillMaxWidth() + .height(64.dp) + .clickable(onClick = onExpand), + ) { + Row( + verticalAlignment = Alignment.CenterVertically, + modifier = Modifier.padding(horizontal = 8.dp), + ) { + AsyncImage( + model = cur.thumbnail, + contentDescription = null, + modifier = Modifier + .size(width = 80.dp, height = 48.dp) + .clip(RoundedCornerShape(4.dp)) + .background(Color.Black), + ) + Spacer(modifier = Modifier.width(10.dp)) + Column(modifier = Modifier.weight(1f)) { + Text( + cur.title, + style = MaterialTheme.typography.bodyMedium, + fontWeight = FontWeight.SemiBold, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + Text( + cur.uploader, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + } + Row(horizontalArrangement = Arrangement.spacedBy(4.dp)) { + MinibarIconButton(label = if (isPlaying) "⏸" else "▶") { + if (controller.isPlaying) controller.pause() else controller.play() + } + MinibarIconButton(label = "×") { + controller.stop() + controller.clearMediaItems() + NowPlaying.clear() + } + } + } + } + } +} + +@Composable +private fun MinibarIconButton(label: String, onClick: () -> Unit) { + Box( + modifier = Modifier + .size(44.dp) + .clip(RoundedCornerShape(22.dp)) + .clickable(onClick = onClick), + contentAlignment = Alignment.Center, + ) { + Text(label, style = MaterialTheme.typography.titleMedium) + } +} diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/NowPlaying.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/NowPlaying.kt new file mode 100644 index 000000000..75e00f29c --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/NowPlaying.kt @@ -0,0 +1,42 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Singleton "currently active video" state — drives the minibar overlay + * and tells screens whether their video matches what's playing. Updated + * by whichever surface starts playback (VideoDetail tap, Player Play + * button, playlist item tap). Cleared by the minibar's × button. + * + * Why a process-wide singleton instead of a ViewModel: the minibar is + * rendered at the activity layout level and needs to outlive any + * specific Screen.* composable. Same shape as Subscriptions / Playlists + * — runtime-only here since there's no persistence (session-scoped). + */ + +package com.sulkta.straw.feature.player + +import com.sulkta.straw.net.SbSegment +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow + +data class NowPlayingItem( + val streamUrl: String, + val title: String, + val uploader: String, + val thumbnail: String?, + val segments: List = emptyList(), +) + +object NowPlaying { + private val _current = MutableStateFlow(null) + val current: StateFlow = _current.asStateFlow() + + fun set(item: NowPlayingItem?) { + _current.value = item + } + + fun clear() { + _current.value = null + } +} diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt index 8e20dfb04..61e0f1c47 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt @@ -2,51 +2,46 @@ * SPDX-FileCopyrightText: 2026 Sulkta-Coop * SPDX-License-Identifier: GPL-3.0-or-later * - * Phase S: foreground-service ExoPlayer for "Background" audio mode. - * Independent of the activity-side player. When the user taps Background - * on the player overlay, the activity stops its own playback and starts - * this service with the audio URL. Audio continues even if the activity - * is killed (swipe out of recents). + * Universal player for Straw. Owns the single ExoPlayer + MediaSession. + * Every UI surface (inline player on VideoDetail, fullscreen PlayerScreen, + * the minibar overlay) is a MediaController client talking to this + * session — so playback never restarts on a screen transition and a + * dragged-down player just keeps going at the bottom of the layout. * - * Audit fixes (2026-05-24 pass #2): - * CRIT-1: call startForeground() immediately on first onStartCommand so - * Android 12+ doesn't kill the process with - * ForegroundServiceDidNotStartInTimeException after the 5s window. - * HIGH-2: return START_NOT_STICKY when there is no playable URL — the - * OS will not relaunch us with a null intent and crash-loop. - * HIGH-3: stop the service when playback ends (Player.Listener) so the - * WAKE_LOCK / foreground notification doesn't linger. - * MED-1: null the field before releasing the session to close a tiny - * onGetSession race during teardown. + * The service is brought up automatically the first time the activity + * builds a MediaController against `SessionToken(ctx, ComponentName)`. + * It transitions to foreground when playback starts (Media3 handles the + * required notification); it stops itself when idle (no controllers + * connected AND nothing in the queue). * - * Limitations: - * - Single URL only. The activity-side merged-DASH path doesn't carry - * over (we just use the best audioStream). Acceptable trade-off for - * background mode. - * - No SponsorBlock skip here. That logic lives in PlayerScreen and is - * foreground-only for now. - * - Service plays one item at a time. Queue/playlist is future work. + * Media source dispatch lives in [StrawMediaSourceFactory] below. It + * routes by MIME type for DASH / HLS / progressive and merges video + + * audio when the audio URL is carried in the MediaItem's + * `requestMetadata.extras[EXTRA_AUDIO_URL]`. */ package com.sulkta.straw.feature.player -import android.app.Notification -import android.app.NotificationChannel -import android.app.NotificationManager import android.app.PendingIntent import android.content.Intent -import android.content.pm.ServiceInfo import android.net.Uri -import android.os.Build -import androidx.core.app.NotificationCompat import androidx.media3.common.AudioAttributes import androidx.media3.common.C import androidx.media3.common.MediaItem +import androidx.media3.common.MimeTypes import androidx.media3.common.Player import androidx.media3.common.util.UnstableApi +import androidx.media3.datasource.DataSource import androidx.media3.datasource.DefaultHttpDataSource import androidx.media3.exoplayer.ExoPlayer +import androidx.media3.exoplayer.dash.DashMediaSource +import androidx.media3.exoplayer.drm.DrmSessionManagerProvider +import androidx.media3.exoplayer.hls.HlsMediaSource import androidx.media3.exoplayer.source.DefaultMediaSourceFactory +import androidx.media3.exoplayer.source.MediaSource +import androidx.media3.exoplayer.source.MergingMediaSource +import androidx.media3.exoplayer.source.ProgressiveMediaSource +import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy import androidx.media3.session.MediaSession import androidx.media3.session.MediaSessionService import com.sulkta.straw.StrawActivity @@ -57,54 +52,51 @@ import com.sulkta.straw.net.STRAW_USER_AGENT class PlaybackService : MediaSessionService() { private var mediaSession: MediaSession? = null - private var foregroundStarted = false override fun onCreate() { super.onCreate() - ensureChannel() // Path C-7: wrap in IosSafeHttpDataSource so ExoPlayer's open-ended - // Range requests get chunked into bounded reads. iOS-bound googlevideo - // URLs 403 on `Range: bytes=N-` but accept `Range: bytes=N-M`. + // Range requests get chunked into bounded reads. iOS-bound + // googlevideo URLs 403 on `Range: bytes=N-` but accept `Range: + // bytes=N-M`. val httpFactory = IosSafeHttpDataSource.Factory( DefaultHttpDataSource.Factory() .setUserAgent(STRAW_USER_AGENT) .setAllowCrossProtocolRedirects(true) ) - val mediaSourceFactory = DefaultMediaSourceFactory(this) - .setDataSourceFactory(httpFactory) + + val mediaSourceFactory = StrawMediaSourceFactory(httpFactory) val player = ExoPlayer.Builder(this) .setMediaSourceFactory(mediaSourceFactory) .setAudioAttributes( AudioAttributes.Builder() .setUsage(C.USAGE_MEDIA) - .setContentType(C.AUDIO_CONTENT_TYPE_MUSIC) + .setContentType(C.AUDIO_CONTENT_TYPE_MOVIE) .build(), /* handleAudioFocus = */ true, ) .build() - // HIGH-3: end-of-playback should release the foreground slot. + // Stop ourselves once playback genuinely ends so the foreground slot + // is released. STATE_IDLE + STATE_ENDED both qualify; STATE_BUFFERING + // / STATE_READY mean we're still doing work even if paused. player.addListener(object : Player.Listener { override fun onPlaybackStateChanged(state: Int) { - if (state == Player.STATE_ENDED || state == Player.STATE_IDLE) { - stopSelf() - } + if (state == Player.STATE_ENDED) stopSelfWhenIdle() } }) val sessionActivityIntent = PendingIntent.getActivity( this, 0, - Intent(this, StrawActivity::class.java), + Intent(this, StrawActivity::class.java).apply { + addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP) + }, PendingIntent.FLAG_IMMUTABLE, ) - // Distinct session ID so we don't collide with the activity-side - // MediaSession (also in this process) when the user hands off from - // PlayerScreen → background audio. Default ID is "" which throws - // IllegalStateException("Session ID must be unique. ID="). mediaSession = MediaSession.Builder(this, player) .setId(MEDIA_SESSION_ID) .setSessionActivity(sessionActivityIntent) @@ -115,58 +107,24 @@ class PlaybackService : MediaSessionService() { controllerInfo: MediaSession.ControllerInfo, ): MediaSession? = mediaSession - override fun onStartCommand( - intent: Intent?, - flags: Int, - startId: Int, - ): Int { - // CRIT-1: must startForeground within ~5s of startForegroundService, - // before anything that can throw or block. - startForegroundCompat() - - val url = intent?.getStringExtra(EXTRA_URL)?.takeIf { isAllowedAudioUrl(it) } - val title = intent?.getStringExtra(EXTRA_TITLE) - val uploader = intent?.getStringExtra(EXTRA_UPLOADER) - val startPositionMs = intent?.getLongExtra(EXTRA_POSITION_MS, 0L)?.coerceAtLeast(0L) ?: 0L - val player = mediaSession?.player - if (url == null || player == null) { - // HIGH-2: nothing to play (likely a re-launch with null intent - // after a kill). Tear down so we don't sit holding the FG slot. - stopSelf() - return START_NOT_STICKY - } - - val item = MediaItem.Builder() - .setUri(url) - .setMediaMetadata( - androidx.media3.common.MediaMetadata.Builder() - .setTitle(title ?: "") - .setArtist(uploader ?: "") - .build(), - ) - .build() - player.setMediaItem(item, startPositionMs) - player.prepare() - player.playWhenReady = true - return START_NOT_STICKY - } - + /** + * When the user swipes the app out of Recents, only kill the service + * if playback isn't running. If the user is intentionally backgrounding + * to keep music going, we stay alive. + */ override fun onTaskRemoved(rootIntent: Intent?) { - // HIGH-3: keep service alive ONLY while playback is genuinely in - // progress. After STATE_ENDED, playWhenReady stays true but state - // is ENDED — old check missed that and held WAKE_LOCK forever. val p = mediaSession?.player - val keep = p != null && + val keepAlive = p != null && p.playWhenReady && p.mediaItemCount > 0 && p.playbackState != Player.STATE_IDLE && p.playbackState != Player.STATE_ENDED - if (!keep) stopSelf() + if (!keepAlive) stopSelf() } override fun onDestroy() { - // MED-1: null the field first so a late onGetSession from the - // controller-binding teardown gets null instead of a released session. + // Null the field first so a late onGetSession during teardown gets + // null rather than a released session. val s = mediaSession mediaSession = null s?.player?.release() @@ -174,73 +132,86 @@ class PlaybackService : MediaSessionService() { super.onDestroy() } - private fun startForegroundCompat() { - if (foregroundStarted) return - val tap = PendingIntent.getActivity( - this, - 0, - Intent(this, StrawActivity::class.java), - PendingIntent.FLAG_IMMUTABLE, - ) - val notification: Notification = NotificationCompat.Builder(this, NOTIF_CHANNEL_ID) - .setSmallIcon(android.R.drawable.ic_media_play) - .setContentTitle("Straw") - .setContentText("Background audio") - .setContentIntent(tap) - .setOngoing(true) - .setCategory(Notification.CATEGORY_TRANSPORT) - .setPriority(NotificationCompat.PRIORITY_LOW) - .build() - if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) { - startForeground( - NOTIF_ID, - notification, - ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK, - ) - } else { - startForeground(NOTIF_ID, notification) + private fun stopSelfWhenIdle() { + val p = mediaSession?.player ?: return + if (p.mediaItemCount == 0 || p.playbackState == Player.STATE_IDLE) { + stopSelf() } - foregroundStarted = true - } - - private fun ensureChannel() { - if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return - val nm = getSystemService(NotificationManager::class.java) ?: return - if (nm.getNotificationChannel(NOTIF_CHANNEL_ID) != null) return - val ch = NotificationChannel( - NOTIF_CHANNEL_ID, - "Background audio", - NotificationManager.IMPORTANCE_LOW, - ).apply { - description = "Straw audio playback while the app is in background" - setShowBadge(false) - } - nm.createNotificationChannel(ch) - } - - /** - * HIGH-4 mirror on the service side: the URL in EXTRA_URL came from - * NewPipeExtractor's audioStream.content. Re-validate host + scheme - * before handing it to ExoPlayer's HTTP source. Only YT googlevideo - * hosts allowed; HTTPS only. - */ - private fun isAllowedAudioUrl(url: String): Boolean { - val uri = runCatching { Uri.parse(url) }.getOrNull() ?: return false - if (!uri.scheme.equals("https", ignoreCase = true)) return false - val host = uri.host?.lowercase() ?: return false - return host.endsWith(".googlevideo.com") || - host.endsWith(".youtube.com") || - host == "youtube.com" } companion object { - const val EXTRA_URL = "com.sulkta.straw.extra.URL" - const val EXTRA_TITLE = "com.sulkta.straw.extra.TITLE" - const val EXTRA_UPLOADER = "com.sulkta.straw.extra.UPLOADER" - const val EXTRA_POSITION_MS = "com.sulkta.straw.extra.POSITION_MS" + const val MEDIA_SESSION_ID = "straw" - private const val NOTIF_CHANNEL_ID = "straw.playback" - private const val NOTIF_ID = 4242 - private const val MEDIA_SESSION_ID = "straw-bg" + /** + * Bundle key — when set on a MediaItem's `requestMetadata.extras`, + * the source factory will merge that audio URL with the + * MediaItem's video URI to produce a combined video+audio source. + */ + const val EXTRA_AUDIO_URL = "straw.audio_url" } } + +/** + * MediaSource.Factory that picks the right inner source per MediaItem: + * + * - If `requestMetadata.extras[EXTRA_AUDIO_URL]` is set → MergingMediaSource + * (progressive video + progressive audio). + * - Else by MIME: application/dash+xml → DASH, application/x-mpegURL → HLS, + * everything else → progressive. + * + * Lets us drive all stream shapes (DASH MPD, HLS, combined progressive, + * separate video+audio progressive) through the single MediaController API + * without exposing MediaSource directly to the UI layer. + */ +@UnstableApi +class StrawMediaSourceFactory( + private val dataSourceFactory: DataSource.Factory, +) : MediaSource.Factory { + private val dashFactory = DashMediaSource.Factory(dataSourceFactory) + private val hlsFactory = HlsMediaSource.Factory(dataSourceFactory) + private val progFactory = ProgressiveMediaSource.Factory(dataSourceFactory) + // For mime-sniffing fallthroughs we also fall back to DefaultMediaSourceFactory + // so things like extractors-only progressive items keep working. + private val defaultFactory = DefaultMediaSourceFactory(dataSourceFactory) + + override fun createMediaSource(mediaItem: MediaItem): MediaSource { + val audioUrl = mediaItem.requestMetadata.extras + ?.getString(PlaybackService.EXTRA_AUDIO_URL) + if (audioUrl != null) { + val videoSource = progFactory.createMediaSource(mediaItem) + val audioSource = progFactory.createMediaSource(MediaItem.fromUri(Uri.parse(audioUrl))) + return MergingMediaSource(videoSource, audioSource) + } + val mime = mediaItem.localConfiguration?.mimeType + return when (mime) { + MimeTypes.APPLICATION_MPD -> dashFactory.createMediaSource(mediaItem) + MimeTypes.APPLICATION_M3U8 -> hlsFactory.createMediaSource(mediaItem) + else -> { + // Try progressive first; fall back to the default factory's + // extractor-based selection so generic URIs (e.g. local + // file:// from the downloads dir) still work. + runCatching { progFactory.createMediaSource(mediaItem) } + .getOrElse { defaultFactory.createMediaSource(mediaItem) } + } + } + } + + override fun setDrmSessionManagerProvider(p: DrmSessionManagerProvider): MediaSource.Factory { + dashFactory.setDrmSessionManagerProvider(p) + hlsFactory.setDrmSessionManagerProvider(p) + progFactory.setDrmSessionManagerProvider(p) + defaultFactory.setDrmSessionManagerProvider(p) + return this + } + + override fun setLoadErrorHandlingPolicy(p: LoadErrorHandlingPolicy): MediaSource.Factory { + dashFactory.setLoadErrorHandlingPolicy(p) + hlsFactory.setLoadErrorHandlingPolicy(p) + progFactory.setLoadErrorHandlingPolicy(p) + defaultFactory.setLoadErrorHandlingPolicy(p) + return this + } + + override fun getSupportedTypes(): IntArray = + intArrayOf(C.CONTENT_TYPE_DASH, C.CONTENT_TYPE_HLS, C.CONTENT_TYPE_OTHER) +} diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt index 748c61379..173718f7a 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt @@ -2,78 +2,83 @@ * SPDX-FileCopyrightText: 2026 Sulkta-Coop * SPDX-License-Identifier: GPL-3.0-or-later * - * Phase C: Media3 PlayerView embedded in Compose. - * Phase D: SponsorBlock auto-skip wired in via position-poll loop. + * Fullscreen player surface. After the V-2 unification, the player + * itself lives in PlaybackService (one ExoPlayer for the whole app). + * This composable is a thin shell that: + * 1. Asks the PlayerViewModel to resolve the stream URL + * 2. Pushes the resolved MediaItem into the shared MediaController + * 3. Renders PlayerView bound to that controller + * 4. Runs the SponsorBlock skip loop against the controller + * 5. Lets the user drag-down to dismiss into the minibar + * + * Audio-only toggle, speed picker, share, manual PiP, and the + * background-audio button stay as overlays. Audio-only flips the + * controller's track-selection params; nothing more to do because + * playback is one player. */ package com.sulkta.straw.feature.player import android.app.Activity import android.app.PictureInPictureParams -import android.content.ComponentName import android.content.Intent import android.os.Build import android.util.Rational import android.widget.Toast -import androidx.core.content.ContextCompat import androidx.annotation.OptIn +import androidx.compose.animation.core.Animatable +import androidx.compose.animation.core.tween import androidx.compose.foundation.background import androidx.compose.foundation.clickable +import androidx.compose.foundation.gestures.detectVerticalDragGestures +import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.height import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material3.AlertDialog import androidx.compose.material3.CircularProgressIndicator import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Text import androidx.compose.material3.TextButton -import androidx.compose.foundation.layout.Column -import androidx.compose.foundation.layout.Row -import androidx.compose.foundation.layout.Spacer -import androidx.compose.foundation.layout.height -import androidx.compose.foundation.layout.width -import androidx.compose.foundation.layout.Arrangement import androidx.compose.runtime.Composable import androidx.compose.runtime.DisposableEffect import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope import androidx.compose.runtime.setValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.draw.clip import androidx.compose.ui.graphics.Color +import androidx.compose.ui.input.pointer.pointerInput import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.platform.LocalDensity +import androidx.compose.ui.unit.IntOffset import androidx.compose.ui.unit.dp import androidx.compose.ui.viewinterop.AndroidView -import androidx.lifecycle.Lifecycle -import androidx.lifecycle.LifecycleEventObserver -import androidx.lifecycle.compose.LocalLifecycleOwner +import androidx.compose.foundation.layout.offset import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.lifecycle.viewmodel.compose.viewModel -import androidx.media3.common.AudioAttributes import androidx.media3.common.C -import androidx.media3.common.MediaItem import androidx.media3.common.PlaybackParameters import androidx.media3.common.Player import androidx.media3.common.TrackSelectionParameters -import androidx.media3.common.TrackGroup as Media3TrackGroup import androidx.media3.common.util.UnstableApi -import androidx.media3.datasource.DefaultHttpDataSource -import androidx.media3.exoplayer.ExoPlayer -import androidx.media3.session.MediaSession -import androidx.media3.exoplayer.dash.DashMediaSource -import androidx.media3.exoplayer.hls.HlsMediaSource -import androidx.media3.exoplayer.source.MergingMediaSource -import androidx.media3.exoplayer.source.ProgressiveMediaSource import androidx.media3.ui.PlayerView -import com.sulkta.straw.net.STRAW_USER_AGENT import com.sulkta.straw.net.SbSegment import com.sulkta.straw.util.strawLogI +import kotlin.math.roundToInt import kotlinx.coroutines.delay +import kotlinx.coroutines.launch @OptIn(UnstableApi::class) @Composable @@ -81,195 +86,115 @@ fun PlayerScreen( streamUrl: String, title: String, startPositionMs: Long = 0L, + onMinimize: () -> Unit = {}, vm: PlayerViewModel = viewModel(), ) { val context = LocalContext.current + val controller = LocalStrawController.current val state by vm.ui.collectAsStateWithLifecycle() LaunchedEffect(streamUrl) { vm.resolve(streamUrl) } - // Local UI state for speed / audio-only / dialog open. var playbackSpeed by remember { mutableStateOf(1.0f) } var audioOnly by remember { mutableStateOf(false) } var showSpeedDialog by remember { mutableStateOf(false) } - val exoPlayer = remember { - ExoPlayer.Builder(context) - .setAudioAttributes( - // Tell the system we're playing media so audio focus + - // ducking + Bluetooth routing work, and notifications can - // sit alongside other media apps. - AudioAttributes.Builder() - .setUsage(C.USAGE_MEDIA) - .setContentType(C.AUDIO_CONTENT_TYPE_MOVIE) - .build(), - /* handleAudioFocus = */ true, - ) - .build() - } - - // Wrap the player in a MediaSession so the OS gets lock-screen + - // notification media controls while this Activity is alive. Full - // background-audio-after-Activity-kill is M-3 (MediaSessionService + - // MediaController refactor). - val mediaSession = remember { - MediaSession.Builder(context, exoPlayer).build() - } - - // Path C-7: surface ExoPlayer failures so they don't read as "stuck spinner" - // (Audit Finding 2). Posts to playbackError state which the UI renders. - var playbackError by remember { mutableStateOf(null) } - DisposableEffect(exoPlayer) { - val listener = object : androidx.media3.common.Player.Listener { - override fun onPlayerError(error: androidx.media3.common.PlaybackException) { - playbackError = - "${error.errorCodeName}: ${error.message ?: "(no message)"}" - } - } - exoPlayer.addListener(listener) - onDispose { exoPlayer.removeListener(listener) } - } - - DisposableEffect(Unit) { - onDispose { - mediaSession.release() - exoPlayer.release() - } - } - - // Home / recents button → seamless hand-off to background audio service - // instead of Picture-in-Picture. PiP is still available manually via the - // ⊟ overlay button. We register a handler that the activity calls from - // onUserLeaveHint(); the handler captures currentPosition so the audio - // service resumes from the same point. Same code path that the explicit - // 🎧 button uses. - val resolvedState = androidx.compose.runtime.rememberUpdatedState(state.resolved) - DisposableEffect(Unit) { - PlayerLeaveHandler.handler = handler@{ - val r = resolvedState.value ?: return@handler - val audio = r.audioUrl ?: r.combinedUrl ?: return@handler - val position = exoPlayer.currentPosition.coerceAtLeast(0L) - runCatching { exoPlayer.stop() } - runCatching { exoPlayer.clearMediaItems() } - val intent = Intent(context, PlaybackService::class.java).apply { - component = ComponentName(context, PlaybackService::class.java) - putExtra(PlaybackService.EXTRA_URL, audio) - putExtra(PlaybackService.EXTRA_TITLE, title) - putExtra(PlaybackService.EXTRA_POSITION_MS, position) - } - ContextCompat.startForegroundService(context, intent) - } - onDispose { PlayerLeaveHandler.handler = null } - } - - // AUD-MED: pause playback when app goes to background. Without this, - // ExoPlayer keeps playing audio with no MediaSession — user can't pause - // from the notification shade. EXCEPTION: don't pause when entering - // Picture-in-Picture mode (that's the whole point of PiP). - val lifecycleOwner = LocalLifecycleOwner.current - DisposableEffect(lifecycleOwner) { - val observer = LifecycleEventObserver { _, event -> - if (event == Lifecycle.Event.ON_STOP) { - val activity = context as? Activity - if (activity?.isInPictureInPictureMode != true) { - exoPlayer.pause() - } - } - } - lifecycleOwner.lifecycle.addObserver(observer) - onDispose { lifecycleOwner.lifecycle.removeObserver(observer) } - } + // Drag-to-minimize: vertical offset accumulated during the gesture. + // On release, if past threshold we dismiss into the minibar. + val density = LocalDensity.current + val dismissThresholdPx = with(density) { 200.dp.toPx() } + val dragY = remember { Animatable(0f) } + val scope = rememberCoroutineScope() + // Push the resolved video into the shared controller as soon as we + // have stream URLs. If something else is already playing the same + // streamUrl, just seek instead of re-loading. + // For metadata that vm.resolve doesn't return (uploader / thumbnail) we + // try to lift them from the matching VideoDetail item if it's open in + // the same nav stack; otherwise fall back to whatever NowPlaying + // already has. Either way the minibar gets enough to render. + val detailVm: com.sulkta.straw.feature.detail.VideoDetailViewModel = viewModel() + LaunchedEffect(streamUrl) { detailVm.load(streamUrl) } + val detailState by detailVm.ui.collectAsStateWithLifecycle() val resolved = state.resolved - - LaunchedEffect(resolved) { + LaunchedEffect(controller, resolved, detailState.detail) { + val c = controller ?: return@LaunchedEffect val r = resolved ?: return@LaunchedEffect - // Path C-7: chunk open-ended Range requests so iOS googlevideo URLs - // don't 403 on first byte. - val dataSourceFactory = com.sulkta.straw.net.IosSafeHttpDataSource.Factory( - DefaultHttpDataSource.Factory() - .setUserAgent(STRAW_USER_AGENT) - .setAllowCrossProtocolRedirects(true) - ) - - val source = when { - r.dashMpdUrl != null -> DashMediaSource.Factory(dataSourceFactory) - .createMediaSource(MediaItem.fromUri(r.dashMpdUrl)) - - r.hlsUrl != null -> HlsMediaSource.Factory(dataSourceFactory) - .createMediaSource(MediaItem.fromUri(r.hlsUrl)) - - r.combinedUrl != null -> ProgressiveMediaSource.Factory(dataSourceFactory) - .createMediaSource(MediaItem.fromUri(r.combinedUrl)) - - r.videoUrl != null && r.audioUrl != null -> { - val v = ProgressiveMediaSource.Factory(dataSourceFactory) - .createMediaSource(MediaItem.fromUri(r.videoUrl)) - val a = ProgressiveMediaSource.Factory(dataSourceFactory) - .createMediaSource(MediaItem.fromUri(r.audioUrl)) - MergingMediaSource(v, a) - } - - r.videoUrl != null -> ProgressiveMediaSource.Factory(dataSourceFactory) - .createMediaSource(MediaItem.fromUri(r.videoUrl)) - - else -> null - } - - if (source != null) { - exoPlayer.setMediaSource(source) - // V-2: when we navigate here from an inline player that was - // already playing, pick up at the same position instead of - // restarting. seekTo() before prepare() is allowed; the seek - // is queued and applied once the player is ready. - if (startPositionMs > 0) { - exoPlayer.seekTo(startPositionMs) - } - exoPlayer.prepare() - exoPlayer.playWhenReady = true - } - } - - // SponsorBlock auto-skip — poll position every 150ms, seek past any segment. - // AUD-HIGH fixes vs initial impl: - // - dedup skipped segments via UUID so re-listen doesn't fight the user - // - tighter poll (150ms) reduces sponsor leak through buffering window - // - check playbackState != IDLE/ENDED (was isPlaying, which is false - // during buffering and missed the skip window) - // - clamp seek target away from duration boundary to avoid jank - val skippedUuids = remember { mutableSetOf() } - LaunchedEffect(resolved?.segments) { - val segments = resolved?.segments ?: return@LaunchedEffect - if (segments.isEmpty()) return@LaunchedEffect - skippedUuids.clear() - while (true) { - delay(150) - val state = exoPlayer.playbackState - if (state == Player.STATE_IDLE || state == Player.STATE_ENDED) continue - val posSec = exoPlayer.currentPosition / 1000.0 - val segment = pickActiveSegment(segments, posSec, skippedUuids) ?: continue - strawLogI( - "StrawSb", - "skip: ${segment.category} ${segment.startSec}s..${segment.endSec}s (pos=$posSec)", + val d = detailState.detail + val uploader = d?.uploader ?: NowPlaying.current.value?.uploader.orEmpty() + val thumbnail = d?.thumbnail ?: NowPlaying.current.value?.thumbnail + val sameVideo = NowPlaying.current.value?.streamUrl == streamUrl + val currentTitle = c.mediaMetadata.title?.toString() + if (sameVideo && currentTitle == title) { + if (startPositionMs > 0) c.seekTo(startPositionMs) + if (!c.isPlaying) c.play() + NowPlaying.set( + NowPlayingItem( + streamUrl = streamUrl, + title = title, + uploader = uploader, + thumbnail = thumbnail, + segments = r.segments, + ), + ) + } else { + c.setPlayingFrom( + streamUrl = streamUrl, + title = title, + uploader = uploader, + thumbnail = thumbnail, + resolved = r, + startPositionMs = startPositionMs, ) - val targetMs = (segment.endSec * 1000).toLong() - val durationMs = exoPlayer.duration - if (durationMs > 0 && targetMs >= durationMs - 500) { - // Past end — let it end naturally rather than seeking past content. - exoPlayer.seekTo(durationMs - 1) - } else { - exoPlayer.seekTo(targetMs) - } - segment.UUID?.let { skippedUuids.add(it) } - Toast.makeText(context, "skipped ${segment.category}", Toast.LENGTH_SHORT).show() } } + // Surface ExoPlayer failures from the service into the UI. + var playbackError by remember { mutableStateOf(null) } + DisposableEffect(controller) { + val c = controller + val listener = object : Player.Listener { + override fun onPlayerError(error: androidx.media3.common.PlaybackException) { + playbackError = "${error.errorCodeName}: ${error.message ?: "(no message)"}" + } + } + c?.addListener(listener) + onDispose { c?.removeListener(listener) } + } + + // Manual-PiP wiring (the ⊟ overlay button). The activity is the PiP + // host; we just feed it the right params. Auto-enter-on-home stays + // disabled — HOME triggers seamless minibar/background per #255. + val activity = context as? Activity + Box( - modifier = Modifier.fillMaxSize(), + modifier = Modifier + .fillMaxSize() + .offset { IntOffset(0, dragY.value.roundToInt()) } + .pointerInput(Unit) { + detectVerticalDragGestures( + onDragEnd = { + if (dragY.value > dismissThresholdPx) { + // Snap to dismiss + pop into minibar. + onMinimize() + } else { + scope.launch { dragY.animateTo(0f, tween(180)) } + } + }, + onDragCancel = { + scope.launch { dragY.animateTo(0f, tween(180)) } + }, + onVerticalDrag = { _, dy -> + scope.launch { + // Clamp to non-negative — upward drag has no effect. + dragY.snapTo((dragY.value + dy).coerceAtLeast(0f)) + } + }, + ) + }, contentAlignment = Alignment.Center, ) { when { - state.loading -> CircularProgressIndicator() + state.loading || controller == null -> CircularProgressIndicator() state.error != null -> Text( "playback error: ${state.error}", @@ -292,14 +217,15 @@ fun PlayerScreen( AndroidView( factory = { ctx -> PlayerView(ctx).apply { - player = exoPlayer + player = controller useController = true } }, + update = { it.player = controller }, modifier = Modifier.fillMaxSize(), ) // SponsorBlock segment count badge — small overlay top-left. - resolved?.let { r -> + resolved.let { r -> Box( modifier = Modifier .align(Alignment.TopStart) @@ -315,20 +241,17 @@ fun PlayerScreen( ) } } - // Top-right overlay — speed / audio-only / share / PiP. + // Top-right overlay — speed / audio-only / share / PiP / minimize. Row( modifier = Modifier.align(Alignment.TopEnd).padding(12.dp), horizontalArrangement = Arrangement.spacedBy(8.dp), ) { - // Playback speed OverlayButton(label = if (playbackSpeed == 1f) "1×" else "${playbackSpeed}×") { showSpeedDialog = true } - // Audio-only toggle OverlayButton(label = if (audioOnly) "📻" else "📺") { audioOnly = !audioOnly - // Disable / enable video renderer via track-selection params. - exoPlayer.trackSelectionParameters = TrackSelectionParameters.Builder(context) + controller.trackSelectionParameters = TrackSelectionParameters.Builder(context) .setTrackTypeDisabled(C.TRACK_TYPE_VIDEO, audioOnly) .build() Toast.makeText( @@ -337,7 +260,6 @@ fun PlayerScreen( Toast.LENGTH_SHORT, ).show() } - // Share OverlayButton(label = "↗") { val send = Intent(Intent.ACTION_SEND).apply { type = "text/plain" @@ -346,11 +268,8 @@ fun PlayerScreen( } context.startActivity(Intent.createChooser(send, "Share video")) } - // PiP — manual entry (auto-enter on home gesture is wired - // up via the DisposableEffect above on Android 12+). OverlayButton(label = "⊟") { - val act = (context as? Activity) - if (act == null) { + if (activity == null) { Toast.makeText(context, "PiP: no activity", Toast.LENGTH_SHORT).show() return@OverlayButton } @@ -361,51 +280,16 @@ fun PlayerScreen( val params = PictureInPictureParams.Builder() .setAspectRatio(Rational(16, 9)) .build() - val result = runCatching { act.enterPictureInPictureMode(params) } - result.onSuccess { ok -> - if (!ok) { - Toast.makeText( - context, - "PiP refused — check Settings > Apps > Straw > PiP", - Toast.LENGTH_LONG, - ).show() + runCatching { activity.enterPictureInPictureMode(params) } + .onSuccess { ok -> + if (!ok) Toast.makeText(context, "PiP refused", Toast.LENGTH_LONG).show() + } + .onFailure { t -> + Toast.makeText(context, "PiP failed: ${t.message}", Toast.LENGTH_LONG).show() } - } - result.onFailure { t -> - Toast.makeText( - context, - "PiP failed: ${t.message ?: t.javaClass.simpleName}", - Toast.LENGTH_LONG, - ).show() - } - } - // Background audio (phase S) — independent foreground-service playback. - // Audit HIGH-1: handing off, not dual-hosting. Stop activity's player - // first so the OS sees a single MediaSession (cleaner lockscreen + - // audio focus) and we don't leak two active ExoPlayers. - OverlayButton(label = "🎧") { - val r = resolved ?: return@OverlayButton - val audio = r.audioUrl ?: r.combinedUrl - if (audio == null) { - Toast.makeText(context, "no audio stream", Toast.LENGTH_SHORT).show() - return@OverlayButton - } - val position = exoPlayer.currentPosition.coerceAtLeast(0L) - runCatching { exoPlayer.stop() } - runCatching { exoPlayer.clearMediaItems() } - val intent = Intent(context, PlaybackService::class.java).apply { - component = ComponentName(context, PlaybackService::class.java) - putExtra(PlaybackService.EXTRA_URL, audio) - putExtra(PlaybackService.EXTRA_TITLE, title) - putExtra(PlaybackService.EXTRA_POSITION_MS, position) - } - ContextCompat.startForegroundService(context, intent) - Toast.makeText( - context, - "background audio started — close the app whenever", - Toast.LENGTH_SHORT, - ).show() } + // Explicit minimize button — same effect as drag-down. + OverlayButton(label = "⌄") { onMinimize() } } if (showSpeedDialog) { @@ -413,7 +297,7 @@ fun PlayerScreen( current = playbackSpeed, onPick = { s -> playbackSpeed = s - exoPlayer.playbackParameters = PlaybackParameters(s) + controller.playbackParameters = PlaybackParameters(s) showSpeedDialog = false }, onDismiss = { showSpeedDialog = false }, @@ -475,9 +359,45 @@ private fun SpeedPickerDialog( } /** - * Returns the segment whose interval contains [posSec], if any, skipping - * UUIDs in [skipped]. Filters out POI-style point segments (start == end). + * SponsorBlock skip loop driven by the controller's currentPosition. + * Runs at the activity composition root (not per-screen) so it skips + * segments whether the user is fullscreen, in the minibar, or away from + * the player surface. */ +@Composable +@OptIn(UnstableApi::class) +fun SponsorBlockSkipLoop() { + val controller = LocalStrawController.current + val context = LocalContext.current + val item by NowPlaying.current.collectAsStateWithLifecycle() + val cur = item ?: return + val segments = cur.segments + if (segments.isEmpty() || controller == null) return + val skipped = remember(cur.streamUrl) { mutableSetOf() } + LaunchedEffect(cur.streamUrl, controller) { + while (true) { + delay(150) + val state = controller.playbackState + if (state == Player.STATE_IDLE || state == Player.STATE_ENDED) continue + val posSec = controller.currentPosition / 1000.0 + val s = pickActiveSegment(segments, posSec, skipped) ?: continue + strawLogI( + "StrawSb", + "skip: ${s.category} ${s.startSec}s..${s.endSec}s (pos=$posSec)", + ) + val targetMs = (s.endSec * 1000).toLong() + val durationMs = controller.duration + if (durationMs > 0 && targetMs >= durationMs - 500) { + controller.seekTo(durationMs - 1) + } else { + controller.seekTo(targetMs) + } + s.UUID?.let { skipped.add(it) } + Toast.makeText(context, "skipped ${s.category}", Toast.LENGTH_SHORT).show() + } + } +} + private fun pickActiveSegment( segments: List, posSec: Double, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt new file mode 100644 index 000000000..6ad3d376f --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt @@ -0,0 +1,144 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Composable bridge to the PlaybackService MediaController. + * + * Why this file exists: every UI surface in Straw (inline player on the + * detail screen, the fullscreen Player, the minibar overlay) renders the + * same single underlying MediaController. We expose it via a + * CompositionLocal so the screens don't have to know how to connect. + * + * The controller is built async — SessionToken bind happens on a + * background thread, the controller future resolves once the service is + * up. Until then `LocalStrawController.current` is null; consumers + * should render placeholder UI in that brief window. + * + * Lifecycle: tied to the activity's composition. When the activity + * finishes the DisposableEffect cleanup releases the future. The + * MediaSessionService stays alive iff there's still something playing + * (its own onTaskRemoved + STATE_ENDED logic handles that). + * + * Also: a small helper, [setPlayingFrom], that knows how to convert + * Straw's domain ResolvedPlayback (DASH URL / HLS URL / combined URL / + * video+audio pair) into a single MediaItem the service understands. + */ + +package com.sulkta.straw.feature.player + +import android.content.ComponentName +import android.os.Bundle +import androidx.compose.runtime.Composable +import androidx.compose.runtime.DisposableEffect +import androidx.compose.runtime.compositionLocalOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.ui.platform.LocalContext +import androidx.media3.common.MediaItem +import androidx.media3.common.MediaMetadata +import androidx.media3.common.MimeTypes +import androidx.media3.common.util.UnstableApi +import androidx.media3.session.MediaController +import androidx.media3.session.SessionToken +import com.google.common.util.concurrent.MoreExecutors + +val LocalStrawController = compositionLocalOf { null } + +@Composable +fun rememberStrawController(): MediaController? { + val context = LocalContext.current + val state = remember { mutableStateOf(null) } + DisposableEffect(Unit) { + val token = SessionToken(context, ComponentName(context, PlaybackService::class.java)) + val future = MediaController.Builder(context, token).buildAsync() + future.addListener({ + // future.get() throws if the build failed; treat as null in that case. + state.value = runCatching { future.get() }.getOrNull() + }, MoreExecutors.directExecutor()) + onDispose { + MediaController.releaseFuture(future) + state.value = null + } + } + return state.value +} + +/** + * Push a resolved video into the controller and update NowPlaying. + * + * Stream-shape preference matches the previous activity-side picker: + * DASH (full quality + adaptive) > HLS > combined progressive > merged + * video+audio progressives > video-only progressive. The + * [StrawMediaSourceFactory] on the service end picks the right inner + * MediaSource based on MIME + the EXTRA_AUDIO_URL bundle. + */ +@UnstableApi +fun MediaController.setPlayingFrom( + streamUrl: String, + title: String, + uploader: String, + thumbnail: String?, + resolved: ResolvedPlayback, + startPositionMs: Long = 0L, +) { + val item = buildMediaItem(title, uploader, thumbnail, resolved) ?: return + setMediaItem(item, startPositionMs) + prepare() + playWhenReady = true + NowPlaying.set( + NowPlayingItem( + streamUrl = streamUrl, + title = title, + uploader = uploader, + thumbnail = thumbnail, + segments = resolved.segments, + ), + ) +} + +@UnstableApi +private fun buildMediaItem( + title: String, + uploader: String, + thumbnail: String?, + r: ResolvedPlayback, +): MediaItem? { + val metadata = MediaMetadata.Builder() + .setTitle(title) + .setArtist(uploader) + .apply { + thumbnail?.let { setArtworkUri(android.net.Uri.parse(it)) } + } + .build() + val baseBuilder = MediaItem.Builder().setMediaMetadata(metadata) + return when { + !r.dashMpdUrl.isNullOrBlank() -> baseBuilder + .setUri(r.dashMpdUrl) + .setMimeType(MimeTypes.APPLICATION_MPD) + .build() + !r.hlsUrl.isNullOrBlank() -> baseBuilder + .setUri(r.hlsUrl) + .setMimeType(MimeTypes.APPLICATION_M3U8) + .build() + !r.combinedUrl.isNullOrBlank() -> baseBuilder + .setUri(r.combinedUrl) + .build() + !r.videoUrl.isNullOrBlank() && !r.audioUrl.isNullOrBlank() -> { + val extras = Bundle().apply { + putString(PlaybackService.EXTRA_AUDIO_URL, r.audioUrl) + } + baseBuilder + .setUri(r.videoUrl) + .setRequestMetadata( + MediaItem.RequestMetadata.Builder() + .setExtras(extras) + .build(), + ) + .build() + } + !r.videoUrl.isNullOrBlank() -> baseBuilder + .setUri(r.videoUrl) + .build() + else -> null + } +} From 3ff9740c408c6c3be7717a4b5ed4adbf7010b3cd Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 16:25:30 +0000 Subject: [PATCH 07/72] detail: wrap action row with FlowRow so Save doesnt clip on narrow widths --- .../com/sulkta/straw/feature/detail/VideoDetailScreen.kt | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index 3f93f1df6..cc33676fe 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -10,6 +10,8 @@ import androidx.compose.foundation.clickable import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.ExperimentalLayoutApi +import androidx.compose.foundation.layout.FlowRow import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.Spacer import androidx.compose.foundation.layout.aspectRatio @@ -75,6 +77,7 @@ import com.sulkta.straw.util.formatCount import com.sulkta.straw.util.formatViews import com.sulkta.straw.util.stripHtml +@OptIn(ExperimentalLayoutApi::class) @Composable fun VideoDetailScreen( streamUrl: String, @@ -218,7 +221,10 @@ fun VideoDetailScreen( } Spacer(modifier = Modifier.height(16.dp)) - Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) { + FlowRow( + horizontalArrangement = Arrangement.spacedBy(12.dp), + verticalArrangement = Arrangement.spacedBy(8.dp), + ) { Button(onClick = { onPlay(inlinePositionMs) }) { Text("Play") } OutlinedButton(onClick = { val send = Intent(Intent.ACTION_SEND).apply { From 1443bb8ef77aee4346e3dfc2475eb521c747d5b7 Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 16:44:27 +0000 Subject: [PATCH 08/72] vc=24: NewPipe/Tubular settings import MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Settings screen now has an Import section. Picks a NewPipeData-*.zip or TubularData-*.zip via the SAF, extracts newpipe.db + preferences.json, and walks the Room SQLite schema (subscriptions / playlists / playlist_stream_join / streams / search_history / stream_history / stream_state). YouTube only — service_id=0 filter drops SoundCloud/PeerTube/etc. Imported on smoke: 26 subs, 1 playlist with 10 items, 50/11402 watch history (capped by HistoryStore MAX_WATCHES), 20/2242 searches (MAX_SEARCHES), 8 settings keys (SponsorBlock category toggles + default resolution). Resume positions counted (10918) but not yet persisted — Straw has no resume-store yet. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- .../feature/dataimport/SettingsImport.kt | 419 ++++++++++++++++++ .../straw/feature/settings/SettingsScreen.kt | 81 +++- 3 files changed, 498 insertions(+), 6 deletions(-) create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/feature/dataimport/SettingsImport.kt diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 14969bfa5..c5fbc9d7f 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 23 -const val STRAW_VERSION_NAME = "0.1.0-AI" +const val STRAW_VERSION_CODE = 24 +const val STRAW_VERSION_NAME = "0.1.0-AJ" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/dataimport/SettingsImport.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/dataimport/SettingsImport.kt new file mode 100644 index 000000000..4e138788e --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/dataimport/SettingsImport.kt @@ -0,0 +1,419 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * NewPipe / Tubular export importer. + * + * The user picks an exported `.zip` (NewPipe writes it as + * `NewPipeData-.zip`, Tubular as `TubularData-.zip`). + * Inside: + * - newpipe.db Room SQLite (subscriptions, playlists, history…) + * - preferences.json flat key/value of all user settings + * - newpipe.settings superseded XML form of preferences (we ignore) + * + * We populate Straw's existing stores (Subscriptions, Playlists, History, + * Settings) — filtering to service_id=0 (YouTube). Other services + * (SoundCloud / PeerTube / …) are silently dropped — we don't support + * them and a mixed import would surprise the user later. + * + * Resume positions (NewPipe `stream_state` table) are read but + * intentionally not persisted yet — Straw has no resume-positions + * store. Counted in [ImportResult.resumePositionsSeen] so the user + * knows the data was present even if dropped. + */ + +package com.sulkta.straw.feature.dataimport + +import android.content.Context +import android.database.sqlite.SQLiteDatabase +import android.net.Uri +import com.sulkta.straw.data.ChannelRef +import com.sulkta.straw.data.History +import com.sulkta.straw.data.PlaylistItem +import com.sulkta.straw.data.Playlists +import com.sulkta.straw.data.SbCategory +import com.sulkta.straw.data.Settings +import com.sulkta.straw.data.Subscriptions +import com.sulkta.straw.data.WatchHistoryItem +import java.io.File +import java.util.zip.ZipInputStream +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext +import kotlinx.serialization.json.Json +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.boolean +import kotlinx.serialization.json.contentOrNull +import kotlinx.serialization.json.jsonPrimitive + +data class ImportResult( + val subscriptionsAdded: Int, + val subscriptionsSkippedNonYt: Int, + val playlistsAdded: Int, + val playlistItemsAdded: Int, + val searchHistoryAdded: Int, + val searchHistoryAvailable: Int, + val watchHistoryAdded: Int, + val watchHistoryAvailable: Int, + val resumePositionsSeen: Int, + val settingsApplied: Int, + val warnings: List, +) { + fun summary(): String = buildString { + append("Imported ") + append(subscriptionsAdded) + append(" subs") + if (subscriptionsSkippedNonYt > 0) { + append(" (skipped ") + append(subscriptionsSkippedNonYt) + append(" non-YouTube)") + } + append(", ") + append(playlistsAdded) + append(" playlist") + if (playlistsAdded != 1) append("s") + append(" (") + append(playlistItemsAdded) + append(" videos), ") + append(watchHistoryAdded) + append("/") + append(watchHistoryAvailable) + append(" watch history, ") + append(searchHistoryAdded) + append("/") + append(searchHistoryAvailable) + append(" searches, ") + append(settingsApplied) + append(" settings.") + if (resumePositionsSeen > 0) { + append(" Resume positions (") + append(resumePositionsSeen) + append(") not yet supported — dropped.") + } + if (warnings.isNotEmpty()) { + append("\n\nWarnings:\n") + warnings.forEach { append("• "); append(it); append("\n") } + } + } +} + +object SettingsImport { + + // YouTube only — Straw doesn't extract from other services. + private const val YT_SERVICE_ID = 0 + + suspend fun run(context: Context, zipUri: Uri): Result = + withContext(Dispatchers.IO) { + runCatching { runInner(context, zipUri) } + } + + private fun runInner(context: Context, zipUri: Uri): ImportResult { + val warnings = mutableListOf() + val workDir = File(context.cacheDir, "newpipe-import-${System.currentTimeMillis()}") + workDir.mkdirs() + try { + val (dbFile, prefsJson) = extractZip(context, zipUri, workDir, warnings) + + val subsResult = if (dbFile != null) importSubscriptions(dbFile) else SubsResult(0, 0) + val plResult = if (dbFile != null) importPlaylists(dbFile) else PlResult(0, 0) + val histResult = if (dbFile != null) importHistory(dbFile) else HistResult(0, 0, 0, 0, 0) + val settingsResult = if (prefsJson != null) importSettings(prefsJson) else 0 + + return ImportResult( + subscriptionsAdded = subsResult.added, + subscriptionsSkippedNonYt = subsResult.skipped, + playlistsAdded = plResult.playlists, + playlistItemsAdded = plResult.items, + searchHistoryAdded = histResult.searches, + searchHistoryAvailable = histResult.searchesAvailable, + watchHistoryAdded = histResult.watchesAdded, + watchHistoryAvailable = histResult.watchesAvailable, + resumePositionsSeen = histResult.resumePositions, + settingsApplied = settingsResult, + warnings = warnings, + ) + } finally { + workDir.deleteRecursively() + } + } + + private fun extractZip( + context: Context, + zipUri: Uri, + workDir: File, + warnings: MutableList, + ): Pair { + var dbFile: File? = null + var prefs: JsonObject? = null + context.contentResolver.openInputStream(zipUri)?.use { input -> + ZipInputStream(input).use { zip -> + while (true) { + val entry = zip.nextEntry ?: break + when (entry.name) { + "newpipe.db" -> { + val out = File(workDir, "newpipe.db") + out.outputStream().use { os -> + zip.copyTo(os, bufferSize = 64 * 1024) + } + dbFile = out + } + "preferences.json" -> { + val bytes = zip.readBytes() + prefs = runCatching { + Json.parseToJsonElement(bytes.decodeToString()) as? JsonObject + }.getOrNull() + if (prefs == null) warnings += "preferences.json present but unparseable" + } + // newpipe.settings is the legacy XML form; preferences.json + // supersedes it in every modern export. Skip. + else -> { /* ignore other entries */ } + } + zip.closeEntry() + } + } + } ?: error("Could not open the selected file") + if (dbFile == null) warnings += "newpipe.db not found in archive — most data skipped" + if (prefs == null) warnings += "preferences.json not found — settings not migrated" + return dbFile to prefs + } + + private data class SubsResult(val added: Int, val skipped: Int) + private fun importSubscriptions(dbFile: File): SubsResult { + val store = Subscriptions.get() + var added = 0 + var skipped = 0 + openDb(dbFile).use { db -> + db.rawQuery( + "SELECT url, name, avatar_url, service_id FROM subscriptions", + null, + ).use { c -> + while (c.moveToNext()) { + val serviceId = c.getInt(3) + if (serviceId != YT_SERVICE_ID) { + skipped++ + continue + } + val url = c.getString(0) ?: continue + val name = c.getString(1) ?: continue + val avatar = c.getString(2) + if (!store.isSubscribed(url)) { + store.toggle(ChannelRef(url = url, name = name, avatar = avatar)) + added++ + } + } + } + } + return SubsResult(added, skipped) + } + + private data class PlResult(val playlists: Int, val items: Int) + private fun importPlaylists(dbFile: File): PlResult { + val store = Playlists.get() + var playlistsAdded = 0 + var itemsAdded = 0 + openDb(dbFile).use { db -> + val playlistRows = mutableListOf>() + db.rawQuery("SELECT uid, name FROM playlists", null).use { c -> + while (c.moveToNext()) { + val uid = c.getLong(0) + val name = c.getString(1) ?: "Untitled" + playlistRows += uid to name + } + } + for ((uid, name) in playlistRows) { + val items = mutableListOf() + db.rawQuery( + """ + SELECT s.url, s.title, s.thumbnail_url, s.uploader, s.service_id + FROM playlist_stream_join j + JOIN streams s ON s.uid = j.stream_id + WHERE j.playlist_id = ? + ORDER BY j.join_index + """.trimIndent(), + arrayOf(uid.toString()), + ).use { c -> + while (c.moveToNext()) { + if (c.getInt(4) != YT_SERVICE_ID) continue + items += PlaylistItem( + streamUrl = c.getString(0) ?: continue, + title = c.getString(1) ?: "(no title)", + thumbnail = c.getString(2), + uploader = c.getString(3) ?: "", + addedAt = System.currentTimeMillis(), + ) + } + } + if (items.isEmpty()) continue + // Use the store's normal create + addItem rather than minting + // a Playlist directly — keeps the atomic-update path + // consistent with user-driven creates. + val created = store.create(name) + for (it in items) store.addItem(created.id, it) + playlistsAdded++ + itemsAdded += items.size + } + } + return PlResult(playlistsAdded, itemsAdded) + } + + private data class HistResult( + val watchesAdded: Int, + val watchesAvailable: Int, + val searches: Int, + val searchesAvailable: Int, + val resumePositions: Int, + ) + + private fun importHistory(dbFile: File): HistResult { + val historyStore = History.get() + var watchesSeen = 0 + var watchesAvailable = 0 + var searchesSeen = 0 + var resumePositions = 0 + val searchesBefore = historyStore.searches.value.size + val watchesBefore = historyStore.watches.value.size + openDb(dbFile).use { db -> + // Search history — feed oldest first so the store ends up with + // the most-recent on top after its own dedup + take(MAX). + db.rawQuery( + "SELECT search FROM search_history WHERE service_id=? ORDER BY creation_date ASC", + arrayOf(YT_SERVICE_ID.toString()), + ).use { c -> + while (c.moveToNext()) { + val q = c.getString(0) ?: continue + historyStore.recordSearch(q) + searchesSeen++ + } + } + + // Watch history — newest first via stream_history.access_date, + // joined to streams for the metadata we need. + // recordWatch caps internally; we just stop counting "added" once + // we've replayed Straw's MAX rows. (The store reverses to put + // most-recent on top — so we feed it oldest-first to match.) + db.rawQuery("SELECT COUNT(*) FROM stream_history", null).use { c -> + if (c.moveToNext()) watchesAvailable = c.getInt(0) + } + db.rawQuery( + """ + SELECT s.url, s.title, s.uploader, s.thumbnail_url, h.access_date, s.service_id + FROM stream_history h + JOIN streams s ON s.uid = h.stream_id + ORDER BY h.access_date ASC + """.trimIndent(), + null, + ).use { c -> + while (c.moveToNext()) { + if (c.getInt(5) != YT_SERVICE_ID) continue + val url = c.getString(0) ?: continue + val title = c.getString(1) ?: continue + val uploader = c.getString(2) ?: "" + val thumb = c.getString(3) + val videoId = extractYtVideoId(url) ?: continue + historyStore.recordWatch( + WatchHistoryItem( + url = url, + videoId = videoId, + title = title, + uploader = uploader, + thumbnail = thumb, + watchedAt = c.getLong(4), + ), + ) + watchesSeen++ + } + } + + // Resume positions — counted, not stored. Future task hooks into + // a ResumePositionsStore. + db.rawQuery("SELECT COUNT(*) FROM stream_state", null).use { c -> + if (c.moveToNext()) resumePositions = c.getInt(0) + } + } + // Report what actually landed in the store after its dedup + caps. + return HistResult( + watchesAdded = historyStore.watches.value.size - watchesBefore, + watchesAvailable = watchesAvailable.takeIf { it > 0 } ?: watchesSeen, + searches = historyStore.searches.value.size - searchesBefore, + resumePositions = resumePositions, + searchesAvailable = searchesSeen, + ) + } + + private fun importSettings(prefs: JsonObject): Int { + val settings = Settings.get() + var applied = 0 + + // SponsorBlock: master toggle gates the categories. If disabled in + // NewPipe, leave Straw's categories alone (they have a non-empty + // default). If enabled, sync each category boolean. + val sbMaster = prefs.boolOrNull("sponsor_block_enable") + if (sbMaster == true) { + val targets = mapOf( + "sponsor_block_category_sponsor" to SbCategory.Sponsor, + "sponsor_block_category_self_promo" to SbCategory.SelfPromo, + "sponsor_block_category_intro" to SbCategory.Intro, + "sponsor_block_category_outro" to SbCategory.Outro, + "sponsor_block_category_interaction" to SbCategory.Interaction, + "sponsor_block_category_music" to SbCategory.MusicOfftopic, + "sponsor_block_category_filler" to SbCategory.Filler, + ) + val current = settings.sbCategories.value + for ((key, cat) in targets) { + val want = prefs.boolOrNull(key) ?: continue + val have = cat in current + if (want != have) settings.toggle(cat) + applied++ + } + } + + // Default resolution: NewPipe values like "720p60", "1080p", "Best + // resolution". Map down to Straw's discrete ceilings. + prefs.stringOrNull("default_resolution")?.let { raw -> + val r = parseResolution(raw) + if (r != null) { + settings.setMaxResolution(r) + applied++ + } + } + + return applied + } + + private fun parseResolution(raw: String): com.sulkta.straw.data.MaxResolution? { + val n = Regex("(\\d+)").find(raw)?.groupValues?.get(1)?.toIntOrNull() + ?: return when (raw.lowercase()) { + "best resolution", "best", "highest" -> com.sulkta.straw.data.MaxResolution.Auto + else -> null + } + return when { + n >= 1080 -> com.sulkta.straw.data.MaxResolution.P1080 + n >= 720 -> com.sulkta.straw.data.MaxResolution.P720 + n >= 480 -> com.sulkta.straw.data.MaxResolution.P480 + n >= 360 -> com.sulkta.straw.data.MaxResolution.P360 + else -> com.sulkta.straw.data.MaxResolution.P144 + } + } + + private fun openDb(dbFile: File): SQLiteDatabase = + SQLiteDatabase.openDatabase( + dbFile.absolutePath, + /* factory = */ null, + SQLiteDatabase.OPEN_READONLY, + ) + + // YouTube URL patterns we need to parse for the videoId column on + // WatchHistoryItem. Cover the watch?v= form (canonical), youtu.be + // shortlinks, and embed/. Reject anything we can't parse rather than + // inventing IDs. + private val YT_ID = Regex( + "(?:youtu\\.be/|youtube(?:-nocookie)?\\.com/(?:watch\\?(?:.*&)?v=|embed/|v/|shorts/))([A-Za-z0-9_-]{6,15})", + ) + private fun extractYtVideoId(url: String): String? = + YT_ID.find(url)?.groupValues?.get(1) + + private fun JsonObject.boolOrNull(key: String): Boolean? = + runCatching { this[key]?.jsonPrimitive?.boolean }.getOrNull() + + private fun JsonObject.stringOrNull(key: String): String? = + runCatching { this[key]?.jsonPrimitive?.contentOrNull }.getOrNull() +} diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt index f090fc99c..f3e704b0d 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt @@ -5,41 +5,66 @@ package com.sulkta.straw.feature.settings +import androidx.activity.compose.rememberLauncherForActivityResult +import androidx.activity.result.contract.ActivityResultContracts +import androidx.compose.foundation.clickable import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.Spacer import androidx.compose.foundation.layout.fillMaxSize -import androidx.compose.foundation.layout.statusBarsPadding import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.height import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.statusBarsPadding import androidx.compose.foundation.rememberScrollState import androidx.compose.foundation.verticalScroll +import androidx.compose.material3.AlertDialog +import androidx.compose.material3.Button +import androidx.compose.material3.CircularProgressIndicator import androidx.compose.material3.HorizontalDivider import androidx.compose.material3.MaterialTheme import androidx.compose.material3.OutlinedButton import androidx.compose.material3.Switch import androidx.compose.material3.Text -import androidx.compose.foundation.clickable -import androidx.compose.foundation.layout.fillMaxWidth -import androidx.compose.runtime.collectAsState +import androidx.compose.material3.TextButton import androidx.compose.runtime.Composable import androidx.compose.runtime.collectAsState import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.runtime.setValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.LocalContext import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.unit.dp import com.sulkta.straw.data.History import com.sulkta.straw.data.MaxResolution import com.sulkta.straw.data.SbCategory import com.sulkta.straw.data.Settings +import com.sulkta.straw.feature.dataimport.ImportResult +import com.sulkta.straw.feature.dataimport.SettingsImport +import kotlinx.coroutines.launch @Composable fun SettingsScreen() { val store = Settings.get() val cats by store.sbCategories.collectAsState() + val context = LocalContext.current + val scope = rememberCoroutineScope() + + var importRunning by remember { mutableStateOf(false) } + var importResult by remember { mutableStateOf?>(null) } + val pickZip = rememberLauncherForActivityResult(ActivityResultContracts.OpenDocument()) { uri -> + if (uri == null) return@rememberLauncherForActivityResult + importRunning = true + scope.launch { + importResult = SettingsImport.run(context, uri) + importRunning = false + } + } Column( modifier = Modifier @@ -124,6 +149,54 @@ fun SettingsScreen() { Text("Clear searches") } } + + Spacer(modifier = Modifier.height(32.dp)) + Text( + "Import from NewPipe / Tubular", + style = MaterialTheme.typography.titleMedium, + fontWeight = FontWeight.SemiBold, + ) + Spacer(modifier = Modifier.height(4.dp)) + Text( + "Pick a NewPipeData-*.zip or TubularData-*.zip — we'll lift " + + "your subscriptions, playlists, search history, watch history " + + "(capped to 50 most recent), and a curated subset of settings. " + + "Other services (SoundCloud, PeerTube) are skipped.", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + Spacer(modifier = Modifier.height(12.dp)) + Button( + enabled = !importRunning, + onClick = { pickZip.launch(arrayOf("application/zip", "application/octet-stream", "*/*")) }, + ) { + if (importRunning) { + CircularProgressIndicator( + modifier = Modifier.height(18.dp).padding(end = 8.dp), + strokeWidth = 2.dp, + ) + Text("Importing…") + } else { + Text("Pick export file…") + } + } + } + + importResult?.let { res -> + AlertDialog( + onDismissRequest = { importResult = null }, + title = { Text(if (res.isSuccess) "Import complete" else "Import failed") }, + text = { + val body = res.fold( + onSuccess = { it.summary() }, + onFailure = { it.message ?: it.javaClass.simpleName }, + ) + Text(body, style = MaterialTheme.typography.bodyMedium) + }, + confirmButton = { + TextButton(onClick = { importResult = null }) { Text("OK") } + }, + ) } } From 21fc81ee7730b7dacd1d6548f13e65db751f7600 Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 17:01:10 +0000 Subject: [PATCH 09/72] =?UTF-8?q?vc=3D25:=20audit-fix=20sprint=20=E2=80=94?= =?UTF-8?q?=20CRIT=20+=20HIGH=20+=20MED=20+=20LOW=20cleanup?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Opus max-effort audit of the vc=23 post-MediaController-unification codebase surfaced two CRITs, both in my own recent code. CRIT-1 + 1b: inline-position-threading band-aid deleted. After the V-2 controller unification, seeking the live controller to its own currentPosition was always 0-500ms backwards — every inline-to- fullscreen and minibar-expand handoff jerked playback backward. The whole `inlinePositionMs` / `onPositionChanged` / `startPositionMs` / `seekTo` chain is gone. The controller is one player; no handoff needed. CRIT-2: PlayerLeaveHandler removed. The registry was fully orphaned — nothing ever assigned to handler. Media3 handles HOME-to-background natively via the foreground service. Dropped the file, the onUserLeaveHint override, and the import. HIGH-1 + 5: PlayerViewModel collapsed into VideoDetailViewModel. Both fetched the same streamInfo for the same URL; PlayerScreen used to spin up two VMs to lift uploader + thumbnail from one and stream URLs from the other. One VM now exposes both `detail` and `resolved`. Drops a redundant network fetch and the double-spinner UX on PlayerScreen. HIGH-2: AndroidView { PlayerView } in PlayerScreen + InlinePlayer now has onRelease { it.player = null } so PlayerView surfaces stop retaining the controller after the composable leaves composition. HIGH-3: SubscriptionFeedViewModel switched to a per-channel cache. Each channel's entries refresh on their own TTL — adding one new subscription no longer invalidates the other 49. Failed/timed-out channel fetches leave the prior cache entry intact instead of blanking the feed for that channel. HIGH-4: onNewIntent override added. singleTask was silently dropping shared-from-Chrome YT URLs whenever Straw was already running. New intents now feed pendingDeepLink which the Compose tree drains into Screen.VideoDetail. MED-3, MED-8, MED-10, LOW batch: PlayerView control-overlay overlap fixed by going through one strategy; SearchViewModel.recordSearch moved into the success branch so errored queries don't pollute recent searches; Downloader's host whitelist tightened to *.googlevideo.com only; SubscriptionsStore.clear + HistoryStore.clearWatches/Searches now use updateAndGet for atomic clear consistent with the other writers; phase/path/audit-ticket markers stripped from comments (kept the technical commentary, dropped sprint tags); 4x duplicated Color(0xCC222222) overlay color extracted to OverlayChromeColor named constant in StrawTheme; HtmlText + StrawActivity NewPipeExtractor references replaced with the current extractor. Net: ~80 LOC deleted overall (the position-threading + handler registry + duplicate VM more than offset the cache + onNewIntent additions). --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- .../src/main/kotlin/com/sulkta/straw/Nav.kt | 14 +- .../kotlin/com/sulkta/straw/StrawActivity.kt | 167 +++++++++--------- .../kotlin/com/sulkta/straw/StrawTheme.kt | 6 + .../com/sulkta/straw/data/HistoryStore.kt | 20 +-- .../sulkta/straw/data/SubscriptionsStore.kt | 15 +- .../straw/feature/detail/VideoDetailScreen.kt | 153 +++++++--------- .../feature/detail/VideoDetailViewModel.kt | 96 ++++++++-- .../straw/feature/download/Downloader.kt | 23 +-- .../feature/feed/SubscriptionFeedViewModel.kt | 131 ++++++++------ .../feature/player/PlayerLeaveHandler.kt | 17 -- .../straw/feature/player/PlayerScreen.kt | 137 ++++++-------- .../straw/feature/player/PlayerViewModel.kt | 103 ----------- .../feature/player/StrawMediaController.kt | 1 + .../straw/feature/search/SearchViewModel.kt | 11 +- .../kotlin/com/sulkta/straw/util/HtmlText.kt | 6 +- 16 files changed, 403 insertions(+), 501 deletions(-) delete mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerLeaveHandler.kt delete mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerViewModel.kt diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index c5fbc9d7f..12e988a7a 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 24 -const val STRAW_VERSION_NAME = "0.1.0-AJ" +const val STRAW_VERSION_CODE = 25 +const val STRAW_VERSION_NAME = "0.1.0-AK" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/Nav.kt b/strawApp/src/main/kotlin/com/sulkta/straw/Nav.kt index bf91616fa..9763aa727 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/Nav.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/Nav.kt @@ -3,7 +3,7 @@ * SPDX-License-Identifier: GPL-3.0-or-later * * Tiny in-app nav model — sealed Screen + a stack. No nav library; pure - * state. Good enough for day-2's home → search → detail → player flow. + * state. */ package com.sulkta.straw @@ -19,11 +19,7 @@ sealed interface Screen { data object Playlists : Screen data object Downloads : Screen data class VideoDetail(val streamUrl: String, val title: String) : Screen - data class Player( - val streamUrl: String, - val title: String, - val startPositionMs: Long = 0L, - ) : Screen + data class Player(val streamUrl: String, val title: String) : Screen data class Channel(val channelUrl: String, val name: String) : Screen data class PlaylistView(val playlistId: String, val name: String) : Screen } @@ -36,7 +32,11 @@ class Navigator(initial: Screen) { stack.add(s) } - /** @return false if we couldn't pop (root), true otherwise. */ + /** + * Pop the current screen off the stack. Returns false at root so the + * caller can defer to the system back behavior (exit the app); true + * otherwise. + */ fun pop(): Boolean { if (stack.size <= 1) return false stack.removeAt(stack.lastIndex) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt index 7d16e4650..dea41ffea 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt @@ -19,6 +19,9 @@ import androidx.compose.material3.Surface import androidx.compose.runtime.Composable import androidx.compose.runtime.CompositionLocalProvider import androidx.compose.runtime.DisposableEffect +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.media3.common.util.UnstableApi @@ -27,7 +30,7 @@ import com.sulkta.straw.feature.detail.VideoDetailScreen import com.sulkta.straw.feature.download.DownloadsScreen import com.sulkta.straw.feature.player.LocalStrawController import com.sulkta.straw.feature.player.MinibarOverlay -import com.sulkta.straw.feature.player.PlayerLeaveHandler +import com.sulkta.straw.feature.player.NowPlaying import com.sulkta.straw.feature.player.PlayerScreen import com.sulkta.straw.feature.player.SponsorBlockSkipLoop import com.sulkta.straw.feature.player.rememberStrawController @@ -35,6 +38,7 @@ import com.sulkta.straw.feature.playlist.PlaylistViewScreen import com.sulkta.straw.feature.playlist.PlaylistsScreen import com.sulkta.straw.feature.search.SearchScreen import com.sulkta.straw.feature.settings.SettingsScreen +import kotlinx.coroutines.flow.MutableStateFlow private val YT_HOSTS = setOf( "youtube.com", "www.youtube.com", "m.youtube.com", @@ -46,6 +50,15 @@ private val YT_URL_RE = Regex( ) class StrawActivity : ComponentActivity() { + + /** + * Newly-arrived deep-link URL while the activity is already running. + * `onNewIntent` writes here; the Compose tree observes and pushes a + * VideoDetail screen. Without this the singleTask flag silently drops + * every share-to-Straw after the first. + */ + private val pendingDeepLink = MutableStateFlow(null) + @OptIn(UnstableApi::class) override fun onCreate(savedInstanceState: Bundle?) { enableEdgeToEdge() @@ -55,10 +68,9 @@ class StrawActivity : ComponentActivity() { setContent { val scheme = if (isSystemInDarkTheme()) strawDarkColors() else strawLightColors() - // Build one MediaController for the whole activity. Every screen - // pulls it via LocalStrawController, every PlayerView binds to - // it, and the minibar overlay (rendered below) uses it too. - // Single player, single source of truth. + // One MediaController for the whole activity. Every screen pulls + // it via LocalStrawController; the minibar overlay below uses it + // too. Single player, single source of truth. val controller = rememberStrawController() MaterialTheme(colorScheme = scheme) { CompositionLocalProvider(LocalStrawController provides controller) { @@ -80,6 +92,15 @@ class StrawActivity : ComponentActivity() { onDispose { cb.remove() } } + // Drain newly-arrived deep links. Consumed (cleared) once + // pushed so we don't re-navigate on every recomposition. + val pending by pendingDeepLink.collectAsState() + LaunchedEffect(pending) { + val url = pending ?: return@LaunchedEffect + nav.push(Screen.VideoDetail(url, "")) + pendingDeepLink.value = null + } + // SponsorBlock skip loop runs at the activity level so it // applies whether the user is fullscreen, in the minibar, // or away from the player surface. @@ -87,21 +108,13 @@ class StrawActivity : ComponentActivity() { Box(modifier = Modifier.fillMaxSize()) { ScreenContent(nav, s = nav.current) - // Persistent minibar overlay — visible on every screen - // except Player itself (fullscreen has its own UI). + // Persistent minibar — visible on every non-Player + // screen whenever something is loaded. if (nav.current !is Screen.Player) { MinibarOverlay( onExpand = { - val item = com.sulkta.straw.feature.player.NowPlaying.current.value - if (item != null) { - nav.push( - Screen.Player( - item.streamUrl, - item.title, - controller?.currentPosition ?: 0L, - ) - ) - } + val item = NowPlaying.current.value ?: return@MinibarOverlay + nav.push(Screen.Player(item.streamUrl, item.title)) }, modifier = Modifier.align(Alignment.BottomCenter), ) @@ -113,97 +126,79 @@ class StrawActivity : ComponentActivity() { } } + /** + * `launchMode="singleTask"` means a fresh VIEW/SEND from Chrome lands + * on the already-running activity instead of creating a new instance. + * Forward the URL into the Compose tree via the pending-link flow. + */ + override fun onNewIntent(intent: Intent) { + super.onNewIntent(intent) + setIntent(intent) + pickYouTubeUrl(intent)?.let { pendingDeepLink.value = it } + } + @Composable private fun ScreenContent(nav: Navigator, s: Screen) { when (s) { - is Screen.Home -> StrawHome( - onOpenSearch = { nav.push(Screen.Search) }, - onOpenSettings = { nav.push(Screen.Settings) }, - onOpenPlaylists = { nav.push(Screen.Playlists) }, - onOpenDownloads = { nav.push(Screen.Downloads) }, - onOpenVideo = { url, title -> - nav.push(Screen.VideoDetail(url, title)) - }, - onOpenChannel = { url, name -> - nav.push(Screen.Channel(url, name)) - }, - ) - is Screen.Downloads -> DownloadsScreen() - is Screen.Settings -> SettingsScreen() - is Screen.Search -> SearchScreen( - onOpenVideo = { url, title -> - nav.push(Screen.VideoDetail(url, title)) - }, - ) - is Screen.VideoDetail -> VideoDetailScreen( - streamUrl = s.streamUrl, - initialTitle = s.title, - onPlay = { startPositionMs -> - nav.push(Screen.Player(s.streamUrl, s.title, startPositionMs)) - }, - onOpenChannel = { url, name -> - nav.push(Screen.Channel(url, name)) - }, - onOpenVideo = { url, title -> - nav.push(Screen.VideoDetail(url, title)) - }, - ) - is Screen.Channel -> ChannelScreen( - channelUrl = s.channelUrl, - initialName = s.name, - onOpenVideo = { url, title -> - nav.push(Screen.VideoDetail(url, title)) - }, - ) - is Screen.Player -> PlayerScreen( - streamUrl = s.streamUrl, - title = s.title, - startPositionMs = s.startPositionMs, - onMinimize = { nav.pop() }, - ) - is Screen.Playlists -> PlaylistsScreen( - onOpenPlaylist = { id, name -> - nav.push(Screen.PlaylistView(id, name)) - }, - ) + is Screen.Home -> StrawHome( + onOpenSearch = { nav.push(Screen.Search) }, + onOpenSettings = { nav.push(Screen.Settings) }, + onOpenPlaylists = { nav.push(Screen.Playlists) }, + onOpenDownloads = { nav.push(Screen.Downloads) }, + onOpenVideo = { url, title -> nav.push(Screen.VideoDetail(url, title)) }, + onOpenChannel = { url, name -> nav.push(Screen.Channel(url, name)) }, + ) + is Screen.Downloads -> DownloadsScreen() + is Screen.Settings -> SettingsScreen() + is Screen.Search -> SearchScreen( + onOpenVideo = { url, title -> nav.push(Screen.VideoDetail(url, title)) }, + ) + is Screen.VideoDetail -> VideoDetailScreen( + streamUrl = s.streamUrl, + initialTitle = s.title, + onPlay = { nav.push(Screen.Player(s.streamUrl, s.title)) }, + onOpenChannel = { url, name -> nav.push(Screen.Channel(url, name)) }, + onOpenVideo = { url, title -> nav.push(Screen.VideoDetail(url, title)) }, + ) + is Screen.Channel -> ChannelScreen( + channelUrl = s.channelUrl, + initialName = s.name, + onOpenVideo = { url, title -> nav.push(Screen.VideoDetail(url, title)) }, + ) + is Screen.Player -> PlayerScreen( + streamUrl = s.streamUrl, + title = s.title, + onMinimize = { nav.pop() }, + ) + is Screen.Playlists -> PlaylistsScreen( + onOpenPlaylist = { id, name -> nav.push(Screen.PlaylistView(id, name)) }, + ) is Screen.PlaylistView -> PlaylistViewScreen( playlistId = s.playlistId, initialName = s.name, - onOpenVideo = { url, title -> - nav.push(Screen.VideoDetail(url, title)) - }, + onOpenVideo = { url, title -> nav.push(Screen.VideoDetail(url, title)) }, ) } } - /** - * HOME / recents → seamless hand-off to background audio when the - * player screen is active. PlayerScreen registers the handler; any - * other screen leaves it null and home behaves normally. - */ - override fun onUserLeaveHint() { - super.onUserLeaveHint() - PlayerLeaveHandler.handler?.invoke() - } - - /** Pull a YouTube URL out of an incoming Intent (VIEW or SEND). */ + /** Pull a YouTube URL out of an incoming VIEW or SEND intent. */ private fun pickYouTubeUrl(intent: Intent?): String? { intent ?: return null return when (intent.action) { Intent.ACTION_VIEW -> { val data = intent.data?.toString() ?: return null // Explicit scheme + host check — defense in depth vs the - // manifest intent-filter (apps can synth intents that - // bypass filter scheme matching when activity is exported). + // manifest intent-filter; apps can synth intents that + // bypass filter scheme matching on exported activities. if (intent.scheme?.lowercase() !in setOf("https", "http")) return null if (!looksLikeYouTube(data)) return null data } Intent.ACTION_SEND -> { val shared = intent.getStringExtra(Intent.EXTRA_TEXT) ?: return null - // Regex extracts a YT-looking substring from arbitrary - // attacker-controlled text. Re-validate via URI parse + host - // check before we hand it to NewPipeExtractor. + // Extract a YT-looking substring from attacker-controlled + // text, then re-validate via URI parse + host check before + // handing it to the extractor. val candidate = YT_URL_RE.find(shared)?.value ?: return null val truncated = candidate.substringBefore('#').trim() if (!looksLikeYouTube(truncated)) return null diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawTheme.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawTheme.kt index 74ad7be59..c3ee116ec 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawTheme.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawTheme.kt @@ -62,3 +62,9 @@ fun strawDarkColors(): ColorScheme = darkColorScheme( tertiary = DarkGreenTertiary, onTertiary = DarkGreenOnTertiary, ) + +// Semi-transparent overlays for chrome (overlay buttons, the SB badge, +// the inline-player fullscreen pill) and for the dimmed area behind the +// minibar thumbnail. Kept here so a theme tweak touches one place. +val OverlayChromeColor = androidx.compose.ui.graphics.Color(0xCC222222) +val OverlayDimColor = androidx.compose.ui.graphics.Color(0xCC000000) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt index 8ed488e48..cc04a788c 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt @@ -2,9 +2,9 @@ * SPDX-FileCopyrightText: 2026 Sulkta-Coop * SPDX-License-Identifier: GPL-3.0-or-later * - * SharedPreferences-backed recent watches + recent search store. Day-3. - * Day-4 graduates to Room when there's a real query pattern (date ranges, - * full-text search, etc.) that SharedPreferences can't serve. + * Recent watches + recent searches backed by SharedPreferences JSON + * blobs. Capped to MAX_WATCHES / MAX_SEARCHES. Graduates to Room when + * a real query pattern (date ranges, full-text search) shows up. */ package com.sulkta.straw.data @@ -46,9 +46,9 @@ class HistoryStore(context: Context) { fun recordWatch(item: WatchHistoryItem) { val now = item.copy(watchedAt = System.currentTimeMillis()) - // Atomic read-modify-write via StateFlow.updateAndGet — fixes - // AUD-HIGH race where two concurrent recordWatch calls would - // each read the old list and one would clobber the other. + // Atomic read-modify-write — two concurrent recordWatch calls + // both reading the same `current` and one clobbering the other + // is exactly the bug updateAndGet avoids. val next = _watches.updateAndGet { current -> val without = current.filterNot { it.videoId == item.videoId } (listOf(now) + without).take(MAX_WATCHES) @@ -67,13 +67,13 @@ class HistoryStore(context: Context) { } fun clearWatches() { - _watches.value = emptyList() - sp.edit().remove(KEY_WATCHES).apply() + _watches.updateAndGet { emptyList() } + sp.edit().putString(KEY_WATCHES, json.encodeToString(emptyList())).apply() } fun clearSearches() { - _searches.value = emptyList() - sp.edit().remove(KEY_SEARCHES).apply() + _searches.updateAndGet { emptyList() } + sp.edit().putString(KEY_SEARCHES, json.encodeToString(emptyList())).apply() } private fun loadWatches(): List = runCatching { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt index 3a9fc8162..b90d9b406 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt @@ -2,8 +2,8 @@ * SPDX-FileCopyrightText: 2026 Sulkta-Coop * SPDX-License-Identifier: GPL-3.0-or-later * - * SharedPreferences-lite subscription list. Day-4 graduates to Room when - * we want background feed fetching for new uploads. + * Subscription list backed by a single JSON blob in SharedPreferences. + * Graduates to Room when background feed fetching arrives. */ package com.sulkta.straw.data @@ -38,7 +38,9 @@ class SubscriptionsStore(context: Context) { _subs.value.any { it.url == channelUrl } fun toggle(ref: ChannelRef) { - // Atomic toggle via updateAndGet — see AUD-HIGH note in HistoryStore. + // updateAndGet makes the read-modify-write atomic vs. concurrent + // toggles (e.g. one channel subscribed from the feed while another + // is unsubscribed from VideoDetail). val next = _subs.updateAndGet { cur -> if (cur.any { it.url == ref.url }) { cur.filterNot { it.url == ref.url } @@ -50,8 +52,11 @@ class SubscriptionsStore(context: Context) { } fun clear() { - _subs.value = emptyList() - sp.edit().remove(KEY).apply() + // Same atomic-update path as toggle — protects against a concurrent + // toggle racing the clear and persisting [new-item] after the + // remove() call has fired. + _subs.updateAndGet { emptyList() } + persist(emptyList()) } private fun persist(list: List) { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index cc33676fe..499f232b1 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -5,6 +5,9 @@ package com.sulkta.straw.feature.detail +import android.content.Intent +import android.widget.Toast +import androidx.annotation.OptIn import androidx.compose.foundation.background import androidx.compose.foundation.clickable import androidx.compose.foundation.layout.Arrangement @@ -23,8 +26,12 @@ import androidx.compose.foundation.layout.size import androidx.compose.foundation.layout.statusBarsPadding import androidx.compose.foundation.layout.width import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.shape.CircleShape import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.foundation.verticalScroll +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.PlayArrow +import androidx.compose.material3.AlertDialog import androidx.compose.material3.AssistChip import androidx.compose.material3.AssistChipDefaults import androidx.compose.material3.Button @@ -35,44 +42,40 @@ import androidx.compose.material3.MaterialTheme import androidx.compose.material3.OutlinedButton import androidx.compose.material3.OutlinedTextField import androidx.compose.material3.Text -import android.content.Intent -import android.widget.Toast -import androidx.annotation.OptIn -import androidx.compose.material3.AlertDialog +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable import androidx.compose.runtime.DisposableEffect +import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.collectAsState -import androidx.compose.runtime.mutableLongStateOf +import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember import androidx.compose.runtime.setValue -import com.sulkta.straw.data.PlaylistItem -import com.sulkta.straw.data.Playlists -import kotlinx.coroutines.delay -import androidx.compose.ui.platform.LocalContext -import androidx.compose.ui.viewinterop.AndroidView -import com.sulkta.straw.feature.download.DownloadKind -import com.sulkta.straw.feature.download.Downloader -import com.sulkta.straw.feature.player.PlayerViewModel -import androidx.compose.material.icons.Icons -import androidx.compose.material.icons.filled.PlayArrow -import androidx.compose.runtime.Composable -import androidx.compose.runtime.LaunchedEffect -import androidx.compose.runtime.getValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.draw.clip import androidx.compose.ui.graphics.Color +import androidx.compose.ui.platform.LocalContext import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.TextOverflow import androidx.compose.ui.unit.dp +import androidx.compose.ui.viewinterop.AndroidView import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.lifecycle.viewmodel.compose.viewModel import androidx.media3.common.Player import androidx.media3.common.util.UnstableApi import androidx.media3.ui.PlayerView import coil3.compose.AsyncImage +import com.sulkta.straw.OverlayChromeColor +import com.sulkta.straw.OverlayDimColor +import com.sulkta.straw.data.PlaylistItem +import com.sulkta.straw.data.Playlists +import com.sulkta.straw.feature.download.DownloadKind +import com.sulkta.straw.feature.download.Downloader import com.sulkta.straw.feature.player.LocalStrawController import com.sulkta.straw.feature.player.NowPlaying import com.sulkta.straw.feature.player.setPlayingFrom +import com.sulkta.straw.feature.search.StreamItem import com.sulkta.straw.util.formatCount import com.sulkta.straw.util.formatViews import com.sulkta.straw.util.stripHtml @@ -82,7 +85,7 @@ import com.sulkta.straw.util.stripHtml fun VideoDetailScreen( streamUrl: String, initialTitle: String, - onPlay: (startPositionMs: Long) -> Unit, + onPlay: () -> Unit, onOpenChannel: (channelUrl: String, name: String) -> Unit, onOpenVideo: (url: String, title: String) -> Unit, vm: VideoDetailViewModel = viewModel(), @@ -91,13 +94,8 @@ fun VideoDetailScreen( val context = LocalContext.current var showDownloadDialog by remember { mutableStateOf(false) } var showSaveToPlaylistDialog by remember { mutableStateOf(false) } - // Inline-play state. Resets when the user navigates to a different - // video (keyed on streamUrl). + // Inline-play state resets when navigating to a different video. var inlinePlaying by remember(streamUrl) { mutableStateOf(false) } - // V-2: inline player's current position, polled into here so the - // outer can pass it through when the user taps Play / ⛶. Resets to 0 - // when the inline player isn't active. - var inlinePositionMs by remember(streamUrl) { mutableLongStateOf(0L) } LaunchedEffect(streamUrl) { vm.load(streamUrl) } Column( @@ -120,17 +118,13 @@ fun VideoDetailScreen( else -> { val d = state.detail ?: return@Column - // Tap the thumbnail to play inline. Fullscreen button (top-right - // overlay on the inline player) jumps to the fullscreen Player - // screen which has the full toolset. if (inlinePlaying) { InlinePlayer( streamUrl = streamUrl, title = d.title, uploader = d.uploader, thumbnail = d.thumbnail, - onFullscreen = { onPlay(inlinePositionMs) }, - onPositionChanged = { inlinePositionMs = it }, + onFullscreen = onPlay, modifier = Modifier .fillMaxWidth() .aspectRatio(16f / 9f) @@ -154,8 +148,8 @@ fun VideoDetailScreen( Box( modifier = Modifier .size(64.dp) - .clip(androidx.compose.foundation.shape.CircleShape) - .background(Color(0xCC000000)), + .clip(CircleShape) + .background(OverlayDimColor), contentAlignment = Alignment.Center, ) { Icon( @@ -169,25 +163,24 @@ fun VideoDetailScreen( } Spacer(modifier = Modifier.height(12.dp)) - // ── Title + uploader ───────────────────────────────────── Text( text = d.title, style = MaterialTheme.typography.titleLarge, fontWeight = FontWeight.SemiBold, ) Spacer(modifier = Modifier.height(4.dp)) - val uploaderClickable = d.uploaderUrl != null + val uploaderUrl = d.uploaderUrl Text( text = d.uploader, style = MaterialTheme.typography.bodyMedium, - color = if (uploaderClickable) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.onSurfaceVariant, - modifier = if (uploaderClickable) Modifier.clickable { - onOpenChannel(d.uploaderUrl!!, d.uploader) + color = if (uploaderUrl != null) MaterialTheme.colorScheme.primary + else MaterialTheme.colorScheme.onSurfaceVariant, + modifier = if (uploaderUrl != null) Modifier.clickable { + onOpenChannel(uploaderUrl, d.uploader) } else Modifier, ) Spacer(modifier = Modifier.height(12.dp)) - // ── Engagement row: views + RYD likes/dislikes ─────────── Row( horizontalArrangement = Arrangement.spacedBy(8.dp), verticalAlignment = Alignment.CenterVertically, @@ -225,7 +218,7 @@ fun VideoDetailScreen( horizontalArrangement = Arrangement.spacedBy(12.dp), verticalArrangement = Arrangement.spacedBy(8.dp), ) { - Button(onClick = { onPlay(inlinePositionMs) }) { Text("Play") } + Button(onClick = onPlay) { Text("Play") } OutlinedButton(onClick = { val send = Intent(Intent.ACTION_SEND).apply { type = "text/plain" @@ -243,17 +236,15 @@ fun VideoDetailScreen( } Spacer(modifier = Modifier.height(20.dp)) - // ── Description ────────────────────────────────────────── Text("Description", style = MaterialTheme.typography.titleSmall, fontWeight = FontWeight.SemiBold) Spacer(modifier = Modifier.height(8.dp)) - // AUD-MED: cap input length before regex passes — defends - // against ANR on multi-MB descriptions. + // Cap input length before regex passes — defends against + // ANR on multi-MB descriptions. Text( text = stripHtml(d.description.take(20_000)).take(2000), style = MaterialTheme.typography.bodySmall, ) - // ── Recommended ────────────────────────────────────────── if (d.related.isNotEmpty()) { Spacer(modifier = Modifier.height(24.dp)) Text( @@ -264,11 +255,10 @@ fun VideoDetailScreen( Spacer(modifier = Modifier.height(8.dp)) d.related.take(20).forEach { rel -> RelatedRow(rel) { onOpenVideo(rel.url, rel.title) } - androidx.compose.material3.HorizontalDivider() + HorizontalDivider() } } - // ── More from ───────────────────────────────── if (d.moreFromChannel.isNotEmpty()) { Spacer(modifier = Modifier.height(24.dp)) Text( @@ -280,7 +270,7 @@ fun VideoDetailScreen( Spacer(modifier = Modifier.height(8.dp)) d.moreFromChannel.take(20).forEach { item -> RelatedRow(item) { onOpenVideo(item.url, item.title) } - androidx.compose.material3.HorizontalDivider() + HorizontalDivider() } } @@ -315,7 +305,6 @@ fun VideoDetailScreen( confirmButton = { Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) { Button(onClick = { - // info is now uniffi.strawcore.StreamInfo (Path C-4). val audio = info?.audioOnly?.maxByOrNull { it.bitrate }?.url if (audio != null) { val id = Downloader.enqueue(context, audio, d.title, DownloadKind.Audio) @@ -341,13 +330,12 @@ fun VideoDetailScreen( } }, dismissButton = { - androidx.compose.material3.TextButton(onClick = { showDownloadDialog = false }) { + TextButton(onClick = { showDownloadDialog = false }) { Text("Cancel") } }, ) } - } } } @@ -355,7 +343,7 @@ fun VideoDetailScreen( @Composable private fun RelatedRow( - item: com.sulkta.straw.feature.search.StreamItem, + item: StreamItem, onClick: () -> Unit, ) { Row( @@ -380,7 +368,7 @@ private fun RelatedRow( style = MaterialTheme.typography.bodyMedium, fontWeight = FontWeight.SemiBold, maxLines = 2, - overflow = androidx.compose.ui.text.style.TextOverflow.Ellipsis, + overflow = TextOverflow.Ellipsis, ) Spacer(modifier = Modifier.height(2.dp)) Text( @@ -394,7 +382,7 @@ private fun RelatedRow( style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant, maxLines = 1, - overflow = androidx.compose.ui.text.style.TextOverflow.Ellipsis, + overflow = TextOverflow.Ellipsis, ) } } @@ -479,18 +467,18 @@ private fun SaveToPlaylistDialog( } }, confirmButton = { - androidx.compose.material3.TextButton(onClick = onDismiss) { Text("Close") } + TextButton(onClick = onDismiss) { Text("Close") } }, ) } /** - * Inline player embedded in the 16:9 thumbnail box on VideoDetailScreen. - * Uses its own ExoPlayer + PlayerView (with the built-in controller for - * play/pause/seek). A small fullscreen pill in the top-right hops the user - * to the fullscreen PlayerScreen for the full toolset (speed picker, audio- - * only, share, PiP, background). Player is released when the composable - * leaves composition (navigate back or away from VideoDetail). + * Inline player surface inside VideoDetail's 16:9 thumbnail box. Renders + * a PlayerView bound to the shared LocalStrawController — the same + * player as the fullscreen PlayerScreen and the minibar overlay. The ⛶ + * pill hops to fullscreen; playback continues unchanged. There is + * nothing to release here: the controller is process-wide, and the + * PlayerView's surface is detached on dispose via onRelease. */ @OptIn(UnstableApi::class) @Composable @@ -500,42 +488,27 @@ private fun InlinePlayer( uploader: String, thumbnail: String?, onFullscreen: () -> Unit, - onPositionChanged: (Long) -> Unit, modifier: Modifier = Modifier, ) { val controller = LocalStrawController.current - val playerVm: PlayerViewModel = viewModel() - val state by playerVm.ui.collectAsStateWithLifecycle() - LaunchedEffect(streamUrl) { playerVm.resolve(streamUrl) } + val vm: VideoDetailViewModel = viewModel() + val state by vm.ui.collectAsStateWithLifecycle() - // As soon as we have a resolved stream AND the active video isn't - // already this URL, push it into the shared controller. The controller - // is the same one driving the fullscreen Player + the minibar overlay, - // so playback survives any nav transition unchanged. + // Push the resolved stream into the shared controller if it isn't + // already playing this URL. We don't kick off a new fetch — the + // outer VideoDetailScreen already called vm.load(streamUrl). val resolved = state.resolved LaunchedEffect(controller, resolved, streamUrl) { val c = controller ?: return@LaunchedEffect val r = resolved ?: return@LaunchedEffect - val activeUrl = NowPlaying.current.value?.streamUrl - if (activeUrl != streamUrl) { - c.setPlayingFrom( - streamUrl = streamUrl, - title = title, - uploader = uploader, - thumbnail = thumbnail, - resolved = r, - ) - } - } - - // Report position to the parent on every tick so a Play / ⛶ tap picks - // up at the right spot if the active video is somehow desynced. - LaunchedEffect(controller) { - val c = controller ?: return@LaunchedEffect - while (true) { - onPositionChanged(c.currentPosition.coerceAtLeast(0L)) - delay(500) - } + if (NowPlaying.current.value?.streamUrl == streamUrl) return@LaunchedEffect + c.setPlayingFrom( + streamUrl = streamUrl, + title = title, + uploader = uploader, + thumbnail = thumbnail, + resolved = r, + ) } var playbackError by remember { mutableStateOf(null) } @@ -577,17 +550,16 @@ private fun InlinePlayer( } }, update = { it.player = controller }, + onRelease = { it.player = null }, modifier = Modifier.fillMaxSize(), ) - // Top-right fullscreen pill — hops to the fullscreen - // PlayerScreen which has speed/audio-only/share/PiP/background. Box( modifier = Modifier .align(Alignment.TopEnd) .padding(8.dp) .size(36.dp) .clip(RoundedCornerShape(6.dp)) - .background(Color(0xCC222222)) + .background(OverlayChromeColor) .clickable(onClick = onFullscreen), contentAlignment = Alignment.Center, ) { @@ -597,4 +569,3 @@ private fun InlinePlayer( } } } - diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt index 63dea79c3..476615c25 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt @@ -2,11 +2,16 @@ * SPDX-FileCopyrightText: 2026 Sulkta-Coop * SPDX-License-Identifier: GPL-3.0-or-later * - * Phase U-3 / Path C-4: streamInfo() moves from NewPipeExtractor (Java) to - * strawcore (Rust + rustypipe via UniFFI). Channel fetch for - * `moreFromChannel` stays on NPE until C-5. + * One VM per video URL — drives VideoDetail, the fullscreen Player, and + * the inline player on detail (all live in the same activity-scoped VM + * store, so `viewModel()` from each composable returns this instance). + * + * `load(url)` fetches strawcore.streamInfo once, derives both `detail` + * (title, uploader, view count, RYD, related, more-from-channel) and + * `resolved` (the picked stream URLs the player needs), and records the + * video to watch history. Subsequent `load(url)` calls for the same URL + * are a no-op so the spinner only fires on a real navigation change. */ - package com.sulkta.straw.feature.detail import androidx.lifecycle.ViewModel @@ -16,7 +21,9 @@ import com.sulkta.straw.data.Settings import com.sulkta.straw.data.WatchHistoryItem import com.sulkta.straw.net.RydClient import com.sulkta.straw.net.RydVotes +import com.sulkta.straw.net.SbSegment import com.sulkta.straw.net.SponsorBlockClient +import com.sulkta.straw.feature.search.StreamItem import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow @@ -34,17 +41,41 @@ data class VideoDetail( val thumbnail: String?, val ryd: RydVotes? = null, val sbSegmentCount: Int = 0, - val related: List = emptyList(), - /** Other videos from the same channel — separate from related (which is YT's - * algo). Anchored to the uploader the user chose; matches the sub-feed ethos. */ - val moreFromChannel: List = emptyList(), + val related: List = emptyList(), + /** + * Other videos from the same channel — separate from `related` + * (which is YT's algo). Anchored to the uploader the user chose; + * matches the sub-feed ethos. + */ + val moreFromChannel: List = emptyList(), ) +/** + * Stream URLs picked from `streamInfo` for the player. The picker prefers + * DASH (whole-quality + adaptive) → HLS → combined progressive → merged + * video+audio progressive → video-only. Carries SB segments for the + * activity-level skip loop. + */ +data class ResolvedPlayback( + val title: String, + val videoUrl: String?, + val audioUrl: String?, + val combinedUrl: String?, + val dashMpdUrl: String?, + val hlsUrl: String?, + val segments: List = emptyList(), +) { + val isPlayable: Boolean + get() = !combinedUrl.isNullOrBlank() || !videoUrl.isNullOrBlank() || + !dashMpdUrl.isNullOrBlank() || !hlsUrl.isNullOrBlank() +} + data class VideoDetailUiState( val loading: Boolean = true, val detail: VideoDetail? = null, + val resolved: ResolvedPlayback? = null, val error: String? = null, - // Stored on success for handoff to the player + Download dialog. Not in UI. + /** Raw extractor result — kept around for the Download dialog. */ val streamInfo: uniffi.strawcore.StreamInfo? = null, ) @@ -55,8 +86,9 @@ class VideoDetailViewModel : ViewModel() { private var loadedUrl: String? = null fun load(streamUrl: String) { - // viewModel() is Activity-scoped, so the same VM is reused across - // navigations. Compare the requested URL with what we last loaded. + // viewModel() is activity-scoped, so the same VM is reused across + // navigations. Skip the refetch if the requested URL already has + // a resolved state. if (loadedUrl == streamUrl && _ui.value.detail != null) return loadedUrl = streamUrl _ui.value = VideoDetailUiState(loading = true) @@ -86,14 +118,13 @@ class VideoDetailViewModel : ViewModel() { runCatching { RydClient.fetch(videoId) }.getOrNull() } val sbCats = Settings.get().sbCategories.value.map { it.key } - val sbCount = if (sbCats.isEmpty()) 0 else withContext(Dispatchers.IO) { - runCatching { SponsorBlockClient.fetch(videoId, sbCats).size }.getOrDefault(0) + val segments = if (sbCats.isEmpty()) emptyList() else withContext(Dispatchers.IO) { + runCatching { SponsorBlockClient.fetch(videoId, sbCats) } + .getOrDefault(emptyList()) } - // strawcore returns `related` as List. Map to the - // Kotlin StreamItem shape used elsewhere. val related = info.related.map { r -> - com.sulkta.straw.feature.search.StreamItem( + StreamItem( url = r.url, title = r.title.ifBlank { "(no title)" }, uploader = r.uploader, @@ -107,7 +138,7 @@ class VideoDetailViewModel : ViewModel() { // More from this channel via strawcore.channelInfo — one // Rust round-trip returns the channel's Videos tab pre-mapped. val uploaderUrl = info.uploaderUrl - val moreFromChannel: List = + val moreFromChannel: List = if (uploaderUrl.isNullOrBlank()) emptyList() else runCatching { val ch = uniffi.strawcore.channelInfo(uploaderUrl) @@ -115,7 +146,7 @@ class VideoDetailViewModel : ViewModel() { .filter { it.url != streamUrl } .take(20) .map { v -> - com.sulkta.straw.feature.search.StreamItem( + StreamItem( url = v.url, title = v.title.ifBlank { "(no title)" }, uploader = v.uploader.ifBlank { uploader }, @@ -127,6 +158,8 @@ class VideoDetailViewModel : ViewModel() { } }.getOrDefault(emptyList()) + val resolved = resolvePlayback(info, segments) + _ui.value = VideoDetailUiState( loading = false, detail = VideoDetail( @@ -138,10 +171,11 @@ class VideoDetailViewModel : ViewModel() { description = info.description, thumbnail = thumb, ryd = ryd, - sbSegmentCount = sbCount, + sbSegmentCount = segments.size, related = related, moreFromChannel = moreFromChannel, ), + resolved = resolved, streamInfo = info, ) } catch (t: Throwable) { @@ -152,4 +186,28 @@ class VideoDetailViewModel : ViewModel() { } } } + + private fun resolvePlayback( + info: uniffi.strawcore.StreamInfo, + segments: List, + ): ResolvedPlayback { + val maxRes = Settings.get().maxResolution.value.ceiling + // Filter by max-resolution ceiling but fall back to the lowest + // available if the ceiling excludes everything (e.g. a 360p-only + // upload with the user on a 480p cap). + fun pickVideo(streams: List): String? { + if (streams.isEmpty()) return null + val pool = streams.filter { it.height <= maxRes }.ifEmpty { streams } + return pool.maxByOrNull { it.bitrate }?.url + } + return ResolvedPlayback( + title = info.title, + videoUrl = pickVideo(info.videoOnly), + audioUrl = info.audioOnly.maxByOrNull { it.bitrate }?.url, + combinedUrl = pickVideo(info.combined), + dashMpdUrl = info.dashMpdUrl?.takeIf { it.isNotBlank() }, + hlsUrl = info.hlsUrl?.takeIf { it.isNotBlank() }, + segments = segments, + ) + } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/Downloader.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/Downloader.kt index 4bb361506..bdb7dcce3 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/Downloader.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/Downloader.kt @@ -2,18 +2,18 @@ * SPDX-FileCopyrightText: 2026 Sulkta-Coop * SPDX-License-Identifier: GPL-3.0-or-later * - * Phase R: minimal download via Android's DownloadManager. Saves to the + * Minimal download via Android's DownloadManager. Saves to the * app-private external files dir so we don't need WRITE_EXTERNAL_STORAGE * on older Android. The user can pull files out via a file manager * (under Android/data/com.sulkta.straw.debug/files/...). * - * Audit fixes (2026-05-24 pass #2): - * HIGH-4: scheme + host validation on the URL before handing it to - * DownloadManager — extractor output is not trusted root-of-truth. - * HIGH-5: harder filename sanitization — control chars, bidi overrides, - * leading dots, trailing whitespace. - * MED-6: catch IllegalArgumentException from enqueue so a malformed URI - * doesn't crash the click handler. + * Hardening: + * - scheme + host validation on the URL before enqueueing (extractor + * output is not trusted root-of-truth) + * - filename sanitization for control chars, bidi overrides, leading + * dots, and trailing whitespace + * - catches IllegalArgumentException from enqueue so a malformed URI + * doesn't crash the click handler */ package com.sulkta.straw.feature.download @@ -88,8 +88,9 @@ object Downloader { val uri = runCatching { Uri.parse(url) }.getOrNull() ?: return false if (!uri.scheme.equals("https", ignoreCase = true)) return false val host = uri.host?.lowercase() ?: return false - return host.endsWith(".googlevideo.com") || - host.endsWith(".youtube.com") || - host == "youtube.com" + // strawcore returns video/audio stream URLs from googlevideo CDN + // exclusively — youtube.com URLs aren't direct streams and have + // no business going to DownloadManager. + return host.endsWith(".googlevideo.com") } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt index d7f27b11c..f69be037f 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt @@ -2,26 +2,26 @@ * SPDX-FileCopyrightText: 2026 Sulkta-Coop * SPDX-License-Identifier: GPL-3.0-or-later * - * Phase Q: aggregate latest videos across all subscribed channels into a - * single feed. Fans out per-channel channelInfo() fetches in parallel, - * merges by view count desc, caps at 200 items. + * Aggregate latest videos across all subscribed channels into a single + * feed. Fans out per-channel channelInfo() fetches in parallel, caches + * each channel's videos independently, merges by view-count desc, caps + * at 200 items. * - * Path C-5: each per-channel fetch is now ONE strawcore.channelInfo() - * call instead of two NewPipeExtractor round-trips (ChannelInfo.getInfo + - * ChannelTabInfo.getInfo). Halves the network work for the feed. + * Each per-channel cache entry has its own TTL so adding one new + * subscription doesn't invalidate the other 49 — only the new one + * actually goes to the network on the next refresh. * - * Audit fixes (2026-05-24 pass #2): - * HIGH-6: cancel any prior in-flight refresh when a new one starts, cap - * concurrency with a Semaphore, time-bound each per-channel fetch so - * one hung channel can't stall the whole feed. - * MED-7: use `update { }` for atomic UI-state writes (matches the - * convention applied to the data stores in audit pass #1). + * Concurrency hardening: cancel any in-flight refresh when a new one + * starts, cap parallelism with a Semaphore so 100+ subs don't slam YT, + * time-bound each per-channel fetch so one hung channel can't stall the + * whole batch. */ package com.sulkta.straw.feature.feed import androidx.lifecycle.ViewModel import androidx.lifecycle.viewModelScope +import com.sulkta.straw.data.ChannelRef import com.sulkta.straw.data.Subscriptions import com.sulkta.straw.feature.search.StreamItem import com.sulkta.straw.util.strawLogW @@ -37,6 +37,7 @@ import kotlinx.coroutines.launch import kotlinx.coroutines.sync.Semaphore import kotlinx.coroutines.sync.withPermit import kotlinx.coroutines.withTimeoutOrNull +import java.util.concurrent.ConcurrentHashMap data class SubscriptionFeedUiState( val loading: Boolean = false, @@ -49,10 +50,14 @@ class SubscriptionFeedViewModel : ViewModel() { private val _ui = MutableStateFlow(SubscriptionFeedUiState()) val ui: StateFlow = _ui.asStateFlow() - /** Cache feed for 10 min to avoid hammering YT on tab re-entry. */ - private val cacheTtlMs = 10L * 60 * 1000 + /** Per-channel cache: each entry refreshes independently. */ + private data class ChannelCacheEntry(val fetchedAt: Long, val items: List) + private val channelCache = ConcurrentHashMap() - /** Per-channel fetch timeout — slowest channel can't stall the whole batch. */ + /** Per-channel TTL — Refresh just re-fetches stale entries. */ + private val perChannelTtlMs = 10L * 60 * 1000 + + /** Per-channel fetch timeout — slowest channel can't stall the batch. */ private val perChannelTimeoutMs = 15_000L /** Cap parallel network fetches even with 100+ subs. */ @@ -63,64 +68,39 @@ class SubscriptionFeedViewModel : ViewModel() { fun refreshIfStale() { val now = System.currentTimeMillis() - if (_ui.value.items.isNotEmpty() && now - _ui.value.lastFetchedAt < cacheTtlMs) return - refresh() + val anyStale = Subscriptions.get().subs.value.any { ch -> + val entry = channelCache[ch.url] + entry == null || now - entry.fetchedAt >= perChannelTtlMs + } + if (anyStale || _ui.value.items.isEmpty()) refresh() } fun refresh() { val channels = Subscriptions.get().subs.value if (channels.isEmpty()) { _ui.update { SubscriptionFeedUiState(loading = false, items = emptyList()) } + channelCache.clear() return } inFlight?.cancel() _ui.update { it.copy(loading = true, error = null) } inFlight = viewModelScope.launch { try { - val perChannelMax = 5 val gate = Semaphore(parallelism) - val items = coroutineScope { - val deferreds = channels.map { ch -> - async { - gate.withPermit { - withTimeoutOrNull(perChannelTimeoutMs) { - runCatching { - val info = uniffi.strawcore.channelInfo(ch.url) - info.videos - .take(perChannelMax) - .map { v -> - StreamItem( - url = v.url, - title = v.title.ifBlank { "(no title)" }, - uploader = v.uploader.ifBlank { ch.name }, - uploaderUrl = v.uploaderUrl ?: ch.url, - thumbnail = v.thumbnail, - durationSeconds = v.durationSeconds, - viewCount = v.viewCount, - ) - } - }.onFailure { - strawLogW("StrawFeed") { "channel fetch failed for ${ch.url}: ${it.message}" } - }.getOrDefault(emptyList()) - } ?: run { - strawLogW("StrawFeed") { "channel fetch timed out: ${ch.url}" } - emptyList() - } - } + val now = System.currentTimeMillis() + coroutineScope { + channels + .filter { ch -> + val entry = channelCache[ch.url] + entry == null || now - entry.fetchedAt >= perChannelTtlMs } - } - deferreds.awaitAll() + .map { ch -> async { gate.withPermit { fetchChannelInto(ch) } } } + .awaitAll() } - .flatten() - // No reliable upload-timestamp on the search-item shape — sort - // by view count desc as a soft proxy for recency-popularity - // within the recent window. - .sortedByDescending { it.viewCount } - .take(200) _ui.update { SubscriptionFeedUiState( loading = false, - items = items, + items = mergeFromCache(channels), lastFetchedAt = System.currentTimeMillis(), ) } @@ -134,4 +114,45 @@ class SubscriptionFeedViewModel : ViewModel() { } } } + + private suspend fun fetchChannelInto(ch: ChannelRef) { + val perChannelMax = 5 + val fetched = withTimeoutOrNull(perChannelTimeoutMs) { + runCatching { + val info = uniffi.strawcore.channelInfo(ch.url) + info.videos.take(perChannelMax).map { v -> + StreamItem( + url = v.url, + title = v.title.ifBlank { "(no title)" }, + uploader = v.uploader.ifBlank { ch.name }, + uploaderUrl = v.uploaderUrl ?: ch.url, + thumbnail = v.thumbnail, + durationSeconds = v.durationSeconds, + viewCount = v.viewCount, + ) + } + }.onFailure { + strawLogW("StrawFeed") { "channel fetch failed for ${ch.url}: ${it.message}" } + }.getOrDefault(emptyList()) + } ?: run { + strawLogW("StrawFeed") { "channel fetch timed out: ${ch.url}" } + emptyList() + } + // Only update the cache on a successful fetch. A timeout/error + // leaves any prior cache entry intact, so a glitchy channel + // doesn't blank your feed for that channel. + if (fetched.isNotEmpty()) { + channelCache[ch.url] = ChannelCacheEntry(System.currentTimeMillis(), fetched) + } + } + + private fun mergeFromCache(channels: List): List { + val subUrls = channels.map { it.url }.toSet() + // Drop cache entries for unsubscribed channels so removed subs + // fall out of the feed immediately. + channelCache.keys.toList().forEach { if (it !in subUrls) channelCache.remove(it) } + return channels.flatMap { ch -> channelCache[ch.url]?.items.orEmpty() } + .sortedByDescending { it.viewCount } + .take(200) + } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerLeaveHandler.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerLeaveHandler.kt deleted file mode 100644 index e7f57495a..000000000 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerLeaveHandler.kt +++ /dev/null @@ -1,17 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2026 Sulkta-Coop - * SPDX-License-Identifier: GPL-3.0-or-later - * - * Bridge between StrawActivity.onUserLeaveHint() (HOME / recents button) - * and the active PlayerScreen. When the user leaves the player by pressing - * HOME, we want a seamless hand-off to the background-audio foreground - * service — not Picture-in-Picture. PlayerScreen registers a handler on - * compose, clears it on dispose; the activity calls it from the OS hook. - */ - -package com.sulkta.straw.feature.player - -object PlayerLeaveHandler { - @Volatile - var handler: (() -> Unit)? = null -} diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt index 173718f7a..0f4339d6f 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt @@ -2,19 +2,12 @@ * SPDX-FileCopyrightText: 2026 Sulkta-Coop * SPDX-License-Identifier: GPL-3.0-or-later * - * Fullscreen player surface. After the V-2 unification, the player - * itself lives in PlaybackService (one ExoPlayer for the whole app). - * This composable is a thin shell that: - * 1. Asks the PlayerViewModel to resolve the stream URL - * 2. Pushes the resolved MediaItem into the shared MediaController - * 3. Renders PlayerView bound to that controller - * 4. Runs the SponsorBlock skip loop against the controller - * 5. Lets the user drag-down to dismiss into the minibar - * - * Audio-only toggle, speed picker, share, manual PiP, and the - * background-audio button stay as overlays. Audio-only flips the - * controller's track-selection params; nothing more to do because - * playback is one player. + * Fullscreen player surface. The player itself lives in PlaybackService + * (one ExoPlayer for the whole app); this composable is a thin shell that + * renders a PlayerView bound to the shared MediaController, lets the user + * drag down to dismiss into the minibar, and overlays speed / audio-only + * / share / PiP / minimize controls. SponsorBlock auto-skip lives at the + * activity root in [SponsorBlockSkipLoop]. */ package com.sulkta.straw.feature.player @@ -35,12 +28,10 @@ import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.Row -import androidx.compose.foundation.layout.Spacer import androidx.compose.foundation.layout.fillMaxSize -import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.offset import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.size -import androidx.compose.foundation.layout.width import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material3.AlertDialog import androidx.compose.material3.CircularProgressIndicator @@ -65,7 +56,6 @@ import androidx.compose.ui.platform.LocalDensity import androidx.compose.ui.unit.IntOffset import androidx.compose.ui.unit.dp import androidx.compose.ui.viewinterop.AndroidView -import androidx.compose.foundation.layout.offset import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.lifecycle.viewmodel.compose.viewModel import androidx.media3.common.C @@ -74,6 +64,8 @@ import androidx.media3.common.Player import androidx.media3.common.TrackSelectionParameters import androidx.media3.common.util.UnstableApi import androidx.media3.ui.PlayerView +import com.sulkta.straw.OverlayChromeColor +import com.sulkta.straw.feature.detail.VideoDetailViewModel import com.sulkta.straw.net.SbSegment import com.sulkta.straw.util.strawLogI import kotlin.math.roundToInt @@ -85,67 +77,46 @@ import kotlinx.coroutines.launch fun PlayerScreen( streamUrl: String, title: String, - startPositionMs: Long = 0L, onMinimize: () -> Unit = {}, - vm: PlayerViewModel = viewModel(), + vm: VideoDetailViewModel = viewModel(), ) { val context = LocalContext.current val controller = LocalStrawController.current val state by vm.ui.collectAsStateWithLifecycle() - LaunchedEffect(streamUrl) { vm.resolve(streamUrl) } + LaunchedEffect(streamUrl) { vm.load(streamUrl) } var playbackSpeed by remember { mutableStateOf(1.0f) } var audioOnly by remember { mutableStateOf(false) } var showSpeedDialog by remember { mutableStateOf(false) } // Drag-to-minimize: vertical offset accumulated during the gesture. - // On release, if past threshold we dismiss into the minibar. + // On release past the threshold we dismiss into the minibar. val density = LocalDensity.current val dismissThresholdPx = with(density) { 200.dp.toPx() } val dragY = remember { Animatable(0f) } val scope = rememberCoroutineScope() - // Push the resolved video into the shared controller as soon as we - // have stream URLs. If something else is already playing the same - // streamUrl, just seek instead of re-loading. - // For metadata that vm.resolve doesn't return (uploader / thumbnail) we - // try to lift them from the matching VideoDetail item if it's open in - // the same nav stack; otherwise fall back to whatever NowPlaying - // already has. Either way the minibar gets enough to render. - val detailVm: com.sulkta.straw.feature.detail.VideoDetailViewModel = viewModel() - LaunchedEffect(streamUrl) { detailVm.load(streamUrl) } - val detailState by detailVm.ui.collectAsStateWithLifecycle() + // When the resolved playback for this URL is ready, push it into the + // shared controller — unless it's already playing this exact URL, in + // which case do nothing: the player is already where we want it. The + // previous "seek-to-self" path here was always a few ms backwards and + // produced a jerk on every entry; the controller's currentPosition is + // its own source of truth. val resolved = state.resolved - LaunchedEffect(controller, resolved, detailState.detail) { + val detail = state.detail + LaunchedEffect(controller, resolved, detail) { val c = controller ?: return@LaunchedEffect val r = resolved ?: return@LaunchedEffect - val d = detailState.detail - val uploader = d?.uploader ?: NowPlaying.current.value?.uploader.orEmpty() - val thumbnail = d?.thumbnail ?: NowPlaying.current.value?.thumbnail - val sameVideo = NowPlaying.current.value?.streamUrl == streamUrl - val currentTitle = c.mediaMetadata.title?.toString() - if (sameVideo && currentTitle == title) { - if (startPositionMs > 0) c.seekTo(startPositionMs) - if (!c.isPlaying) c.play() - NowPlaying.set( - NowPlayingItem( - streamUrl = streamUrl, - title = title, - uploader = uploader, - thumbnail = thumbnail, - segments = r.segments, - ), - ) - } else { - c.setPlayingFrom( - streamUrl = streamUrl, - title = title, - uploader = uploader, - thumbnail = thumbnail, - resolved = r, - startPositionMs = startPositionMs, - ) - } + val uploader = detail?.uploader.orEmpty() + val thumbnail = detail?.thumbnail + if (NowPlaying.current.value?.streamUrl == streamUrl) return@LaunchedEffect + c.setPlayingFrom( + streamUrl = streamUrl, + title = title, + uploader = uploader, + thumbnail = thumbnail, + resolved = r, + ) } // Surface ExoPlayer failures from the service into the UI. @@ -161,9 +132,6 @@ fun PlayerScreen( onDispose { c?.removeListener(listener) } } - // Manual-PiP wiring (the ⊟ overlay button). The activity is the PiP - // host; we just feed it the right params. Auto-enter-on-home stays - // disabled — HOME triggers seamless minibar/background per #255. val activity = context as? Activity Box( @@ -174,7 +142,6 @@ fun PlayerScreen( detectVerticalDragGestures( onDragEnd = { if (dragY.value > dismissThresholdPx) { - // Snap to dismiss + pop into minibar. onMinimize() } else { scope.launch { dragY.animateTo(0f, tween(180)) } @@ -185,7 +152,6 @@ fun PlayerScreen( }, onVerticalDrag = { _, dy -> scope.launch { - // Clamp to non-negative — upward drag has no effect. dragY.snapTo((dragY.value + dy).coerceAtLeast(0f)) } }, @@ -222,26 +188,23 @@ fun PlayerScreen( } }, update = { it.player = controller }, + onRelease = { it.player = null }, modifier = Modifier.fillMaxSize(), ) - // SponsorBlock segment count badge — small overlay top-left. - resolved.let { r -> - Box( - modifier = Modifier - .align(Alignment.TopStart) - .padding(12.dp) - .clip(RoundedCornerShape(6.dp)) - .background(Color(0xCC222222)) - .padding(horizontal = 8.dp, vertical = 4.dp), - ) { - Text( - text = "SB: ${r.segments.size} segment${if (r.segments.size == 1) "" else "s"}", - color = Color.White, - style = MaterialTheme.typography.labelSmall, - ) - } + Box( + modifier = Modifier + .align(Alignment.TopStart) + .padding(12.dp) + .clip(RoundedCornerShape(6.dp)) + .background(OverlayChromeColor) + .padding(horizontal = 8.dp, vertical = 4.dp), + ) { + Text( + text = "SB: ${resolved.segments.size} segment${if (resolved.segments.size == 1) "" else "s"}", + color = Color.White, + style = MaterialTheme.typography.labelSmall, + ) } - // Top-right overlay — speed / audio-only / share / PiP / minimize. Row( modifier = Modifier.align(Alignment.TopEnd).padding(12.dp), horizontalArrangement = Arrangement.spacedBy(8.dp), @@ -288,7 +251,6 @@ fun PlayerScreen( Toast.makeText(context, "PiP failed: ${t.message}", Toast.LENGTH_LONG).show() } } - // Explicit minimize button — same effect as drag-down. OverlayButton(label = "⌄") { onMinimize() } } @@ -314,7 +276,7 @@ private fun OverlayButton(label: String, onClick: () -> Unit) { modifier = Modifier .size(36.dp) .clip(RoundedCornerShape(6.dp)) - .background(Color(0xCC222222)) + .background(OverlayChromeColor) .clickable(onClick = onClick), contentAlignment = Alignment.Center, ) { @@ -360,9 +322,12 @@ private fun SpeedPickerDialog( /** * SponsorBlock skip loop driven by the controller's currentPosition. - * Runs at the activity composition root (not per-screen) so it skips - * segments whether the user is fullscreen, in the minibar, or away from - * the player surface. + * Lives at the activity composition root so it skips segments whether + * the user is fullscreen, in the minibar, or away from the player + * surface. + * + * The `skipped` set is only mutated from this single coroutine — safe + * without synchronization while that invariant holds. */ @Composable @OptIn(UnstableApi::class) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerViewModel.kt deleted file mode 100644 index 5dd9eeaa3..000000000 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerViewModel.kt +++ /dev/null @@ -1,103 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2026 Sulkta-Coop - * SPDX-License-Identifier: GPL-3.0-or-later - * - * Phase U-3 / Path C-4: extractor moved from NewPipeExtractor (Java) to - * strawcore (Rust + rustypipe via UniFFI). PlayerScreen still calls - * vm.resolve(url) the same way — the engine underneath flipped. - */ - -package com.sulkta.straw.feature.player - -import androidx.lifecycle.ViewModel -import androidx.lifecycle.viewModelScope -import com.sulkta.straw.data.Settings -import com.sulkta.straw.net.SbSegment -import com.sulkta.straw.net.SponsorBlockClient -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.flow.MutableStateFlow -import kotlinx.coroutines.flow.StateFlow -import kotlinx.coroutines.flow.asStateFlow -import kotlinx.coroutines.launch -import kotlinx.coroutines.withContext - -data class ResolvedPlayback( - val title: String, - val videoUrl: String?, - val audioUrl: String?, - val combinedUrl: String?, - val dashMpdUrl: String?, - val hlsUrl: String?, - val segments: List = emptyList(), -) { - /** Have anything playable? */ - val isPlayable: Boolean - get() = !combinedUrl.isNullOrBlank() || !videoUrl.isNullOrBlank() || - !dashMpdUrl.isNullOrBlank() || !hlsUrl.isNullOrBlank() -} - -data class PlayerUiState( - val loading: Boolean = true, - val resolved: ResolvedPlayback? = null, - val error: String? = null, -) - -class PlayerViewModel : ViewModel() { - private val _ui = MutableStateFlow(PlayerUiState()) - val ui: StateFlow = _ui.asStateFlow() - - fun resolve(streamUrl: String) { - _ui.value = PlayerUiState(loading = true) - viewModelScope.launch { - try { - // strawcore.streamInfo is a suspend fun running on the tokio - // runtime baked into libstrawcore.so — no Dispatchers.IO needed. - val info = uniffi.strawcore.streamInfo(streamUrl) - val videoId = info.id - - val sbCategories = Settings.get().sbCategories.value.map { it.key } - val segments = if (sbCategories.isEmpty()) { - emptyList() - } else { - withContext(Dispatchers.IO) { - runCatching { SponsorBlockClient.fetch(videoId, sbCategories) } - .getOrDefault(emptyList()) - } - } - - val maxRes = Settings.get().maxResolution.value.ceiling - - // Audit HIGH-8 carry-over: filter by max resolution but fall - // back to lowest available if the ceiling excludes everything. - fun pickVideo(streams: List): String? { - if (streams.isEmpty()) return null - val filtered = streams.filter { it.height <= maxRes } - val pool = filtered.ifEmpty { streams } - return pool.maxByOrNull { it.bitrate }?.url - } - - val combined = pickVideo(info.combined) - val videoOnly = pickVideo(info.videoOnly) - val audioOnly = info.audioOnly.maxByOrNull { it.bitrate }?.url - - _ui.value = PlayerUiState( - loading = false, - resolved = ResolvedPlayback( - title = info.title, - videoUrl = videoOnly, - audioUrl = audioOnly, - combinedUrl = combined, - dashMpdUrl = info.dashMpdUrl?.takeIf { it.isNotBlank() }, - hlsUrl = info.hlsUrl?.takeIf { it.isNotBlank() }, - segments = segments, - ), - ) - } catch (t: Throwable) { - _ui.value = PlayerUiState( - loading = false, - error = t.message ?: t.javaClass.simpleName, - ) - } - } - } -} diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt index 6ad3d376f..498dc96a9 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt @@ -41,6 +41,7 @@ import androidx.media3.common.util.UnstableApi import androidx.media3.session.MediaController import androidx.media3.session.SessionToken import com.google.common.util.concurrent.MoreExecutors +import com.sulkta.straw.feature.detail.ResolvedPlayback val LocalStrawController = compositionLocalOf { null } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt index 338388af9..e48aecd83 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt @@ -41,15 +41,11 @@ class SearchViewModel : ViewModel() { fun submit() { val q = _ui.value.query.trim() if (q.isEmpty()) return - runCatching { History.get().recordSearch(q) } _ui.value = _ui.value.copy(loading = true, error = null, results = emptyList()) viewModelScope.launch { try { - // Phase U-2 / Path C-3: rustypipe via UniFFI. The bindgen-generated - // `search()` is already a suspend fun running on the tokio runtime - // baked into libstrawcore.so — no Dispatchers.IO wrapper needed, - // the JNI call returns to us on the caller dispatcher when the - // future completes. + // strawcore.search() is suspend on the tokio runtime baked + // into libstrawcore.so — no Dispatchers.IO wrap needed. val rustItems = uniffi.strawcore.search(q) val items = rustItems.map { r -> StreamItem( @@ -63,6 +59,9 @@ class SearchViewModel : ViewModel() { ) } _ui.value = _ui.value.copy(loading = false, results = items) + // Record AFTER the search succeeds so mistyped queries + // that error out don't pollute the recent-searches list. + runCatching { History.get().recordSearch(q) } } catch (t: Throwable) { _ui.value = _ui.value.copy( loading = false, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/util/HtmlText.kt b/strawApp/src/main/kotlin/com/sulkta/straw/util/HtmlText.kt index f228b23d2..b4933d38a 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/util/HtmlText.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/util/HtmlText.kt @@ -2,9 +2,9 @@ * SPDX-FileCopyrightText: 2026 Sulkta-Coop * SPDX-License-Identifier: GPL-3.0-or-later * - * Strip HTML tags from NewPipeExtractor's description.content for plain-text - * rendering. Day-3 polish replaces this with a real Markwon/Compose annotated - * renderer; for now we just want readable text. + * Strip HTML tags from video descriptions for plain-text rendering. + * Replace with a real annotated renderer (Markwon, Compose annotated + * strings) when the description UI needs richer formatting. */ package com.sulkta.straw.util From 885398e3bddc89f6e478d5df98f2cd84fd1f5691 Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 17:46:23 +0000 Subject: [PATCH 10/72] =?UTF-8?q?vc=3D26:=20look=20+=20feel=20pass=20?= =?UTF-8?q?=E2=80=94=20sulkta.com=20palette=20+=20Material=20Icons?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Color palette pulled directly from sulkta.com's stylesheet — the same greens used on the website now drive the app theme: #166534 deep green (light-theme primary, top app bar background) #4ade80 bright lime (dark-theme primary, accents in dark mode) #86efac light green (primaryContainer in light theme) #e8f5e8 pale green (secondary container tint) #d97706 amber accent (tertiary) #374137 olive gray (secondary on light, container on dark) Replaces the made-up forest palette from vc=23 with the real Sulkta brand. Same M3 tonal-role mapping so derived surfaces stay consistent. TopAppBar redone NewPipe-style: solid deep-green bar with white "straw" title, white hamburger + search icons. Clear bold header instead of the previous white-with-a-pill-underneath layout. Material Icons swapped in everywhere we had emoji: drawer Person / History / PlaylistPlay / Download / Settings minibar PlayArrow / Pause / Close fullscreen Speed / Headphones / Videocam / Share / PictureInPictureAlt / KeyboardArrowDown Pulled in material-icons-extended (4 MB APK growth, all icons). Consistent renders across vendors; no more emoji font fallback drift. FeedRow gets a NewPipe-style duration pill burned into the bottom-right of every thumbnail (mm:ss / h:mm:ss). Live streams / mixes with no duration leave it off. Audit deferred-MED items addressed: MED-6: dropped the PlayerService STATE_ENDED auto-stop. Service shutdown is now driven only by onTaskRemoved + the minibar's ×. Removes the implicit "we'll never queue" assumption and is correct for a future autoplay/queue feature. LOW-7: DownloadsScreen adaptive poll — 1s while a download is active, 5s when idle. No more wasted DB queries when nothing is running. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- strawApp/build.gradle.kts | 2 +- .../main/kotlin/com/sulkta/straw/StrawHome.kt | 121 ++++++++++++------ .../kotlin/com/sulkta/straw/StrawTheme.kt | 106 ++++++++------- .../straw/feature/download/DownloadsScreen.kt | 17 ++- .../straw/feature/player/MinibarOverlay.kt | 20 ++- .../straw/feature/player/PlaybackService.kt | 20 +-- .../straw/feature/player/PlayerScreen.kt | 41 ++++-- 8 files changed, 207 insertions(+), 124 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 12e988a7a..fdfb000d4 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 25 -const val STRAW_VERSION_NAME = "0.1.0-AK" +const val STRAW_VERSION_CODE = 26 +const val STRAW_VERSION_NAME = "0.1.0-AL" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/build.gradle.kts b/strawApp/build.gradle.kts index 774719420..bb98352e7 100644 --- a/strawApp/build.gradle.kts +++ b/strawApp/build.gradle.kts @@ -81,7 +81,7 @@ dependencies { implementation(libs.jetbrains.compose.foundation) implementation(libs.jetbrains.compose.material3) implementation(libs.jetbrains.compose.ui) - implementation("androidx.compose.material:material-icons-core:1.7.5") + implementation("androidx.compose.material:material-icons-extended:1.7.5") // Lifecycle + ViewModel for Compose implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.10.0") diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt index 0512de4aa..85c4b9a6e 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt @@ -8,8 +8,10 @@ package com.sulkta.straw +import androidx.compose.foundation.background import androidx.compose.foundation.clickable import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.Spacer @@ -25,7 +27,13 @@ import androidx.compose.foundation.lazy.items import androidx.compose.foundation.shape.CircleShape import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Download +import androidx.compose.material.icons.filled.History import androidx.compose.material.icons.filled.Menu +import androidx.compose.material.icons.filled.Person +import androidx.compose.material.icons.filled.PlaylistPlay +import androidx.compose.material.icons.filled.Search +import androidx.compose.material.icons.filled.Settings import androidx.compose.material3.CircularProgressIndicator import androidx.compose.material3.DrawerValue import androidx.compose.material3.ExperimentalMaterial3Api @@ -36,14 +44,12 @@ import androidx.compose.material3.MaterialTheme import androidx.compose.material3.ModalDrawerSheet import androidx.compose.material3.ModalNavigationDrawer import androidx.compose.material3.NavigationDrawerItem -import androidx.compose.foundation.background -import androidx.compose.foundation.border -import androidx.compose.foundation.layout.Box import androidx.compose.material3.Scaffold import androidx.compose.material3.Surface import androidx.compose.material3.Text import androidx.compose.material3.TextButton import androidx.compose.material3.TopAppBar +import androidx.compose.material3.TopAppBarDefaults import androidx.compose.material3.rememberDrawerState import androidx.compose.runtime.Composable import androidx.compose.runtime.LaunchedEffect @@ -68,6 +74,7 @@ import com.sulkta.straw.data.Subscriptions import com.sulkta.straw.data.WatchHistoryItem import com.sulkta.straw.feature.feed.SubscriptionFeedViewModel import com.sulkta.straw.feature.search.StreamItem +import com.sulkta.straw.OverlayDimColor import com.sulkta.straw.util.formatViews import kotlinx.coroutines.launch @@ -109,7 +116,7 @@ fun StrawHome( NavigationDrawerItem( label = { Text("Subscriptions") }, - icon = { Text("👤") }, + icon = { Icon(Icons.Filled.Person, contentDescription = null) }, selected = view == HomeView.Subs, onClick = { view = HomeView.Subs @@ -119,7 +126,7 @@ fun StrawHome( ) NavigationDrawerItem( label = { Text("History") }, - icon = { Text("📺") }, + icon = { Icon(Icons.Filled.History, contentDescription = null) }, selected = view == HomeView.History, onClick = { view = HomeView.History @@ -129,7 +136,7 @@ fun StrawHome( ) NavigationDrawerItem( label = { Text("Playlists") }, - icon = { Text("📃") }, + icon = { Icon(Icons.Filled.PlaylistPlay, contentDescription = null) }, selected = false, onClick = { scope.launch { drawerState.close() } @@ -139,7 +146,7 @@ fun StrawHome( ) NavigationDrawerItem( label = { Text("Downloads") }, - icon = { Text("⬇") }, + icon = { Icon(Icons.Filled.Download, contentDescription = null) }, selected = false, onClick = { scope.launch { drawerState.close() } @@ -150,7 +157,7 @@ fun StrawHome( HorizontalDivider(modifier = Modifier.padding(vertical = 12.dp)) NavigationDrawerItem( label = { Text("Settings") }, - icon = { Text("⚙") }, + icon = { Icon(Icons.Filled.Settings, contentDescription = null) }, selected = false, onClick = { scope.launch { drawerState.close() } @@ -163,42 +170,33 @@ fun StrawHome( ) { Scaffold( topBar = { + // Green-tinted bar inspired by NewPipe/Tubular's colored + // header, but using our forest-green primary container so + // it sits cleanly with the rest of the Material 3 surfaces. TopAppBar( title = { - // Search-pill in the title slot — tap takes you to the - // full search screen with the field auto-focused. Same - // idea as YT's mobile top bar. - Surface( - modifier = Modifier - .fillMaxWidth() - .padding(end = 8.dp) - .height(40.dp) - .clip(RoundedCornerShape(20.dp)) - .clickable(onClick = onOpenSearch), - color = MaterialTheme.colorScheme.surfaceVariant, - ) { - Row( - verticalAlignment = Alignment.CenterVertically, - modifier = Modifier.padding(horizontal = 14.dp), - ) { - Text( - "🔍", - style = MaterialTheme.typography.bodyMedium, - ) - Spacer(modifier = Modifier.width(10.dp)) - Text( - "Search YouTube", - style = MaterialTheme.typography.bodyMedium, - color = MaterialTheme.colorScheme.onSurfaceVariant, - ) - } - } + Text( + "straw", + style = MaterialTheme.typography.titleLarge, + fontWeight = FontWeight.SemiBold, + ) }, navigationIcon = { IconButton(onClick = { scope.launch { drawerState.open() } }) { Icon(Icons.Filled.Menu, contentDescription = "Menu") } }, + actions = { + IconButton(onClick = onOpenSearch) { + Icon(Icons.Filled.Search, contentDescription = "Search") + } + }, + colors = TopAppBarDefaults.topAppBarColors( + containerColor = MaterialTheme.colorScheme.primary, + titleContentColor = MaterialTheme.colorScheme.onPrimary, + navigationIconContentColor = MaterialTheme.colorScheme.onPrimary, + actionIconContentColor = MaterialTheme.colorScheme.onPrimary, + ), ) }, ) { padding -> @@ -352,13 +350,12 @@ private fun FeedRow(item: StreamItem, onClick: () -> Unit) { .padding(vertical = 8.dp), verticalAlignment = Alignment.Top, ) { - AsyncImage( - model = item.thumbnail, - contentDescription = null, + ThumbnailWithDuration( + thumbnail = item.thumbnail, + durationSeconds = item.durationSeconds, modifier = Modifier .width(140.dp) - .height(80.dp) - .clip(RoundedCornerShape(6.dp)), + .height(80.dp), ) Spacer(modifier = Modifier.width(10.dp)) Column(modifier = Modifier.weight(1f)) { @@ -387,6 +384,48 @@ private fun FeedRow(item: StreamItem, onClick: () -> Unit) { } } +/** + * 16:9 thumbnail with a NewPipe-style duration pill burned into the + * bottom-right corner. `durationSeconds == 0` skips the badge (live + * streams, mixes that come back without a duration, etc.). + */ +@Composable +private fun ThumbnailWithDuration( + thumbnail: String?, + durationSeconds: Long, + modifier: Modifier = Modifier, +) { + Box(modifier = modifier) { + AsyncImage( + model = thumbnail, + contentDescription = null, + modifier = Modifier + .fillMaxSize() + .clip(RoundedCornerShape(6.dp)), + ) + if (durationSeconds > 0) { + Text( + text = formatDurationShort(durationSeconds), + style = MaterialTheme.typography.labelSmall, + color = androidx.compose.ui.graphics.Color.White, + modifier = Modifier + .align(Alignment.BottomEnd) + .padding(4.dp) + .clip(RoundedCornerShape(3.dp)) + .background(OverlayDimColor) + .padding(horizontal = 4.dp, vertical = 1.dp), + ) + } + } +} + +private fun formatDurationShort(totalSec: Long): String { + val h = totalSec / 3600 + val m = (totalSec % 3600) / 60 + val s = totalSec % 60 + return if (h > 0) "%d:%02d:%02d".format(h, m, s) else "%d:%02d".format(m, s) +} + @Composable private fun SubChip( ch: ChannelRef, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawTheme.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawTheme.kt index c3ee116ec..ebbacd377 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawTheme.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawTheme.kt @@ -2,10 +2,19 @@ * SPDX-FileCopyrightText: 2026 Sulkta-Coop * SPDX-License-Identifier: GPL-3.0-or-later * - * Sulkta green palette for Straw. Replaces the M3 default lavender/red - * tints with a clean forest green primary — modern, clean, distinct from - * NewPipe / Tubular's red. Same Tonal Palette structure Material 3 uses - * internally so all the derived surfaces stay in harmony. + * Straw palette pulled directly from sulkta.com's stylesheet: + * #4ade80 primary green (Tailwind green-400, most-used on the site) + * #166534 deep green (green-800, headings + emphasis) + * #22c55e mid green (green-500, links + buttons) + * #86efac light green container (green-300) + * #e8f5e8 pale green tint + * #d97706 amber accent (sulkta.com calls this out for chips) + * #374137 olive-gray secondary + * #0a0a0a near-black text on light + * #111411 near-black with green tint for dark surface + * + * Mapped into Material 3's primary / secondary / tertiary tonal roles + * so all the derived M3 surfaces (containers, outlines, etc.) follow. */ package com.sulkta.straw @@ -15,56 +24,61 @@ import androidx.compose.material3.darkColorScheme import androidx.compose.material3.lightColorScheme import androidx.compose.ui.graphics.Color -private val GreenPrimary = Color(0xFF386A1F) -private val GreenOnPrimary = Color(0xFFFFFFFF) -private val GreenPrimaryContainer = Color(0xFFB6F397) -private val GreenOnPrimaryContainer = Color(0xFF0B2000) -private val GreenSecondary = Color(0xFF55624C) -private val GreenOnSecondary = Color(0xFFFFFFFF) -private val GreenSecondaryContainer = Color(0xFFD8E7CB) -private val GreenOnSecondaryContainer = Color(0xFF131F0D) -private val GreenTertiary = Color(0xFF386666) -private val GreenOnTertiary = Color(0xFFFFFFFF) +// Light theme — primary is sulkta.com's deep green (#166534), strong +// enough for white text and matches the site's heading emphasis. +private val LPrimary = Color(0xFF166534) +private val LOnPrimary = Color(0xFFFFFFFF) +private val LPrimaryContainer = Color(0xFF86EFAC) +private val LOnPrimaryContainer = Color(0xFF0A0A0A) +private val LSecondary = Color(0xFF374137) +private val LOnSecondary = Color(0xFFFFFFFF) +private val LSecondaryContainer = Color(0xFFE8F5E8) +private val LOnSecondaryContainer = Color(0xFF0A0A0A) +private val LTertiary = Color(0xFFD97706) +private val LOnTertiary = Color(0xFFFFFFFF) -private val DarkGreenPrimary = Color(0xFF9BD67D) -private val DarkGreenOnPrimary = Color(0xFF153800) -private val DarkGreenPrimaryContainer = Color(0xFF205107) -private val DarkGreenOnPrimaryContainer = Color(0xFFB6F397) -private val DarkGreenSecondary = Color(0xFFBDCBB0) -private val DarkGreenOnSecondary = Color(0xFF283420) -private val DarkGreenSecondaryContainer = Color(0xFF3E4A35) -private val DarkGreenOnSecondaryContainer = Color(0xFFD8E7CB) -private val DarkGreenTertiary = Color(0xFFA0CFD0) -private val DarkGreenOnTertiary = Color(0xFF003738) +// Dark theme — primary is sulkta.com's bright lime (#4ade80) since dark +// backgrounds need a brighter accent for readability. PrimaryContainer +// is the deep green so emphasis stays consistent across themes. +private val DPrimary = Color(0xFF4ADE80) +private val DOnPrimary = Color(0xFF0A0A0A) +private val DPrimaryContainer = Color(0xFF166534) +private val DOnPrimaryContainer = Color(0xFF86EFAC) +private val DSecondary = Color(0xFF9AB89A) +private val DOnSecondary = Color(0xFF111411) +private val DSecondaryContainer = Color(0xFF374137) +private val DOnSecondaryContainer = Color(0xFFE8F5E8) +private val DTertiary = Color(0xFFD97706) +private val DOnTertiary = Color(0xFF0A0A0A) fun strawLightColors(): ColorScheme = lightColorScheme( - primary = GreenPrimary, - onPrimary = GreenOnPrimary, - primaryContainer = GreenPrimaryContainer, - onPrimaryContainer = GreenOnPrimaryContainer, - secondary = GreenSecondary, - onSecondary = GreenOnSecondary, - secondaryContainer = GreenSecondaryContainer, - onSecondaryContainer = GreenOnSecondaryContainer, - tertiary = GreenTertiary, - onTertiary = GreenOnTertiary, + primary = LPrimary, + onPrimary = LOnPrimary, + primaryContainer = LPrimaryContainer, + onPrimaryContainer = LOnPrimaryContainer, + secondary = LSecondary, + onSecondary = LOnSecondary, + secondaryContainer = LSecondaryContainer, + onSecondaryContainer = LOnSecondaryContainer, + tertiary = LTertiary, + onTertiary = LOnTertiary, ) fun strawDarkColors(): ColorScheme = darkColorScheme( - primary = DarkGreenPrimary, - onPrimary = DarkGreenOnPrimary, - primaryContainer = DarkGreenPrimaryContainer, - onPrimaryContainer = DarkGreenOnPrimaryContainer, - secondary = DarkGreenSecondary, - onSecondary = DarkGreenOnSecondary, - secondaryContainer = DarkGreenSecondaryContainer, - onSecondaryContainer = DarkGreenOnSecondaryContainer, - tertiary = DarkGreenTertiary, - onTertiary = DarkGreenOnTertiary, + primary = DPrimary, + onPrimary = DOnPrimary, + primaryContainer = DPrimaryContainer, + onPrimaryContainer = DOnPrimaryContainer, + secondary = DSecondary, + onSecondary = DOnSecondary, + secondaryContainer = DSecondaryContainer, + onSecondaryContainer = DOnSecondaryContainer, + tertiary = DTertiary, + onTertiary = DOnTertiary, ) // Semi-transparent overlays for chrome (overlay buttons, the SB badge, // the inline-player fullscreen pill) and for the dimmed area behind the // minibar thumbnail. Kept here so a theme tweak touches one place. -val OverlayChromeColor = androidx.compose.ui.graphics.Color(0xCC222222) -val OverlayDimColor = androidx.compose.ui.graphics.Color(0xCC000000) +val OverlayChromeColor = Color(0xCC222222) +val OverlayDimColor = Color(0xCC000000) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/DownloadsScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/DownloadsScreen.kt index f3262cd41..5872a5c17 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/DownloadsScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/DownloadsScreen.kt @@ -86,14 +86,19 @@ fun DownloadsScreen() { val context = LocalContext.current var rows by remember { mutableStateOf>(emptyList()) } - // Poll DownloadManager every second while the screen is visible. - // DownloadManager doesn't broadcast progress, so polling is the - // standard pattern. Cheap query — single cursor across the app's own - // download queue. + // DownloadManager doesn't broadcast progress, so we poll while the + // screen is visible. Fast cadence (1s) when something is actively + // running, slow cadence (5s) when everything is settled — no + // animations to update. LaunchedEffect(Unit) { while (true) { - rows = queryDownloads(context) - delay(1000) + val fresh = queryDownloads(context) + rows = fresh + val active = fresh.any { + it.status == DownloadManager.STATUS_RUNNING || + it.status == DownloadManager.STATUS_PENDING + } + delay(if (active) 1000 else 5000) } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/MinibarOverlay.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/MinibarOverlay.kt index b1d98bcb6..dea622a58 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/MinibarOverlay.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/MinibarOverlay.kt @@ -27,7 +27,12 @@ import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.size import androidx.compose.foundation.layout.width import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Close +import androidx.compose.material.icons.filled.Pause +import androidx.compose.material.icons.filled.PlayArrow import androidx.compose.material3.HorizontalDivider +import androidx.compose.material3.Icon import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Surface import androidx.compose.material3.Text @@ -113,10 +118,13 @@ fun MinibarOverlay( ) } Row(horizontalArrangement = Arrangement.spacedBy(4.dp)) { - MinibarIconButton(label = if (isPlaying) "⏸" else "▶") { + MinibarIconButton( + icon = if (isPlaying) Icons.Filled.Pause else Icons.Filled.PlayArrow, + desc = if (isPlaying) "Pause" else "Play", + ) { if (controller.isPlaying) controller.pause() else controller.play() } - MinibarIconButton(label = "×") { + MinibarIconButton(icon = Icons.Filled.Close, desc = "Stop") { controller.stop() controller.clearMediaItems() NowPlaying.clear() @@ -128,7 +136,11 @@ fun MinibarOverlay( } @Composable -private fun MinibarIconButton(label: String, onClick: () -> Unit) { +private fun MinibarIconButton( + icon: androidx.compose.ui.graphics.vector.ImageVector, + desc: String, + onClick: () -> Unit, +) { Box( modifier = Modifier .size(44.dp) @@ -136,6 +148,6 @@ private fun MinibarIconButton(label: String, onClick: () -> Unit) { .clickable(onClick = onClick), contentAlignment = Alignment.Center, ) { - Text(label, style = MaterialTheme.typography.titleMedium) + Icon(imageVector = icon, contentDescription = desc, modifier = Modifier.size(22.dp)) } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt index 61e0f1c47..95902fa6d 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt @@ -79,14 +79,11 @@ class PlaybackService : MediaSessionService() { ) .build() - // Stop ourselves once playback genuinely ends so the foreground slot - // is released. STATE_IDLE + STATE_ENDED both qualify; STATE_BUFFERING - // / STATE_READY mean we're still doing work even if paused. - player.addListener(object : Player.Listener { - override fun onPlaybackStateChanged(state: Int) { - if (state == Player.STATE_ENDED) stopSelfWhenIdle() - } - }) + // Service shutdown is driven by onTaskRemoved (user swiped app away) + // + the user pressing × on the minibar (which clears the queue). + // Don't auto-stop on STATE_ENDED — a future autoplay/queue feature + // expects the service to stay alive between items in the queue. + // Foreground notification fades on its own when nothing is playing. val sessionActivityIntent = PendingIntent.getActivity( this, @@ -132,13 +129,6 @@ class PlaybackService : MediaSessionService() { super.onDestroy() } - private fun stopSelfWhenIdle() { - val p = mediaSession?.player ?: return - if (p.mediaItemCount == 0 || p.playbackState == Player.STATE_IDLE) { - stopSelf() - } - } - companion object { const val MEDIA_SESSION_ID = "straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt index 0f4339d6f..cdc2fa39a 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt @@ -33,11 +33,20 @@ import androidx.compose.foundation.layout.offset import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.size import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.KeyboardArrowDown +import androidx.compose.material.icons.filled.Headphones +import androidx.compose.material.icons.filled.PictureInPictureAlt +import androidx.compose.material.icons.filled.Share +import androidx.compose.material.icons.filled.Speed +import androidx.compose.material.icons.filled.Videocam import androidx.compose.material3.AlertDialog import androidx.compose.material3.CircularProgressIndicator +import androidx.compose.material3.Icon import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Text import androidx.compose.material3.TextButton +import androidx.compose.ui.graphics.vector.ImageVector import androidx.compose.runtime.Composable import androidx.compose.runtime.DisposableEffect import androidx.compose.runtime.LaunchedEffect @@ -209,10 +218,13 @@ fun PlayerScreen( modifier = Modifier.align(Alignment.TopEnd).padding(12.dp), horizontalArrangement = Arrangement.spacedBy(8.dp), ) { - OverlayButton(label = if (playbackSpeed == 1f) "1×" else "${playbackSpeed}×") { + OverlayIconButton(icon = Icons.Filled.Speed, desc = "Playback speed") { showSpeedDialog = true } - OverlayButton(label = if (audioOnly) "📻" else "📺") { + OverlayIconButton( + icon = if (audioOnly) Icons.Filled.Headphones else Icons.Filled.Videocam, + desc = if (audioOnly) "Audio-only on" else "Video on", + ) { audioOnly = !audioOnly controller.trackSelectionParameters = TrackSelectionParameters.Builder(context) .setTrackTypeDisabled(C.TRACK_TYPE_VIDEO, audioOnly) @@ -223,7 +235,7 @@ fun PlayerScreen( Toast.LENGTH_SHORT, ).show() } - OverlayButton(label = "↗") { + OverlayIconButton(icon = Icons.Filled.Share, desc = "Share") { val send = Intent(Intent.ACTION_SEND).apply { type = "text/plain" putExtra(Intent.EXTRA_TEXT, streamUrl) @@ -231,14 +243,14 @@ fun PlayerScreen( } context.startActivity(Intent.createChooser(send, "Share video")) } - OverlayButton(label = "⊟") { + OverlayIconButton(icon = Icons.Filled.PictureInPictureAlt, desc = "Picture in picture") { if (activity == null) { Toast.makeText(context, "PiP: no activity", Toast.LENGTH_SHORT).show() - return@OverlayButton + return@OverlayIconButton } if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) { Toast.makeText(context, "PiP needs Android 8+", Toast.LENGTH_SHORT).show() - return@OverlayButton + return@OverlayIconButton } val params = PictureInPictureParams.Builder() .setAspectRatio(Rational(16, 9)) @@ -251,7 +263,9 @@ fun PlayerScreen( Toast.makeText(context, "PiP failed: ${t.message}", Toast.LENGTH_LONG).show() } } - OverlayButton(label = "⌄") { onMinimize() } + OverlayIconButton(icon = Icons.Filled.KeyboardArrowDown, desc = "Minimize") { + onMinimize() + } } if (showSpeedDialog) { @@ -271,7 +285,11 @@ fun PlayerScreen( } @Composable -private fun OverlayButton(label: String, onClick: () -> Unit) { +private fun OverlayIconButton( + icon: ImageVector, + desc: String, + onClick: () -> Unit, +) { Box( modifier = Modifier .size(36.dp) @@ -280,7 +298,12 @@ private fun OverlayButton(label: String, onClick: () -> Unit) { .clickable(onClick = onClick), contentAlignment = Alignment.Center, ) { - Text(label, color = Color.White, style = MaterialTheme.typography.titleSmall) + Icon( + imageVector = icon, + contentDescription = desc, + tint = Color.White, + modifier = Modifier.size(20.dp), + ) } } From 35f5affec33d22693d7282c23aac8ad1c6f472ca Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 11:17:20 -0700 Subject: [PATCH 11/72] vc=27: swipe-down on detail page + Background/Popout buttons MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Three pieces of feedback on vc=26, fixed in one pass: (1) Swipe-to-minimize was on the fullscreen player, where it fought PlayerView's own touch handling and felt janky. Moved the gesture to the VideoDetailScreen — the same place YouTube/NewPipe put it. The drag handle is the inline-player surface itself (the 16:9 box at top); outside that, the description scrolls normally. The whole page translates with the finger via graphicsLayer + an alpha/scale fade so the motion reads as "the video is being tucked away" rather than the old jump-and-snap. Threshold 140dp → onMinimize. Fullscreen keeps the down-arrow button for minimize; the drag-to-dismiss path is gone from PlayerScreen entirely (along with its Animatable + density imports). Whichever surface is visible has exactly one minimize affordance. (2) The minibar was always visible on every non-Player screen, which meant it stacked under the VideoDetail page even though the inline player is already there. Updated visibility predicate to also hide on VideoDetail — the minibar is now strictly the take-over UI for when you leave the video page. Tapping the minibar pushes back to VideoDetail (not fullscreen) so the mental model is symmetrical: swipe-down to leave, tap to come back. (3) Two new buttons on the VideoDetail action row: Background — disables the video track on the controller and pops out of detail. The foreground service keeps audio going; the minibar appears on whatever screen you land on. Pre-checks that the controller is actually playing this video before leaving — otherwise the minibar would dismiss into empty. Popout — enters PiP via the activity, same code path as the fullscreen overlay button. Same controller pre-check. Nav helper: added Navigator.resetTo(Screen) so that minimize from a deep-link entry (where VideoDetail is the only stack item) drops the user on Home rather than no-op'ing. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- .../src/main/kotlin/com/sulkta/straw/Nav.kt | 11 ++ .../kotlin/com/sulkta/straw/StrawActivity.kt | 14 +- .../straw/feature/detail/VideoDetailScreen.kt | 162 +++++++++++++++++- .../straw/feature/player/PlayerScreen.kt | 50 +----- 5 files changed, 189 insertions(+), 52 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index fdfb000d4..a20dca091 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 26 -const val STRAW_VERSION_NAME = "0.1.0-AL" +const val STRAW_VERSION_CODE = 27 +const val STRAW_VERSION_NAME = "0.1.0-AM" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/Nav.kt b/strawApp/src/main/kotlin/com/sulkta/straw/Nav.kt index 9763aa727..1b57d3471 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/Nav.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/Nav.kt @@ -42,6 +42,17 @@ class Navigator(initial: Screen) { stack.removeAt(stack.lastIndex) return true } + + /** + * Replace the entire stack with a single screen. Used by the + * swipe-to-minimize gesture when the user lands directly on a video + * page via a deep link — there's nothing to pop back to, so we drop + * them on Home instead. + */ + fun resetTo(s: Screen) { + stack.clear() + stack.add(s) + } } @Composable diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt index dea41ffea..2a5cc65e9 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt @@ -108,13 +108,18 @@ class StrawActivity : ComponentActivity() { Box(modifier = Modifier.fillMaxSize()) { ScreenContent(nav, s = nav.current) - // Persistent minibar — visible on every non-Player - // screen whenever something is loaded. - if (nav.current !is Screen.Player) { + // The minibar is the takeover-when-you-leave UI: + // hide it while you're on the actual video page + // (the inline player IS the player) and hide it + // in fullscreen (which IS the player). Everywhere + // else, audio keeps going and the minibar gives + // you a way back. + val cur = nav.current + if (cur !is Screen.Player && cur !is Screen.VideoDetail) { MinibarOverlay( onExpand = { val item = NowPlaying.current.value ?: return@MinibarOverlay - nav.push(Screen.Player(item.streamUrl, item.title)) + nav.push(Screen.VideoDetail(item.streamUrl, item.title)) }, modifier = Modifier.align(Alignment.BottomCenter), ) @@ -157,6 +162,7 @@ class StrawActivity : ComponentActivity() { streamUrl = s.streamUrl, initialTitle = s.title, onPlay = { nav.push(Screen.Player(s.streamUrl, s.title)) }, + onMinimize = { if (!nav.pop()) nav.resetTo(Screen.Home) }, onOpenChannel = { url, name -> nav.push(Screen.Channel(url, name)) }, onOpenVideo = { url, title -> nav.push(Screen.VideoDetail(url, title)) }, ) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index 499f232b1..7b552764e 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -5,11 +5,19 @@ package com.sulkta.straw.feature.detail +import android.app.Activity +import android.app.PictureInPictureParams import android.content.Intent +import android.os.Build +import android.util.Rational import android.widget.Toast import androidx.annotation.OptIn +import androidx.compose.animation.core.Animatable +import androidx.compose.animation.core.spring +import androidx.compose.animation.core.tween import androidx.compose.foundation.background import androidx.compose.foundation.clickable +import androidx.compose.foundation.gestures.detectVerticalDragGestures import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Column @@ -30,6 +38,8 @@ import androidx.compose.foundation.shape.CircleShape import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.foundation.verticalScroll import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.Headphones +import androidx.compose.material.icons.filled.PictureInPictureAlt import androidx.compose.material.icons.filled.PlayArrow import androidx.compose.material3.AlertDialog import androidx.compose.material3.AssistChip @@ -50,19 +60,25 @@ import androidx.compose.runtime.collectAsState import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope import androidx.compose.runtime.setValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.draw.clip import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.graphicsLayer +import androidx.compose.ui.input.pointer.pointerInput import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.platform.LocalDensity import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.text.style.TextOverflow import androidx.compose.ui.unit.dp import androidx.compose.ui.viewinterop.AndroidView import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.lifecycle.viewmodel.compose.viewModel +import androidx.media3.common.C import androidx.media3.common.Player +import androidx.media3.common.TrackSelectionParameters import androidx.media3.common.util.UnstableApi import androidx.media3.ui.PlayerView import coil3.compose.AsyncImage @@ -79,28 +95,51 @@ import com.sulkta.straw.feature.search.StreamItem import com.sulkta.straw.util.formatCount import com.sulkta.straw.util.formatViews import com.sulkta.straw.util.stripHtml +import kotlinx.coroutines.launch -@OptIn(ExperimentalLayoutApi::class) +@OptIn(ExperimentalLayoutApi::class, UnstableApi::class) @Composable fun VideoDetailScreen( streamUrl: String, initialTitle: String, onPlay: () -> Unit, + onMinimize: () -> Unit, onOpenChannel: (channelUrl: String, name: String) -> Unit, onOpenVideo: (url: String, title: String) -> Unit, vm: VideoDetailViewModel = viewModel(), ) { val state by vm.ui.collectAsStateWithLifecycle() val context = LocalContext.current + val controller = LocalStrawController.current + val activity = context as? Activity var showDownloadDialog by remember { mutableStateOf(false) } var showSaveToPlaylistDialog by remember { mutableStateOf(false) } // Inline-play state resets when navigating to a different video. var inlinePlaying by remember(streamUrl) { mutableStateOf(false) } LaunchedEffect(streamUrl) { vm.load(streamUrl) } + // Swipe-down to minimize. The drag handle is the inline player surface + // (the 16:9 box at the top); we translate the WHOLE page with it so the + // motion reads as "the video is being tucked away" rather than "this + // one widget slid." The graphicsLayer + alpha/scale fade keeps it + // smooth — no per-pixel coroutine churn from offset { }. + val density = LocalDensity.current + val dismissThresholdPx = with(density) { 140.dp.toPx() } + val dragY = remember { Animatable(0f) } + val scope = rememberCoroutineScope() + Column( modifier = Modifier .fillMaxSize() + .graphicsLayer { + val y = dragY.value + translationY = y + val p = (y / dismissThresholdPx).coerceIn(0f, 1f) + alpha = 1f - p * 0.4f + val s = 1f - p * 0.08f + scaleX = s + scaleY = s + } .statusBarsPadding() .verticalScroll(rememberScrollState()) .padding(16.dp), @@ -118,6 +157,33 @@ fun VideoDetailScreen( else -> { val d = state.detail ?: return@Column + // Drag-to-minimize gesture lives on the player surface + // itself — same pattern YouTube/NewPipe use. Outside the + // 16:9 box the page scrolls normally, so the drag never + // fights with description scrolling. + val playerDragModifier = Modifier.pointerInput(Unit) { + detectVerticalDragGestures( + onDragEnd = { + if (dragY.value > dismissThresholdPx) { + onMinimize() + } else { + scope.launch { + dragY.animateTo(0f, spring()) + } + } + }, + onDragCancel = { + scope.launch { dragY.animateTo(0f, spring()) } + }, + onVerticalDrag = { _, dy -> + scope.launch { + dragY.snapTo( + (dragY.value + dy).coerceAtLeast(0f), + ) + } + }, + ) + } if (inlinePlaying) { InlinePlayer( streamUrl = streamUrl, @@ -129,7 +195,8 @@ fun VideoDetailScreen( .fillMaxWidth() .aspectRatio(16f / 9f) .clip(RoundedCornerShape(8.dp)) - .background(Color.Black), + .background(Color.Black) + .then(playerDragModifier), ) } else { Box( @@ -137,7 +204,8 @@ fun VideoDetailScreen( .fillMaxWidth() .aspectRatio(16f / 9f) .clip(RoundedCornerShape(8.dp)) - .clickable { inlinePlaying = true }, + .clickable { inlinePlaying = true } + .then(playerDragModifier), contentAlignment = Alignment.Center, ) { AsyncImage( @@ -219,6 +287,94 @@ fun VideoDetailScreen( verticalArrangement = Arrangement.spacedBy(8.dp), ) { Button(onClick = onPlay) { Text("Play") } + OutlinedButton( + onClick = { + val c = controller + if (c == null) { + Toast.makeText(context, "no player", Toast.LENGTH_SHORT).show() + return@OutlinedButton + } + // Make sure the controller is playing this video + // before backing out — otherwise dropping to the + // minibar would dismiss into an empty slot. + if (NowPlaying.current.value?.streamUrl != streamUrl) { + val r = state.resolved + if (r == null) { + Toast.makeText(context, "stream not ready", Toast.LENGTH_SHORT).show() + return@OutlinedButton + } + c.setPlayingFrom( + streamUrl = streamUrl, + title = d.title, + uploader = d.uploader, + thumbnail = d.thumbnail, + resolved = r, + ) + } + // Audio-only: drop video track. Foreground + // service keeps the audio going; minibar takes + // over once we pop off the detail screen. + c.trackSelectionParameters = TrackSelectionParameters.Builder(context) + .setTrackTypeDisabled(C.TRACK_TYPE_VIDEO, true) + .build() + if (!c.isPlaying) c.play() + onMinimize() + }, + ) { + Icon( + imageVector = Icons.Filled.Headphones, + contentDescription = null, + modifier = Modifier.size(18.dp), + ) + Spacer(modifier = Modifier.width(6.dp)) + Text("Background") + } + OutlinedButton( + onClick = { + if (activity == null) { + Toast.makeText(context, "PiP: no activity", Toast.LENGTH_SHORT).show() + return@OutlinedButton + } + if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) { + Toast.makeText(context, "PiP needs Android 8+", Toast.LENGTH_SHORT).show() + return@OutlinedButton + } + // PiP needs the controller to actually be playing + // this video, same as Background — otherwise we + // pop out into nothing. + val c = controller + if (c != null && NowPlaying.current.value?.streamUrl != streamUrl) { + val r = state.resolved + if (r != null) { + c.setPlayingFrom( + streamUrl = streamUrl, + title = d.title, + uploader = d.uploader, + thumbnail = d.thumbnail, + resolved = r, + ) + } + } + val params = PictureInPictureParams.Builder() + .setAspectRatio(Rational(16, 9)) + .build() + runCatching { activity.enterPictureInPictureMode(params) } + .onSuccess { ok -> + if (!ok) Toast.makeText(context, "PiP refused", Toast.LENGTH_LONG).show() + } + .onFailure { t -> + Toast.makeText(context, "PiP failed: ${t.message}", Toast.LENGTH_LONG).show() + } + }, + ) { + Icon( + imageVector = Icons.Filled.PictureInPictureAlt, + contentDescription = null, + modifier = Modifier.size(18.dp), + ) + Spacer(modifier = Modifier.width(6.dp)) + Text("Popout") + } OutlinedButton(onClick = { val send = Intent(Intent.ACTION_SEND).apply { type = "text/plain" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt index cdc2fa39a..4266cf34b 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt @@ -4,10 +4,12 @@ * * Fullscreen player surface. The player itself lives in PlaybackService * (one ExoPlayer for the whole app); this composable is a thin shell that - * renders a PlayerView bound to the shared MediaController, lets the user - * drag down to dismiss into the minibar, and overlays speed / audio-only - * / share / PiP / minimize controls. SponsorBlock auto-skip lives at the - * activity root in [SponsorBlockSkipLoop]. + * renders a PlayerView bound to the shared MediaController and overlays + * speed / audio-only / share / PiP / minimize controls. To minimize, tap + * the down-arrow button (top right) — the swipe-down gesture lives on + * the VideoDetail page instead, where it doesn't fight PlayerView's own + * touch handling. SponsorBlock auto-skip lives at the activity root in + * [SponsorBlockSkipLoop]. */ package com.sulkta.straw.feature.player @@ -19,17 +21,13 @@ import android.os.Build import android.util.Rational import android.widget.Toast import androidx.annotation.OptIn -import androidx.compose.animation.core.Animatable -import androidx.compose.animation.core.tween import androidx.compose.foundation.background import androidx.compose.foundation.clickable -import androidx.compose.foundation.gestures.detectVerticalDragGestures import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.fillMaxSize -import androidx.compose.foundation.layout.offset import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.size import androidx.compose.foundation.shape.RoundedCornerShape @@ -53,16 +51,12 @@ import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember -import androidx.compose.runtime.rememberCoroutineScope import androidx.compose.runtime.setValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.draw.clip import androidx.compose.ui.graphics.Color -import androidx.compose.ui.input.pointer.pointerInput import androidx.compose.ui.platform.LocalContext -import androidx.compose.ui.platform.LocalDensity -import androidx.compose.ui.unit.IntOffset import androidx.compose.ui.unit.dp import androidx.compose.ui.viewinterop.AndroidView import androidx.lifecycle.compose.collectAsStateWithLifecycle @@ -77,9 +71,7 @@ import com.sulkta.straw.OverlayChromeColor import com.sulkta.straw.feature.detail.VideoDetailViewModel import com.sulkta.straw.net.SbSegment import com.sulkta.straw.util.strawLogI -import kotlin.math.roundToInt import kotlinx.coroutines.delay -import kotlinx.coroutines.launch @OptIn(UnstableApi::class) @Composable @@ -98,13 +90,6 @@ fun PlayerScreen( var audioOnly by remember { mutableStateOf(false) } var showSpeedDialog by remember { mutableStateOf(false) } - // Drag-to-minimize: vertical offset accumulated during the gesture. - // On release past the threshold we dismiss into the minibar. - val density = LocalDensity.current - val dismissThresholdPx = with(density) { 200.dp.toPx() } - val dragY = remember { Animatable(0f) } - val scope = rememberCoroutineScope() - // When the resolved playback for this URL is ready, push it into the // shared controller — unless it's already playing this exact URL, in // which case do nothing: the player is already where we want it. The @@ -144,28 +129,7 @@ fun PlayerScreen( val activity = context as? Activity Box( - modifier = Modifier - .fillMaxSize() - .offset { IntOffset(0, dragY.value.roundToInt()) } - .pointerInput(Unit) { - detectVerticalDragGestures( - onDragEnd = { - if (dragY.value > dismissThresholdPx) { - onMinimize() - } else { - scope.launch { dragY.animateTo(0f, tween(180)) } - } - }, - onDragCancel = { - scope.launch { dragY.animateTo(0f, tween(180)) } - }, - onVerticalDrag = { _, dy -> - scope.launch { - dragY.snapTo((dragY.value + dy).coerceAtLeast(0f)) - } - }, - ) - }, + modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center, ) { when { From 2e339814fde397de890cd637fef8ec3fbe44e376 Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 11:43:38 -0700 Subject: [PATCH 12/72] vc=28: edge-to-edge player, nav-bar inset, video-track reset, app icon MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Three layout/playback fixes on vc=26-27 feedback plus the long-deferred app icon. Layout — VideoDetailScreen Player surface now fills the screen width (no 16dp side gutters). Outer Column dropped its 16dp padding; the player Box hangs off the full width with no rounded corners — NewPipe/YouTube look. Everything below (title, chips, button row, description, related list) goes back into an inner Column with 16dp horizontal + 12dp vertical padding so the body still reads correctly. Bottom inset: Spacer(windowInsetsBottomHeight(WindowInsets.navigationBars)) appended at the end of the scrollable column. Last related video can scroll up past the gesture pill / 3-button nav instead of being obscured by it. (Plain navigationBarsPadding would have pushed the whole surface up and left a dead band.) Black-video fix vc=27's Background button disabled the video track on the controller via setTrackTypeDisabled(C.TRACK_TYPE_VIDEO, true) and that override is sticky. Returning to a video left it audio-only with a black surface. Added a LaunchedEffect(controller, streamUrl) that resets TrackSelectionParameters to defaults on every entry into detail — if the user opened a video page, they want video. The audio-only fullscreen toggle and the Background button still set the override for the duration of that session; they just no longer leak. App icon Replaced the Android default placeholder (sym_def_app_icon, which fdroid was failing to render anyway) with a proper adaptive icon: Background: #166534 deep green (sulkta.com brand) Foreground: tilted lime parallelogram + white play triangle (literal "straw" nod + video-app affordance) Adaptive XML in mipmap-anydpi-v26/. PNG fallbacks rendered via rsvg-convert at all five mipmap densities (mdpi/hdpi/xhdpi/xxhdpi/ xxxhdpi) for pre-API-26 devices. Manifest now points at @mipmap/ic_launcher and @mipmap/ic_launcher_round. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- strawApp/src/main/AndroidManifest.xml | 4 +- .../straw/feature/detail/VideoDetailScreen.kt | 84 +++++++++++------- .../res/drawable/ic_launcher_background.xml | 5 ++ .../res/drawable/ic_launcher_foreground.xml | 25 ++++++ .../res/mipmap-anydpi-v26/ic_launcher.xml | 5 ++ .../mipmap-anydpi-v26/ic_launcher_round.xml | 5 ++ .../src/main/res/mipmap-hdpi/ic_launcher.png | Bin 0 -> 987 bytes .../res/mipmap-hdpi/ic_launcher_round.png | Bin 0 -> 987 bytes .../src/main/res/mipmap-mdpi/ic_launcher.png | Bin 0 -> 740 bytes .../res/mipmap-mdpi/ic_launcher_round.png | Bin 0 -> 740 bytes .../src/main/res/mipmap-xhdpi/ic_launcher.png | Bin 0 -> 1355 bytes .../res/mipmap-xhdpi/ic_launcher_round.png | Bin 0 -> 1355 bytes .../main/res/mipmap-xxhdpi/ic_launcher.png | Bin 0 -> 1809 bytes .../res/mipmap-xxhdpi/ic_launcher_round.png | Bin 0 -> 1809 bytes .../main/res/mipmap-xxxhdpi/ic_launcher.png | Bin 0 -> 2477 bytes .../res/mipmap-xxxhdpi/ic_launcher_round.png | Bin 0 -> 2477 bytes 17 files changed, 94 insertions(+), 38 deletions(-) create mode 100644 strawApp/src/main/res/drawable/ic_launcher_background.xml create mode 100644 strawApp/src/main/res/drawable/ic_launcher_foreground.xml create mode 100644 strawApp/src/main/res/mipmap-anydpi-v26/ic_launcher.xml create mode 100644 strawApp/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml create mode 100644 strawApp/src/main/res/mipmap-hdpi/ic_launcher.png create mode 100644 strawApp/src/main/res/mipmap-hdpi/ic_launcher_round.png create mode 100644 strawApp/src/main/res/mipmap-mdpi/ic_launcher.png create mode 100644 strawApp/src/main/res/mipmap-mdpi/ic_launcher_round.png create mode 100644 strawApp/src/main/res/mipmap-xhdpi/ic_launcher.png create mode 100644 strawApp/src/main/res/mipmap-xhdpi/ic_launcher_round.png create mode 100644 strawApp/src/main/res/mipmap-xxhdpi/ic_launcher.png create mode 100644 strawApp/src/main/res/mipmap-xxhdpi/ic_launcher_round.png create mode 100644 strawApp/src/main/res/mipmap-xxxhdpi/ic_launcher.png create mode 100644 strawApp/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index a20dca091..225345b66 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 27 -const val STRAW_VERSION_NAME = "0.1.0-AM" +const val STRAW_VERSION_CODE = 28 +const val STRAW_VERSION_NAME = "0.1.0-AN" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/AndroidManifest.xml b/strawApp/src/main/AndroidManifest.xml index 46abc05b7..87ff57336 100644 --- a/strawApp/src/main/AndroidManifest.xml +++ b/strawApp/src/main/AndroidManifest.xml @@ -14,8 +14,8 @@ diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index 7b552764e..502314b25 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -25,14 +25,17 @@ import androidx.compose.foundation.layout.ExperimentalLayoutApi import androidx.compose.foundation.layout.FlowRow import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.WindowInsets import androidx.compose.foundation.layout.aspectRatio import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.navigationBars import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.size import androidx.compose.foundation.layout.statusBarsPadding import androidx.compose.foundation.layout.width +import androidx.compose.foundation.layout.windowInsetsBottomHeight import androidx.compose.foundation.rememberScrollState import androidx.compose.foundation.shape.CircleShape import androidx.compose.foundation.shape.RoundedCornerShape @@ -118,6 +121,16 @@ fun VideoDetailScreen( var inlinePlaying by remember(streamUrl) { mutableStateOf(false) } LaunchedEffect(streamUrl) { vm.load(streamUrl) } + // The Background button (and the fullscreen audio-only toggle) + // disable the video track on the shared controller, and that state + // sticks. Entering detail = user wants to watch the video — wipe the + // override and let DASH pick the highest renderable video again. + LaunchedEffect(controller, streamUrl) { + controller?.let { + it.trackSelectionParameters = TrackSelectionParameters.Builder(context).build() + } + } + // Swipe-down to minimize. The drag handle is the inline player surface // (the 16:9 box at the top); we translate the WHOLE page with it so the // motion reads as "the video is being tucked away" rather than "this @@ -127,6 +140,25 @@ fun VideoDetailScreen( val dismissThresholdPx = with(density) { 140.dp.toPx() } val dragY = remember { Animatable(0f) } val scope = rememberCoroutineScope() + val playerDragModifier = Modifier.pointerInput(Unit) { + detectVerticalDragGestures( + onDragEnd = { + if (dragY.value > dismissThresholdPx) { + onMinimize() + } else { + scope.launch { dragY.animateTo(0f, spring()) } + } + }, + onDragCancel = { + scope.launch { dragY.animateTo(0f, spring()) } + }, + onVerticalDrag = { _, dy -> + scope.launch { + dragY.snapTo((dragY.value + dy).coerceAtLeast(0f)) + } + }, + ) + } Column( modifier = Modifier @@ -141,49 +173,27 @@ fun VideoDetailScreen( scaleY = s } .statusBarsPadding() - .verticalScroll(rememberScrollState()) - .padding(16.dp), + .verticalScroll(rememberScrollState()), ) { when { state.loading -> Box( - modifier = Modifier.fillMaxWidth().padding(top = 64.dp), + modifier = Modifier + .fillMaxWidth() + .padding(top = 64.dp), contentAlignment = Alignment.Center, ) { CircularProgressIndicator() } state.error != null -> Text( "error: ${state.error}", color = MaterialTheme.colorScheme.error, + modifier = Modifier.padding(16.dp), ) else -> { val d = state.detail ?: return@Column - // Drag-to-minimize gesture lives on the player surface - // itself — same pattern YouTube/NewPipe use. Outside the - // 16:9 box the page scrolls normally, so the drag never - // fights with description scrolling. - val playerDragModifier = Modifier.pointerInput(Unit) { - detectVerticalDragGestures( - onDragEnd = { - if (dragY.value > dismissThresholdPx) { - onMinimize() - } else { - scope.launch { - dragY.animateTo(0f, spring()) - } - } - }, - onDragCancel = { - scope.launch { dragY.animateTo(0f, spring()) } - }, - onVerticalDrag = { _, dy -> - scope.launch { - dragY.snapTo( - (dragY.value + dy).coerceAtLeast(0f), - ) - } - }, - ) - } + // Player surface — edge-to-edge, NewPipe/YouTube style. + // Lives outside the 16dp horizontal padding so the + // thumbnail fills the screen width with no gutters. if (inlinePlaying) { InlinePlayer( streamUrl = streamUrl, @@ -194,7 +204,6 @@ fun VideoDetailScreen( modifier = Modifier .fillMaxWidth() .aspectRatio(16f / 9f) - .clip(RoundedCornerShape(8.dp)) .background(Color.Black) .then(playerDragModifier), ) @@ -203,7 +212,7 @@ fun VideoDetailScreen( modifier = Modifier .fillMaxWidth() .aspectRatio(16f / 9f) - .clip(RoundedCornerShape(8.dp)) + .background(Color.Black) .clickable { inlinePlaying = true } .then(playerDragModifier), contentAlignment = Alignment.Center, @@ -229,8 +238,9 @@ fun VideoDetailScreen( } } } - Spacer(modifier = Modifier.height(12.dp)) - + // Everything below the player gets the side gutters + // back; player itself remains edge-to-edge. + Column(modifier = Modifier.padding(horizontal = 16.dp, vertical = 12.dp)) { Text( text = d.title, style = MaterialTheme.typography.titleLarge, @@ -492,8 +502,14 @@ fun VideoDetailScreen( }, ) } + } // close inner Column (padded body) } } + // Leave room at the bottom for the system nav bar so the last + // related video doesn't tuck under the gesture pill / 3-button + // nav. Compose's `navigationBarsPadding` would push the whole + // surface up; we want the scroll to extend past it instead. + Spacer(modifier = Modifier.windowInsetsBottomHeight(WindowInsets.navigationBars)) } } diff --git a/strawApp/src/main/res/drawable/ic_launcher_background.xml b/strawApp/src/main/res/drawable/ic_launcher_background.xml new file mode 100644 index 000000000..7d786ca64 --- /dev/null +++ b/strawApp/src/main/res/drawable/ic_launcher_background.xml @@ -0,0 +1,5 @@ + + + + diff --git a/strawApp/src/main/res/drawable/ic_launcher_foreground.xml b/strawApp/src/main/res/drawable/ic_launcher_foreground.xml new file mode 100644 index 000000000..9bb57a385 --- /dev/null +++ b/strawApp/src/main/res/drawable/ic_launcher_foreground.xml @@ -0,0 +1,25 @@ + + + + + + + + diff --git a/strawApp/src/main/res/mipmap-anydpi-v26/ic_launcher.xml b/strawApp/src/main/res/mipmap-anydpi-v26/ic_launcher.xml new file mode 100644 index 000000000..6b78462d6 --- /dev/null +++ b/strawApp/src/main/res/mipmap-anydpi-v26/ic_launcher.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/strawApp/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml b/strawApp/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml new file mode 100644 index 000000000..6b78462d6 --- /dev/null +++ b/strawApp/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/strawApp/src/main/res/mipmap-hdpi/ic_launcher.png b/strawApp/src/main/res/mipmap-hdpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..c8f3906f9b9faa3c8659b6a600e32c9e5be5082d GIT binary patch literal 987 zcmV<110?*3P)7l-Tg>9vTe6WkVN8(H0c9I6g?ebxRiL%8zo(_9pIhm} z^X(^j==1UmD17fK@jqfS`T=lZiJ1*c%xqXaup5{izjK|d)=Q~;IrXc- z)?hm~Ow1b#y2kmunX;0Bx3?USnKCjTA zu$BP{(p$_o8FqM_a(DSwo7p@B3DR4POenoJO1pXPqz)3KtC)RgFmNfX(11?Dj6*_a zvC#B5vdJbk*jnX#0V+#ZF>*%fwZW_(@NFI{3zt}QxO2$4qr8^lbKX!||v><6<%mn~r_kBIvFD z+egen4%M?Xzccr z$lWWhi_*_&h*fU~1}uU*^lHp;HOqjf7QQun0GqweF!=aw${Blp^FhbN0774! zD@rE@s6P8bOaNA|kHiF^^!iQ=3L}rWd$N*Rd$RcA%l3-Ke)>oZN=X2h7?MAS>IPOx z0GF7;iH#H-N&>jV2K_GO2KbZ&u!s$Kop$-E!d5Nw_}#PjOCNDWi(nB8&W!i`jS1V9 zmE7j~=TA6trC<>YO?RFGNOxj%GR^ZCmc4%hFXoK}T_KNn*|E9gd7fU+f`@hkFD8~M zd+wLneY#OT0T1m4SWGNczGOboT&24K;92iqo&>f#u~ga9s#R~6cJi=^asZ3zP^wf3 zq?kUXN|iv0g%U9xN|h=B6GI4fPhV1?N|h=B6Z1`m2fTWeDpdj|rd+B#+RZ_gDpdj| zcARC{Oi^yFq~~ix0BnNJE$`))_iO`p??fm-jrysxkqKL>R0;6Pqut=jseCz=ClE0- z>i1t5@lB3Y(?!5irAma_zeSEVxB$t@-P4Z002ov JPDHLkV1jmc(98e; literal 0 HcmV?d00001 diff --git a/strawApp/src/main/res/mipmap-hdpi/ic_launcher_round.png b/strawApp/src/main/res/mipmap-hdpi/ic_launcher_round.png new file mode 100644 index 0000000000000000000000000000000000000000..c8f3906f9b9faa3c8659b6a600e32c9e5be5082d GIT binary patch literal 987 zcmV<110?*3P)7l-Tg>9vTe6WkVN8(H0c9I6g?ebxRiL%8zo(_9pIhm} z^X(^j==1UmD17fK@jqfS`T=lZiJ1*c%xqXaup5{izjK|d)=Q~;IrXc- z)?hm~Ow1b#y2kmunX;0Bx3?USnKCjTA zu$BP{(p$_o8FqM_a(DSwo7p@B3DR4POenoJO1pXPqz)3KtC)RgFmNfX(11?Dj6*_a zvC#B5vdJbk*jnX#0V+#ZF>*%fwZW_(@NFI{3zt}QxO2$4qr8^lbKX!||v><6<%mn~r_kBIvFD z+egen4%M?Xzccr z$lWWhi_*_&h*fU~1}uU*^lHp;HOqjf7QQun0GqweF!=aw${Blp^FhbN0774! zD@rE@s6P8bOaNA|kHiF^^!iQ=3L}rWd$N*Rd$RcA%l3-Ke)>oZN=X2h7?MAS>IPOx z0GF7;iH#H-N&>jV2K_GO2KbZ&u!s$Kop$-E!d5Nw_}#PjOCNDWi(nB8&W!i`jS1V9 zmE7j~=TA6trC<>YO?RFGNOxj%GR^ZCmc4%hFXoK}T_KNn*|E9gd7fU+f`@hkFD8~M zd+wLneY#OT0T1m4SWGNczGOboT&24K;92iqo&>f#u~ga9s#R~6cJi=^asZ3zP^wf3 zq?kUXN|iv0g%U9xN|h=B6GI4fPhV1?N|h=B6Z1`m2fTWeDpdj|rd+B#+RZ_gDpdj| zcARC{Oi^yFq~~ix0BnNJE$`))_iO`p??fm-jrysxkqKL>R0;6Pqut=jseCz=ClE0- z>i1t5@lB3Y(?!5irAma_zeSEVxB$t@-P4Z002ov JPDHLkV1jmc(98e; literal 0 HcmV?d00001 diff --git a/strawApp/src/main/res/mipmap-mdpi/ic_launcher.png b/strawApp/src/main/res/mipmap-mdpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..fcfab8700211002e656f1e323500fa314802beda GIT binary patch literal 740 zcmV^nG9!0O7 z^empd@1Q499Ak$KREA8LAj~gh2r|Kq&SioYOI^FQUDGuwZPzquJOpaZDru6pi--JA z%|m$dj6(B|~0+z1PKXb)z`{fkXWe3Qwj0pKri>Y;K#qGWeqwb)m`woyn-bg@N5(J7& zci#af2=ls~{(ec3Nm2E~sy-lJ^w{zMP>Am;Y61;}AP5nbg7|u)^dqYe2tPAuaoQwB ziri~9czr#(*T+AxSsp!y?c_{2Sy>RnhYs>2o5+iPTrL3M$ zjIoL6%(XjHW0PIp4}W58&)#AF;p@ePwdHz)?Kud6P0QG!#qroa|m|~o?5GHw-@PTo-H3~2dOz2J)MU` z2+IRhfDjW(g#3~sS7S?wygs1*vqNUPRZ^t3(*mz-n1=@HJj`#wd0#*UsPHvi+{tjY zKSy6BOIPy@ERf=FS&_^X$qa%bj^Vz(aUVW5P}ov4%>OHh@jtap43Jz5kX#IqTz&(M WZvJ&>7YL020000^nG9!0O7 z^empd@1Q499Ak$KREA8LAj~gh2r|Kq&SioYOI^FQUDGuwZPzquJOpaZDru6pi--JA z%|m$dj6(B|~0+z1PKXb)z`{fkXWe3Qwj0pKri>Y;K#qGWeqwb)m`woyn-bg@N5(J7& zci#af2=ls~{(ec3Nm2E~sy-lJ^w{zMP>Am;Y61;}AP5nbg7|u)^dqYe2tPAuaoQwB ziri~9czr#(*T+AxSsp!y?c_{2Sy>RnhYs>2o5+iPTrL3M$ zjIoL6%(XjHW0PIp4}W58&)#AF;p@ePwdHz)?Kud6P0QG!#qroa|m|~o?5GHw-@PTo-H3~2dOz2J)MU` z2+IRhfDjW(g#3~sS7S?wygs1*vqNUPRZ^t3(*mz-n1=@HJj`#wd0#*UsPHvi+{tjY zKSy6BOIPy@ERf=FS&_^X$qa%bj^Vz(aUVW5P}ov4%>OHh@jtap43Jz5kX#IqTz&(M WZvJ&>7YL0200000Xz-GbXQ>yrg-Vm!V==>xyy4 z@-mybi}KbaA}5_>8KE4C8p5em$a2?z_ndpqJW!&e4q3D^(i__a@JJWR|fz< zljwr?QfTncR8v;e*sa-kg{X$QIpcwypTQ9~Facl}K*ZyG(%38P;dq#n!Q;q@lAsGP ztS#@wONur;`pR2)&Lx#1EXc&f2#PDChpZ>V5B@Ve4^Vx^_4~D)8}dA$kEHB>+<1e9>(dZk%K`k$d5D2*+=z8msEY} z5XatKCbKkX0#2<14muB2KBT6!KQH?~ZTk8Yg`eSoH0xxpJy)>RCvRP|Yn~B) z(0($#=~~ZeM>%p^4-H{;z7FN|#9t$>W?_FL9L!*JR|-#g5oUnp{giZ*9Dx@8NCIKC zt>|)Lxvps!doIcM8-v^5%1LIRY~HOK%$|3Q^)sPPzK#ol%X^ zOPzVJTTU9N!He3_g4qMU`%nnCV*#{m??28@ADB?((m=REgIhl|=Kh{)3MXWxuJtu? zW9H>w{RnU5^d$)ixaos|qTp=lgpQG5u_~rS2zpP$FWFZBju!bCqs~D{qYivhNVK zx0MCpz3k9=9f6d>_vJ76NaO$?R98Rpm3s07W^uhEp@budu#7QR=7XpoA1<&wgb&hJ z`$Q8FPo+GHF2<#qR2njAnKD1+%Xw{%F51Zjt(#c4rg}_zTazIJ_tw zU|pbenil%&s*ngZ3BRas zX;U$L5qZXS#(jmf|Tpi9;9DTOiCg>CwU z2X~Ens)z{Cz-aCsl+;0>Woj?#Id-zR{=zUeOTLJiNJ5BT+XUa@h<4yZ2s9J|>g+%D zFbBOO(V%WN=DsUWba9~4JU6WTx$YRoKIM!ifT|5EKdUnaGhF7X0uBf43&7`a*XLVhFX3qD zR^{hh4x$le`2F72_mwGePc+ah(=%HK5k-u(G3=fE2id5Xw#KjO48zwG+E=WDY{=EBeCH#BQv%_K>S}{$;dE@O|?^T0}E9u zZ-|fk&op8;-aLY|zNNFwIvbd5Xb#rn(y<-p2E^`vaq=(9Y`_v&I!mK_S)mF#0z@Yg JUg#K1`v-WEY~KI? literal 0 HcmV?d00001 diff --git a/strawApp/src/main/res/mipmap-xhdpi/ic_launcher_round.png b/strawApp/src/main/res/mipmap-xhdpi/ic_launcher_round.png new file mode 100644 index 0000000000000000000000000000000000000000..717e67c8cf3c1db79d750e434ede4f7e94fcde80 GIT binary patch literal 1355 zcmaKseKgYx7{`BDGUGOd9P={w$jhjfHj7?nnlUnY>0Xz-GbXQ>yrg-Vm!V==>xyy4 z@-mybi}KbaA}5_>8KE4C8p5em$a2?z_ndpqJW!&e4q3D^(i__a@JJWR|fz< zljwr?QfTncR8v;e*sa-kg{X$QIpcwypTQ9~Facl}K*ZyG(%38P;dq#n!Q;q@lAsGP ztS#@wONur;`pR2)&Lx#1EXc&f2#PDChpZ>V5B@Ve4^Vx^_4~D)8}dA$kEHB>+<1e9>(dZk%K`k$d5D2*+=z8msEY} z5XatKCbKkX0#2<14muB2KBT6!KQH?~ZTk8Yg`eSoH0xxpJy)>RCvRP|Yn~B) z(0($#=~~ZeM>%p^4-H{;z7FN|#9t$>W?_FL9L!*JR|-#g5oUnp{giZ*9Dx@8NCIKC zt>|)Lxvps!doIcM8-v^5%1LIRY~HOK%$|3Q^)sPPzK#ol%X^ zOPzVJTTU9N!He3_g4qMU`%nnCV*#{m??28@ADB?((m=REgIhl|=Kh{)3MXWxuJtu? zW9H>w{RnU5^d$)ixaos|qTp=lgpQG5u_~rS2zpP$FWFZBju!bCqs~D{qYivhNVK zx0MCpz3k9=9f6d>_vJ76NaO$?R98Rpm3s07W^uhEp@budu#7QR=7XpoA1<&wgb&hJ z`$Q8FPo+GHF2<#qR2njAnKD1+%Xw{%F51Zjt(#c4rg}_zTazIJ_tw zU|pbenil%&s*ngZ3BRas zX;U$L5qZXS#(jmf|Tpi9;9DTOiCg>CwU z2X~Ens)z{Cz-aCsl+;0>Woj?#Id-zR{=zUeOTLJiNJ5BT+XUa@h<4yZ2s9J|>g+%D zFbBOO(V%WN=DsUWba9~4JU6WTx$YRoKIM!ifT|5EKdUnaGhF7X0uBf43&7`a*XLVhFX3qD zR^{hh4x$le`2F72_mwGePc+ah(=%HK5k-u(G3=fE2id5Xw#KjO48zwG+E=WDY{=EBeCH#BQv%_K>S}{$;dE@O|?^T0}E9u zZ-|fk&op8;-aLY|zNNFwIvbd5Xb#rn(y<-p2E^`vaq=(9Y`_v&I!mK_S)mF#0z@Yg JUg#K1`v-WEY~KI? literal 0 HcmV?d00001 diff --git a/strawApp/src/main/res/mipmap-xxhdpi/ic_launcher.png b/strawApp/src/main/res/mipmap-xxhdpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..455be2a69ba7453ef56a9f1e6f1f46b9546bb285 GIT binary patch literal 1809 zcmb7Fc{m%`7FR@KYrW1`Dos_HMy;t1QktN)+7hLf1|!9nmYGS=;ZY5mSh`r+YG@*K z(T0qsG`6ZG!U!hHH`J1n7A@6@SfZpU;-xcx%s=ms_rCj``}^+i-gEA`_ndprwE&ct zwuYgGl9H0P_bK;41>XEBAZ0~=!8CbU0cz2{UhYaeU)%lms$vDf^LBSVlS&s0`2?`X z{?5eOcN3`n&ahWq@SXS$|bjxWS%7Qs*-fYFUj}Eu&s&UBkDe?q-4tof~oV=#B1g7{*jx*SB`v!8Z>|T}gFLBxFsdz-B zO|a@#U~x!1e1GAh?VTtNEp|7<%;&S=PHmLeq#$Pf)b!=-o5#ZzhI2CR<)y=` z|5|~YpHHg9IEVSG)AP-S)kM-X+GsbzeO8{Y*Z9(C1Q zY@GP5$cVT;(i_F$tl(S6;ligg7BN#h?sAV8DX9a9tu|v#p5=FX9NEfRilFOaB@r)& z(t=?QrQs*{<;Rs;MbB>6WkkIE`H??byx({?Z-JebN0eWKNzp-}DGlG~?3rvZ>BoUe z#H*eX`CzTc=gQ`XY73pxN>s6_LH(Vu2p>zN6=C~k=1O(Lm}q78hmJeQ6Ghk5O@m?c zzy4cNDAn__w^J9*C;9GGi@EfYF$xw`>4c^yKhowI45ieSC^yTJ-M$*)B;lSE-NtLn5rU6 z$H=&*ve1$zG!=jwkKr41`2fL`^I5iJ!{?lZ12u4<>@!*bkuu6Wm(&Qb(skovvZ&V| zV9&dtdIIW7r>mmP3}|QaS>zd?o`ah61zPH|;|4)T`$#ey$+F+M6-G1+aPdWCN1_~S z(ZWG)Zuqt_4g9!@5TNvj;_cGuVtM;AHY3yr4FkNJzz8m58x(P1k>6nAbZFRiJnI!= zQZw_%$F3Jh9(qs+uS39?8(CXv4l&F&x%<%UUn)_L#_^dN*A+K217bKeN`lLq_db|V zXcuB39j9tVID}=mh4x9ECqgDgt+_i|pqL_IXVSKr6vWT)A(!n#2qcJ9EY8%IDcZwc^Eppc8N`J$}yi`PZ%V2i`L& z64u6_S(^4bYfh;)w<^Uy9q-B5EnpVMRWDiq|N9MYpfPjXQx?4TP>R$|6y|-vR#}u>v^fg(p-wsljQcr z&I-j*7O+(xty?=qe_#(Gzei5B{ms&_{xA8~>j{;aePDVa02lpc`rw4Z!@${QLKp%# ntdd|P@;?86eEk2dOl$!s6W1};0Z$thHBQOf1LgkoB$o6aJD_A_ literal 0 HcmV?d00001 diff --git a/strawApp/src/main/res/mipmap-xxhdpi/ic_launcher_round.png b/strawApp/src/main/res/mipmap-xxhdpi/ic_launcher_round.png new file mode 100644 index 0000000000000000000000000000000000000000..455be2a69ba7453ef56a9f1e6f1f46b9546bb285 GIT binary patch literal 1809 zcmb7Fc{m%`7FR@KYrW1`Dos_HMy;t1QktN)+7hLf1|!9nmYGS=;ZY5mSh`r+YG@*K z(T0qsG`6ZG!U!hHH`J1n7A@6@SfZpU;-xcx%s=ms_rCj``}^+i-gEA`_ndprwE&ct zwuYgGl9H0P_bK;41>XEBAZ0~=!8CbU0cz2{UhYaeU)%lms$vDf^LBSVlS&s0`2?`X z{?5eOcN3`n&ahWq@SXS$|bjxWS%7Qs*-fYFUj}Eu&s&UBkDe?q-4tof~oV=#B1g7{*jx*SB`v!8Z>|T}gFLBxFsdz-B zO|a@#U~x!1e1GAh?VTtNEp|7<%;&S=PHmLeq#$Pf)b!=-o5#ZzhI2CR<)y=` z|5|~YpHHg9IEVSG)AP-S)kM-X+GsbzeO8{Y*Z9(C1Q zY@GP5$cVT;(i_F$tl(S6;ligg7BN#h?sAV8DX9a9tu|v#p5=FX9NEfRilFOaB@r)& z(t=?QrQs*{<;Rs;MbB>6WkkIE`H??byx({?Z-JebN0eWKNzp-}DGlG~?3rvZ>BoUe z#H*eX`CzTc=gQ`XY73pxN>s6_LH(Vu2p>zN6=C~k=1O(Lm}q78hmJeQ6Ghk5O@m?c zzy4cNDAn__w^J9*C;9GGi@EfYF$xw`>4c^yKhowI45ieSC^yTJ-M$*)B;lSE-NtLn5rU6 z$H=&*ve1$zG!=jwkKr41`2fL`^I5iJ!{?lZ12u4<>@!*bkuu6Wm(&Qb(skovvZ&V| zV9&dtdIIW7r>mmP3}|QaS>zd?o`ah61zPH|;|4)T`$#ey$+F+M6-G1+aPdWCN1_~S z(ZWG)Zuqt_4g9!@5TNvj;_cGuVtM;AHY3yr4FkNJzz8m58x(P1k>6nAbZFRiJnI!= zQZw_%$F3Jh9(qs+uS39?8(CXv4l&F&x%<%UUn)_L#_^dN*A+K217bKeN`lLq_db|V zXcuB39j9tVID}=mh4x9ECqgDgt+_i|pqL_IXVSKr6vWT)A(!n#2qcJ9EY8%IDcZwc^Eppc8N`J$}yi`PZ%V2i`L& z64u6_S(^4bYfh;)w<^Uy9q-B5EnpVMRWDiq|N9MYpfPjXQx?4TP>R$|6y|-vR#}u>v^fg(p-wsljQcr z&I-j*7O+(xty?=qe_#(Gzei5B{ms&_{xA8~>j{;aePDVa02lpc`rw4Z!@${QLKp%# ntdd|P@;?86eEk2dOl$!s6W1};0Z$thHBQOf1LgkoB$o6aJD_A_ literal 0 HcmV?d00001 diff --git a/strawApp/src/main/res/mipmap-xxxhdpi/ic_launcher.png b/strawApp/src/main/res/mipmap-xxxhdpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..edd54e2eb2689cbca5a3480edd8988a69be8cf5e GIT binary patch literal 2477 zcmcImi9gg^6gNW|TO<(~M)rzcmSmkDO~%@gl&ob!6U8eA6EkQ*XtG2jj246B2}AZN z$rdvrGMHpbWQiI(^M2lY|HAv+&%NhXml&*yXQ_uLcja0)FZEGNvz$0ufOg*pw& zH`@~i1y@ePx&tV7dfTE=e7x-i3ZmW6kpO zl`0{=#zaMlK%v?&SQX-b00~IqJZ-QA!LR@IF>mDap4DK4T!1{aa{BHd`ja~3wKyPI zNO4!$OMX5&#ePg(r=1T!f3Uc$*>yd?+PE4Puc{zHijTP*|n>4;@%gs(`gMM%gkj4ZSD4I=cSX1c@fQxU*$_kWb98^`eGL9Y^rf?$%d|b zQy5|>Q-4(IgDTGN3Xk&?-tP}f$|7gB_;tnML<`^;s(Yacbq`Ogr02zjawmBb55y?%>nsSXEqeBw$rp<9We|w7FEE`QyGwG? z`%pETt2VH>-qzxeT|sGhT2~-d3l_I`b-K{eP^);hhdF~3Xi||7Qx$0{${#4RGGKWL zLXNg|U|tY0!zLs+s60_mAe4E$R7k`5)j%O3G9Og2&)(5>D||+V&D;T-BLLu00P&g*8MPm}hY3w`y@jWNCNkh7Lr6Z&E)=@C%<_R1h%EN@^qhM*W}l6x zB}h1^!z&eT*trpuM$LfF=0NtV08`%tTxQK-2I;(sRM%!8Z{<)4r+h(R-HjaL?1?PM zD5C3fCZ0q!=xyFXZjLW2Zq0}fSFJmzxBLn)#ly{!wLQ_X(6YMoE)nx+hHqQk#_Wyq zfv}1iv~f>Jj!0{_zB1|fqb%AN!puS?4#pr5qS5?i!L0@AZsd3p7-G(@*6Ti&_5Fky zR6%jeKBZjUS=oy}j^g{(*K}VdDqLalhBjD?Lq%t>Cx-}$yP-9W-gtr|h3G!GhMmHu zB%=O3?Q>TlAs3~sEe~8XZH7TY-cplu-N;8R0J|`q?uFSF$p=)%mDv0q~m-B}#Ph?LMk3pcmBC4ugml7>Fb=Hkhp8s`{@>(ZSKZE9P{k zAs)wT_~tTIG3(gQ&36Fo@+(-{{T&c7;gRlA1Y%hz69m=P--8dsTH%t%3#FsWo?|tOXASQA zOQF?;DExBO`f_sj@kG&^MtzXf!TjTT;a2+{5OOxs zmL(g91gBhnqmOi?2MiB(S`S3&{7QYn8(qd5gP~4+2wRUxu7h~Ennp5K$aw>VcL7HG z!^)gq&Sg}SZI4~w2^L0>zcR#?+?r-xr@8s08+Odi=xf0d>odTI%hJ@DE@s-T+mJ$# z#@xqr-Gu*WEUzM}p`R*(iVGw)|M(oDA{sY7N5ykbbHkkSvo*!oP~oJeyEGlJF67zw zG%Zf`UJ}u${log^uR2_2)kaUWJEYLYH)mzJ9*ZWlQ({$`>Z4-RtNpc*+%Yfr*WY=0?*eXDaLjNtnx!AHC;CxEs_7lbq|yAaDwOA>{IG=zVNUUMw2BLc=wXB!2j5@XTVydrPZ*^Seh zdq()D-}hlxW;BgQ_-$Bw7?EZJMlYvY=(?)k$ivDF>*cK96EbM(bTdvlE$%_Uv+DJQ z@^;&ZwU~!LsqL5bGbhA~>z-WQysDaYFG;F7A70fyvB}XDb0EE24~WLzRs?s34jDuj%-& cpV<(feB~KiITJAk_FsI~Cr_dNvbYfQHxo3P)&Kwi literal 0 HcmV?d00001 diff --git a/strawApp/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png b/strawApp/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png new file mode 100644 index 0000000000000000000000000000000000000000..edd54e2eb2689cbca5a3480edd8988a69be8cf5e GIT binary patch literal 2477 zcmcImi9gg^6gNW|TO<(~M)rzcmSmkDO~%@gl&ob!6U8eA6EkQ*XtG2jj246B2}AZN z$rdvrGMHpbWQiI(^M2lY|HAv+&%NhXml&*yXQ_uLcja0)FZEGNvz$0ufOg*pw& zH`@~i1y@ePx&tV7dfTE=e7x-i3ZmW6kpO zl`0{=#zaMlK%v?&SQX-b00~IqJZ-QA!LR@IF>mDap4DK4T!1{aa{BHd`ja~3wKyPI zNO4!$OMX5&#ePg(r=1T!f3Uc$*>yd?+PE4Puc{zHijTP*|n>4;@%gs(`gMM%gkj4ZSD4I=cSX1c@fQxU*$_kWb98^`eGL9Y^rf?$%d|b zQy5|>Q-4(IgDTGN3Xk&?-tP}f$|7gB_;tnML<`^;s(Yacbq`Ogr02zjawmBb55y?%>nsSXEqeBw$rp<9We|w7FEE`QyGwG? z`%pETt2VH>-qzxeT|sGhT2~-d3l_I`b-K{eP^);hhdF~3Xi||7Qx$0{${#4RGGKWL zLXNg|U|tY0!zLs+s60_mAe4E$R7k`5)j%O3G9Og2&)(5>D||+V&D;T-BLLu00P&g*8MPm}hY3w`y@jWNCNkh7Lr6Z&E)=@C%<_R1h%EN@^qhM*W}l6x zB}h1^!z&eT*trpuM$LfF=0NtV08`%tTxQK-2I;(sRM%!8Z{<)4r+h(R-HjaL?1?PM zD5C3fCZ0q!=xyFXZjLW2Zq0}fSFJmzxBLn)#ly{!wLQ_X(6YMoE)nx+hHqQk#_Wyq zfv}1iv~f>Jj!0{_zB1|fqb%AN!puS?4#pr5qS5?i!L0@AZsd3p7-G(@*6Ti&_5Fky zR6%jeKBZjUS=oy}j^g{(*K}VdDqLalhBjD?Lq%t>Cx-}$yP-9W-gtr|h3G!GhMmHu zB%=O3?Q>TlAs3~sEe~8XZH7TY-cplu-N;8R0J|`q?uFSF$p=)%mDv0q~m-B}#Ph?LMk3pcmBC4ugml7>Fb=Hkhp8s`{@>(ZSKZE9P{k zAs)wT_~tTIG3(gQ&36Fo@+(-{{T&c7;gRlA1Y%hz69m=P--8dsTH%t%3#FsWo?|tOXASQA zOQF?;DExBO`f_sj@kG&^MtzXf!TjTT;a2+{5OOxs zmL(g91gBhnqmOi?2MiB(S`S3&{7QYn8(qd5gP~4+2wRUxu7h~Ennp5K$aw>VcL7HG z!^)gq&Sg}SZI4~w2^L0>zcR#?+?r-xr@8s08+Odi=xf0d>odTI%hJ@DE@s-T+mJ$# z#@xqr-Gu*WEUzM}p`R*(iVGw)|M(oDA{sY7N5ykbbHkkSvo*!oP~oJeyEGlJF67zw zG%Zf`UJ}u${log^uR2_2)kaUWJEYLYH)mzJ9*ZWlQ({$`>Z4-RtNpc*+%Yfr*WY=0?*eXDaLjNtnx!AHC;CxEs_7lbq|yAaDwOA>{IG=zVNUUMw2BLc=wXB!2j5@XTVydrPZ*^Seh zdq()D-}hlxW;BgQ_-$Bw7?EZJMlYvY=(?)k$ivDF>*cK96EbM(bTdvlE$%_Uv+DJQ z@^;&ZwU~!LsqL5bGbhA~>z-WQysDaYFG;F7A70fyvB}XDb0EE24~WLzRs?s34jDuj%-& cpV<(feB~KiITJAk_FsI~Cr_dNvbYfQHxo3P)&Kwi literal 0 HcmV?d00001 From 29ffed265b3d81f0154040480a38a284f0329c4e Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 11:54:45 -0700 Subject: [PATCH 13/72] vc=29: fullscreen overlay controls respect display cutout + status bar MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit In portrait fullscreen, the camera notch / cutout was eating the top overlay buttons — SB pill, Speed, Headphones, Videocam, Share, PiP, Minimize. Tappable area sat under the cutout shadow; presses dropped. Wrapped the overlay layer (SB pill + control Row) in a Box with windowInsetsPadding(WindowInsets.safeDrawing). safeDrawing is the union of system bars + display cutouts + IME, so this single modifier covers both portrait (notch at top) and landscape (cutout at side) without per-orientation logic. The PlayerView itself still uses fillMaxSize with no inset padding — video stays full-bleed and reads as immersive; only the touch-targets respect the safe area. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 ++-- .../sulkta/straw/feature/player/PlayerScreen.kt | 15 +++++++++++++++ 2 files changed, 17 insertions(+), 2 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 225345b66..83175d02a 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 28 -const val STRAW_VERSION_NAME = "0.1.0-AN" +const val STRAW_VERSION_CODE = 29 +const val STRAW_VERSION_NAME = "0.1.0-AO" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt index 4266cf34b..0c3ee8f01 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt @@ -27,9 +27,12 @@ import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.WindowInsets import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.safeDrawing import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.windowInsetsPadding import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material.icons.Icons import androidx.compose.material.icons.filled.KeyboardArrowDown @@ -153,6 +156,8 @@ fun PlayerScreen( ) else -> { + // Video surface — bleeds full-screen including under any + // display cutout / camera notch. Looks more immersive. AndroidView( factory = { ctx -> PlayerView(ctx).apply { @@ -164,6 +169,15 @@ fun PlayerScreen( onRelease = { it.player = null }, modifier = Modifier.fillMaxSize(), ) + // Overlay controls layer — sits inside the safe area so + // buttons don't get eaten by the notch in portrait or by + // a side cutout in landscape. SafeDrawing covers system + // bars + display cutouts in one go. + Box( + modifier = Modifier + .fillMaxSize() + .windowInsetsPadding(WindowInsets.safeDrawing), + ) { Box( modifier = Modifier .align(Alignment.TopStart) @@ -231,6 +245,7 @@ fun PlayerScreen( onMinimize() } } + } // close safe-area overlay Box if (showSpeedDialog) { SpeedPickerDialog( From 20ee8023c11b3178c71104326f2840155cfb84b2 Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 11:58:43 -0700 Subject: [PATCH 14/72] vc=30: minibar above nav buttons + simpler icon MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two follow-ups on vc=29 (the cutout fix is bundled in too — vc=29 never shipped standalone): Minibar Was rendering UNDER the system nav buttons / gesture pill because StrawActivity uses enableEdgeToEdge() and the minibar was aligned BottomCenter with no inset awareness. Added navigationBarsPadding() to the MinibarOverlay Column so it lifts above the system bar in both gesture-nav and 3-button-nav modes. Icon v1 had two overlapping shapes (tilted lime parallelogram + white play triangle) that fought each other and read as visual noise at launcher size. Replaced with a single bold white play triangle on the deep-green (#166534) background — one strong silhouette, reads at any size, says "video app" without ceremony. PNG fallbacks re-rendered at all five mipmap densities. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 ++-- .../straw/feature/player/MinibarOverlay.kt | 7 +++++- .../res/drawable/ic_launcher_foreground.xml | 20 ++++++------------ .../src/main/res/mipmap-hdpi/ic_launcher.png | Bin 987 -> 603 bytes .../res/mipmap-hdpi/ic_launcher_round.png | Bin 987 -> 603 bytes .../src/main/res/mipmap-mdpi/ic_launcher.png | Bin 740 -> 479 bytes .../res/mipmap-mdpi/ic_launcher_round.png | Bin 740 -> 479 bytes .../src/main/res/mipmap-xhdpi/ic_launcher.png | Bin 1355 -> 759 bytes .../res/mipmap-xhdpi/ic_launcher_round.png | Bin 1355 -> 759 bytes .../main/res/mipmap-xxhdpi/ic_launcher.png | Bin 1809 -> 973 bytes .../res/mipmap-xxhdpi/ic_launcher_round.png | Bin 1809 -> 973 bytes .../main/res/mipmap-xxxhdpi/ic_launcher.png | Bin 2477 -> 1200 bytes .../res/mipmap-xxxhdpi/ic_launcher_round.png | Bin 2477 -> 1200 bytes 13 files changed, 14 insertions(+), 17 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 83175d02a..021a8e0ff 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 29 -const val STRAW_VERSION_NAME = "0.1.0-AO" +const val STRAW_VERSION_CODE = 30 +const val STRAW_VERSION_NAME = "0.1.0-AP" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/MinibarOverlay.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/MinibarOverlay.kt index dea622a58..b9dbdcda6 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/MinibarOverlay.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/MinibarOverlay.kt @@ -23,6 +23,7 @@ import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.Spacer import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.navigationBarsPadding import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.size import androidx.compose.foundation.layout.width @@ -79,7 +80,11 @@ fun MinibarOverlay( onDispose { controller.removeListener(listener) } } - Column(modifier = modifier.fillMaxWidth()) { + // navigationBarsPadding shifts the whole minibar up by the system + // nav-bar height so the bar sits ABOVE the gesture pill / 3-button + // nav, not behind them. enableEdgeToEdge in StrawActivity means + // anything aligned BottomCenter lands under those buttons otherwise. + Column(modifier = modifier.fillMaxWidth().navigationBarsPadding()) { HorizontalDivider() Surface( color = MaterialTheme.colorScheme.surfaceVariant, diff --git a/strawApp/src/main/res/drawable/ic_launcher_foreground.xml b/strawApp/src/main/res/drawable/ic_launcher_foreground.xml index 9bb57a385..7dac7e8a3 100644 --- a/strawApp/src/main/res/drawable/ic_launcher_foreground.xml +++ b/strawApp/src/main/res/drawable/ic_launcher_foreground.xml @@ -1,25 +1,17 @@ - - - + android:pathData="M 38,30 L 38,78 L 82,54 Z" /> diff --git a/strawApp/src/main/res/mipmap-hdpi/ic_launcher.png b/strawApp/src/main/res/mipmap-hdpi/ic_launcher.png index c8f3906f9b9faa3c8659b6a600e32c9e5be5082d..c14f88f15a69484dd10899f061a8dd70d63367c5 100644 GIT binary patch delta 561 zcmV-10?z&02ipXYHGcvSNklz4Mi+GHZ~*6Sy@<3v9KCh z$pQ=8A!4RxGf^HXuf;6P6h`vMBhfUT3kw#*Mo}Y=JfalCjKwWk;L4nH|9f=4{XPHx z-R}S0ySS3Ep*-O~q7%IVELe;hEJh6$qXvsngT<)9V$@(UYJad8HCT)qkYe4nt#y{_ zM4cvX7UU*O2BX_%U+?f*&6R*-{|5ZsEzT(%X>?7t4wmJWfDivYSdWdRv|^>rGt%hF z&(1|!;%5-ggCt2-bLD2&q}yiCN;lvw^d;yAU7w_{vs7<6rdq1%Q}oH$%YC3y!7|e_ z+H0D3oHMFrQ-9So=NOD`n|-6xr$RObymN|71uA4y*vk|`k}I^6)_pWY-&qP1|*wW6qAWFo7xqNlO)j__?AFu&oSM9aCY>!%e5$W ze178a_pcrV;~AnYvGcpDo`ung;Otv88s{jjh}}Ou41X+nhS$8$kr$AG;>9Ab5#QFl zYj)`7@eXjTNU>NfHn+d#^bed~hrx#n6AOg)x~KaN&yJDi3lIZ|o+7G>g>Nr=7so)N zr-({o;L%eAT?{FDiXe)iMo$qeG3@9m0xzac^b~;<3*TNejd%EWm!mQC=qV!cKf%Oc zF>0_FH7Zz)8Z1T)7NZ7>QG>;(!D7^4F>1U6qFTbtHM%BP00000NkvXXu0mjf%$5t4 delta 948 zcmV;l155nd1ltFYHGcz;Nkl`@tm>94A z2i`nr;vcY!2X7uc7|+J|a`j~NvWv#VOmADv;@DfVkvU;ZkkSEV8!v@=Xwp@nwXwga zrKX=->BIBwCwb`e@(U<@?<(;>Vl(;yaAAp=4NJ^ySYl?w5`QxrmYCVF8<-uxbDgW! zOR0Q0^{c_wU^_QV%o_{3#{vXF_^DBXAZm2=XgA01(`<&}TW#(A8zvS?Oh_-Cq$fgB zk!uuJYgYCPh1E3sgVxf&F~2dJ!yb%}^}Jte2#w$WH-b}9n?rW6wCc^$ zPEKQlF=FIwOn>2SaUmunX;0Bx z3?USnKCjTAu$BP{(p$_o8FqM_a(DSwo7p@B3DR4POenoJO1pXPqz)3KtC)RgFmNfX z(11?Dj6*_avC#B5vdJbk*jnX#0V+#ZF>*%fwZW_(@PBO{DhrobbhvZKxue6buutJD z#SMVzO9YqL!&?iB_g~$J&x@asiE)MYY=${4RskOX<4~NZX5TD474&TObHnkdLgQjG z4V#XA+al<#{@i|xzJ5F1>)EE=jQ9MF3EP&H+~)e{PdIX=U=a&Vcb)=BcVcuh&GQ(Ry?+8P=8XkiA&+?3vAN`V zo?g#_hjs%mCYCCD?w8qpx=}s>5A6n6Oe|HtWIoVbrMm&(S?^z-1hzY|RN2$2Rd1Gd z@_(?2asZ3zP^wf3q?kUXN|iv0g%U9xN|h=B6GI4fPhV1?N|h=B6Z1`m2fTWeDpdj| zrd+B#+RZ_gDpdj|cARC{Oi^yFq~~ix0BnNJE$`))_iO`p??fm-jrysxkqKL>R0;6P zqut=jseCz=ClE0->i1t5@lB3Y(?!5ir7cR3_1_kgVTqXyOU!IoVrIhz4Mi+GHZ~*6Sy@<3v9KCh z$pQ=8A!4RxGf^HXuf;6P6h`vMBhfUT3kw#*Mo}Y=JfalCjKwWk;L4nH|9f=4{XPHx z-R}S0ySS3Ep*-O~q7%IVELe;hEJh6$qXvsngT<)9V$@(UYJad8HCT)qkYe4nt#y{_ zM4cvX7UU*O2BX_%U+?f*&6R*-{|5ZsEzT(%X>?7t4wmJWfDivYSdWdRv|^>rGt%hF z&(1|!;%5-ggCt2-bLD2&q}yiCN;lvw^d;yAU7w_{vs7<6rdq1%Q}oH$%YC3y!7|e_ z+H0D3oHMFrQ-9So=NOD`n|-6xr$RObymN|71uA4y*vk|`k}I^6)_pWY-&qP1|*wW6qAWFo7xqNlO)j__?AFu&oSM9aCY>!%e5$W ze178a_pcrV;~AnYvGcpDo`ung;Otv88s{jjh}}Ou41X+nhS$8$kr$AG;>9Ab5#QFl zYj)`7@eXjTNU>NfHn+d#^bed~hrx#n6AOg)x~KaN&yJDi3lIZ|o+7G>g>Nr=7so)N zr-({o;L%eAT?{FDiXe)iMo$qeG3@9m0xzac^b~;<3*TNejd%EWm!mQC=qV!cKf%Oc zF>0_FH7Zz)8Z1T)7NZ7>QG>;(!D7^4F>1U6qFTbtHM%BP00000NkvXXu0mjf%$5t4 delta 948 zcmV;l155nd1ltFYHGcz;Nkl`@tm>94A z2i`nr;vcY!2X7uc7|+J|a`j~NvWv#VOmADv;@DfVkvU;ZkkSEV8!v@=Xwp@nwXwga zrKX=->BIBwCwb`e@(U<@?<(;>Vl(;yaAAp=4NJ^ySYl?w5`QxrmYCVF8<-uxbDgW! zOR0Q0^{c_wU^_QV%o_{3#{vXF_^DBXAZm2=XgA01(`<&}TW#(A8zvS?Oh_-Cq$fgB zk!uuJYgYCPh1E3sgVxf&F~2dJ!yb%}^}Jte2#w$WH-b}9n?rW6wCc^$ zPEKQlF=FIwOn>2SaUmunX;0Bx z3?USnKCjTAu$BP{(p$_o8FqM_a(DSwo7p@B3DR4POenoJO1pXPqz)3KtC)RgFmNfX z(11?Dj6*_avC#B5vdJbk*jnX#0V+#ZF>*%fwZW_(@PBO{DhrobbhvZKxue6buutJD z#SMVzO9YqL!&?iB_g~$J&x@asiE)MYY=${4RskOX<4~NZX5TD474&TObHnkdLgQjG z4V#XA+al<#{@i|xzJ5F1>)EE=jQ9MF3EP&H+~)e{PdIX=U=a&Vcb)=BcVcuh&GQ(Ry?+8P=8XkiA&+?3vAN`V zo?g#_hjs%mCYCCD?w8qpx=}s>5A6n6Oe|HtWIoVbrMm&(S?^z-1hzY|RN2$2Rd1Gd z@_(?2asZ3zP^wf3q?kUXN|iv0g%U9xN|h=B6GI4fPhV1?N|h=B6Z1`m2fTWeDpdj| zrd+B#+RZ_gDpdj|cARC{Oi^yFq~~ix0BnNJE$`))_iO`p??fm-jrysxkqKL>R0;6P zqut=jseCz=ClE0->i1t5@lB3Y(?!5ir7cR3_1_kgVTqXyOU!IoVrIhXaZHGct=NklI*1S$br2yi>L5a3 z)Io&6(07mkH=nVEnLIEz`)FHEJczAAs+s%74uwlt?$2j^7!pDsym3xC^Jyd zT30-Mb>UPk8P!4IAPBJ2G}~LdWOjPHjIiXOa1a9n0}~^YpMSB-k;YXuK{3817tbIg8`8F!!T;@Ot1Kbm;o2 z`qdMzJ-JQ17Jphf=)!|*jcX?zyLpyWjnsG0lef=1H_cpqV%z`!|H;r!O$WXI`f=*c z#WVLT|Mlk=*@jTZLEnGg|I=h#=Ohgbcjt=P&04<{qA_PVqLQoQH#kHAVw|%mafr1bH#7_DTqsdZ_^?Y;}6?x3gp4v<0K zNI+T=1d2>|-vK5F^SYh>eo2u@QT4;BJ|JK8*zy2Si0>+D0u6*92oaWo_#(*Tz||e$f@YilX)oYIK6Q5UTe$i z4-zA8d8MqLPmHmN=*+b{Q)81|-Vc9bY|q|d{^9Gzg|+2+gY7v8flbj0vUyw`>jzBn z@!Kb}@1829Xaza_xTI3zE3+S-Jy@PsN6`c_+pTu5yPfia{BR?8a=fd>ExO=ZJ8OptR3cMP6dt8BLy>13WQ zA87}vIT$^iheHU<15|(z6H0{qk|I}QONqQbp#HN%X1i5Vq_)!nuWXoy2I@S_Z^3zA zKn1AqHC^1vaJ4^2UnNUd^9(GI;%`}z%oNECf;1wI;l93cA3iov*itjh|0{^`KebE@ hkX#IqTnvz0eglne{&i><2#o*$002ovPDHLkV1jZSOK1Q9 diff --git a/strawApp/src/main/res/mipmap-mdpi/ic_launcher_round.png b/strawApp/src/main/res/mipmap-mdpi/ic_launcher_round.png index fcfab8700211002e656f1e323500fa314802beda..7885352b044bac81fa38aa09f9785e8d96cde23e 100644 GIT binary patch delta 436 zcmV;l0Zabm1>XaZHGct=NklI*1S$br2yi>L5a3 z)Io&6(07mkH=nVEnLIEz`)FHEJczAAs+s%74uwlt?$2j^7!pDsym3xC^Jyd zT30-Mb>UPk8P!4IAPBJ2G}~LdWOjPHjIiXOa1a9n0}~^YpMSB-k;YXuK{3817tbIg8`8F!!T;@Ot1Kbm;o2 z`qdMzJ-JQ17Jphf=)!|*jcX?zyLpyWjnsG0lef=1H_cpqV%z`!|H;r!O$WXI`f=*c z#WVLT|Mlk=*@jTZLEnGg|I=h#=Ohgbcjt=P&04<{qA_PVqLQoQH#kHAVw|%mafr1bH#7_DTqsdZ_^?Y;}6?x3gp4v<0K zNI+T=1d2>|-vK5F^SYh>eo2u@QT4;BJ|JK8*zy2Si0>+D0u6*92oaWo_#(*Tz||e$f@YilX)oYIK6Q5UTe$i z4-zA8d8MqLPmHmN=*+b{Q)81|-Vc9bY|q|d{^9Gzg|+2+gY7v8flbj0vUyw`>jzBn z@!Kb}@1829Xaza_xTI3zE3+S-Jy@PsN6`c_+pTu5yPfia{BR?8a=fd>ExO=ZJ8OptR3cMP6dt8BLy>13WQ zA87}vIT$^iheHU<15|(z6H0{qk|I}QONqQbp#HN%X1i5Vq_)!nuWXoy2I@S_Z^3zA zKn1AqHC^1vaJ4^2UnNUd^9(GI;%`}z%oNECf;1wI;l93cA3iov*itjh|0{^`KebE@ hkX#IqTnvz0eglne{&i><2#o*$002ovPDHLkV1jZSOK1Q9 diff --git a/strawApp/src/main/res/mipmap-xhdpi/ic_launcher.png b/strawApp/src/main/res/mipmap-xhdpi/ic_launcher.png index 717e67c8cf3c1db79d750e434ede4f7e94fcde80..d5571af16ee797b9dfd6fe31b26d5b1e2b76de79 100644 GIT binary patch literal 759 zcmeAS@N?(olHy`uVBq!ia0vp^2_VeD1SE5RJ;(=AY)RhkE)4%caKYZ?lNlJ8)_A%& zhE&XXd*`6{xO36gf14te$1e}4T~eY1Ls-YunHl2`6*F|U7j?90=Qi+}Tb-uo*rXSZbY%xRC7 z{`q_F_RKGGKVSbpb-Qb;d`|7f_!FgHmj?IlyZ12v$DE(Kr61pIJGb*-d$`|Mwb#-% z`%cRL_%C;5gKpuz$8TmIbhkZzUSp2s|HhtUZ>`z=;sY#-qnISQ(*42}oUfkAU$>hXHH`#OC3>uX9&lpZ)3 zb8o)R<=h=_XT4V_Wx>y*<$s0CpWE#b-60yG@LHLbRrth34@X9pBCDVYuN;_^Szq$1 z7za%_<}eA! z6zLOD5%GBI;b_YA|B3EYkGzmmOXXj$gXt5i^&y)c+6bfGL^5)78&qol`;+0A4OV`v3p{ delta 1319 zcmaJ>Yc$gf0RPL#Ot&fIG>^GQ9wRMn7Cq*#S*DOj_qya2#)P=!5%XsrL&c(X#W-Vm z%x3PQyqZMhq?0ToltWQNIF<6qa(%n!+zSs&7|0k1ILPEUx9+G2w>EI;bLokk8JJy6wJmR4{wtl58jn)TH>quh5LM`2 z2M^2mjT^QNlcG;r&nDKLYq%{C&Vkot)lby^-k;HV`37YPBK}4`n8NBP6P@%RPXY`3 zXvszyLQT@)81hncUTSWMj&VC@I?j8QMeUR(`ItzR^D+za`^P9u#KNy!Ar=0utC<^) zDe$BwTz~h$pwi&A_6+cWJcju?Z z^xxz4A!I0Vxx0=#^{LfD-pjWXg}P);WtF;vf2yBQC;`ALuMxw&i&>7KYoo==7np14 zl~r!TNS;kk6}Nx$)>O=t7iQsZ4bjhA%Xl!jJRqk=;Oj;q^l;GTI$vC1v6$U9aXB@` zOH5m^q$vzYzXy>wH+Kl(dpH+ow1qO7z*{iuB~<_dSar?dclwFrgt?X0m;$aa)I8F3 zhX6+Z{CJk_CVG^-)GZzjeJ*J{6r6K2_GimONu$ii zxFaQ}*H?7z)uB0AFZ&X$%{bRv;3;kT$is?Fcj2L^;Ui~chRcMl{r*DP#B6+pYjCNYSvDk zbhjvTd}%orqb3#Pb)LIr%sPza@n<=AJR+xl>=;*^3GiQ!`=*qAJICG^ zX>F$}vt+0B^VgXRzQg-buqg0URj?mE-(P8l7hLjEXP97@aCR4fs|qeTr#+0)U*M?% z_6O{8;OD`cGfnc>XgqSG>}w_$Q-{+3@nGY};<%(U0%(xynykPeikP)LOdJwdOIJ@} z=15Pml`TPiKJglRof*2<3xXUd$jqU`XU*UjvD<~az)148!^p|s39GB$ll2g-MEWRx zaYzExO36gf14te$1e}4T~eY1Ls-YunHl2`6*F|U7j?90=Qi+}Tb-uo*rXSZbY%xRC7 z{`q_F_RKGGKVSbpb-Qb;d`|7f_!FgHmj?IlyZ12v$DE(Kr61pIJGb*-d$`|Mwb#-% z`%cRL_%C;5gKpuz$8TmIbhkZzUSp2s|HhtUZ>`z=;sY#-qnISQ(*42}oUfkAU$>hXHH`#OC3>uX9&lpZ)3 zb8o)R<=h=_XT4V_Wx>y*<$s0CpWE#b-60yG@LHLbRrth34@X9pBCDVYuN;_^Szq$1 z7za%_<}eA! z6zLOD5%GBI;b_YA|B3EYkGzmmOXXj$gXt5i^&y)c+6bfGL^5)78&qol`;+0A4OV`v3p{ delta 1319 zcmaJ>Yc$gf0RPL#Ot&fIG>^GQ9wRMn7Cq*#S*DOj_qya2#)P=!5%XsrL&c(X#W-Vm z%x3PQyqZMhq?0ToltWQNIF<6qa(%n!+zSs&7|0k1ILPEUx9+G2w>EI;bLokk8JJy6wJmR4{wtl58jn)TH>quh5LM`2 z2M^2mjT^QNlcG;r&nDKLYq%{C&Vkot)lby^-k;HV`37YPBK}4`n8NBP6P@%RPXY`3 zXvszyLQT@)81hncUTSWMj&VC@I?j8QMeUR(`ItzR^D+za`^P9u#KNy!Ar=0utC<^) zDe$BwTz~h$pwi&A_6+cWJcju?Z z^xxz4A!I0Vxx0=#^{LfD-pjWXg}P);WtF;vf2yBQC;`ALuMxw&i&>7KYoo==7np14 zl~r!TNS;kk6}Nx$)>O=t7iQsZ4bjhA%Xl!jJRqk=;Oj;q^l;GTI$vC1v6$U9aXB@` zOH5m^q$vzYzXy>wH+Kl(dpH+ow1qO7z*{iuB~<_dSar?dclwFrgt?X0m;$aa)I8F3 zhX6+Z{CJk_CVG^-)GZzjeJ*J{6r6K2_GimONu$ii zxFaQ}*H?7z)uB0AFZ&X$%{bRv;3;kT$is?Fcj2L^;Ui~chRcMl{r*DP#B6+pYjCNYSvDk zbhjvTd}%orqb3#Pb)LIr%sPza@n<=AJR+xl>=;*^3GiQ!`=*qAJICG^ zX>F$}vt+0B^VgXRzQg-buqg0URj?mE-(P8l7hLjEXP97@aCR4fs|qeTr#+0)U*M?% z_6O{8;OD`cGfnc>XgqSG>}w_$Q-{+3@nGY};<%(U0%(xynykPeikP)LOdJwdOIJ@} z=15Pml`TPiKJglRof*2<3xXUd$jqU`XU*UjvD<~az)148!^p|s39GB$ll2g-MEWRx zaYzE<|{ zLn`LHy}jT2YM{)qkMBd*y9KCBoZuMfY(I@-id(eI9G2Nr)e2WGyt+t3e}_k4l%rUq z3)eEmsV$1FGg_USd7lZXXoO5jQn;y`YtgKD?WNb9;(O0+*4IC%+4p^~&1v7MreSJ_ z0w4ThIN95DP(z}JcEs|7S$#6utMl*eTYBZI;=PY15rv7n7Ou)$^Yq`!S;Dg~sjfT! zv19qcp4{2n=h@bMN?o>p;i`2T4!jQj%=STh%JgYlubSK2-w%!seEUo6JHx@Azt-Q& z%(i};x38??yW{okJ6br?LS(J1N|vqOyt4FsU+lX4LS``?&q*O#q0xbVA35dEF`guT z#zWlIN_pkM9**=B4tdF|Jv@pt1W)$xsLv4m)5D`1A@r+<$6&_C-#t2>;=Aph@8>j| zk(l;m^_k{`v=ol}38I&JdX#1e9_#7RnBh2o;zd^P2gXLn64*-Ij!B<6aMt5MXC=d| ziCo*b43$N5bkCux#Y@(`X|qOLJYX?r!D!-EpVo%rfl8qpFJTPWMnk%Kd*7q zia2-YoCoV|j&|dqgJ$PW0+r5Cy3XE^TAxyVOl~XRogaTn_450*Zn&*kv&N>zcFxQ9 z75_8U&iiXeoO4qOkCV*UddgVcX6lc%4@wRY21jnkZcU&+Q!$ee8KDBwIXY#wIVrF`9YjX zN0tj_h*lficUus;=inci#xO&+&y_4uuHt7t10@0tj&N-0Qj*AEiDH%GF=txa#LFhz z7{%s9#|_Kjmp z6RY%0nf#a8^Jmn({w0uZa8L>8o`!_LUI*><&8`+qYi)SH>FzG6eerJULF>=m-0Si` vdaqiu@zPh`Nz8v2^1B^O5aFR6@l3qs-n7*JJ!USz{K??y>gTe~DWM4fA5*B* literal 1809 zcmb7Fc{m%`7FR@KYrW1`Dos_HMy;t1QktN)+7hLf1|!9nmYGS=;ZY5mSh`r+YG@*K z(T0qsG`6ZG!U!hHH`J1n7A@6@SfZpU;-xcx%s=ms_rCj``}^+i-gEA`_ndprwE&ct zwuYgGl9H0P_bK;41>XEBAZ0~=!8CbU0cz2{UhYaeU)%lms$vDf^LBSVlS&s0`2?`X z{?5eOcN3`n&ahWq@SXS$|bjxWS%7Qs*-fYFUj}Eu&s&UBkDe?q-4tof~oV=#B1g7{*jx*SB`v!8Z>|T}gFLBxFsdz-B zO|a@#U~x!1e1GAh?VTtNEp|7<%;&S=PHmLeq#$Pf)b!=-o5#ZzhI2CR<)y=` z|5|~YpHHg9IEVSG)AP-S)kM-X+GsbzeO8{Y*Z9(C1Q zY@GP5$cVT;(i_F$tl(S6;ligg7BN#h?sAV8DX9a9tu|v#p5=FX9NEfRilFOaB@r)& z(t=?QrQs*{<;Rs;MbB>6WkkIE`H??byx({?Z-JebN0eWKNzp-}DGlG~?3rvZ>BoUe z#H*eX`CzTc=gQ`XY73pxN>s6_LH(Vu2p>zN6=C~k=1O(Lm}q78hmJeQ6Ghk5O@m?c zzy4cNDAn__w^J9*C;9GGi@EfYF$xw`>4c^yKhowI45ieSC^yTJ-M$*)B;lSE-NtLn5rU6 z$H=&*ve1$zG!=jwkKr41`2fL`^I5iJ!{?lZ12u4<>@!*bkuu6Wm(&Qb(skovvZ&V| zV9&dtdIIW7r>mmP3}|QaS>zd?o`ah61zPH|;|4)T`$#ey$+F+M6-G1+aPdWCN1_~S z(ZWG)Zuqt_4g9!@5TNvj;_cGuVtM;AHY3yr4FkNJzz8m58x(P1k>6nAbZFRiJnI!= zQZw_%$F3Jh9(qs+uS39?8(CXv4l&F&x%<%UUn)_L#_^dN*A+K217bKeN`lLq_db|V zXcuB39j9tVID}=mh4x9ECqgDgt+_i|pqL_IXVSKr6vWT)A(!n#2qcJ9EY8%IDcZwc^Eppc8N`J$}yi`PZ%V2i`L& z64u6_S(^4bYfh;)w<^Uy9q-B5EnpVMRWDiq|N9MYpfPjXQx?4TP>R$|6y|-vR#}u>v^fg(p-wsljQcr z&I-j*7O+(xty?=qe_#(Gzei5B{ms&_{xA8~>j{;aePDVa02lpc`rw4Z!@${QLKp%# ntdd|P@;?86eEk2dOl$!s6W1};0Z$thHBQOf1LgkoB$o6aJD_A_ diff --git a/strawApp/src/main/res/mipmap-xxhdpi/ic_launcher_round.png b/strawApp/src/main/res/mipmap-xxhdpi/ic_launcher_round.png index 455be2a69ba7453ef56a9f1e6f1f46b9546bb285..f6d9d87c540a77a8dd0edecd4c7bde1558d351ef 100644 GIT binary patch literal 973 zcmeAS@N?(olHy`uVBq!ia0vp^6F``Q2}owBl)eX2Y)RhkE)4%caKYZ?lNlJ8n><|{ zLn`LHy}jT2YM{)qkMBd*y9KCBoZuMfY(I@-id(eI9G2Nr)e2WGyt+t3e}_k4l%rUq z3)eEmsV$1FGg_USd7lZXXoO5jQn;y`YtgKD?WNb9;(O0+*4IC%+4p^~&1v7MreSJ_ z0w4ThIN95DP(z}JcEs|7S$#6utMl*eTYBZI;=PY15rv7n7Ou)$^Yq`!S;Dg~sjfT! zv19qcp4{2n=h@bMN?o>p;i`2T4!jQj%=STh%JgYlubSK2-w%!seEUo6JHx@Azt-Q& z%(i};x38??yW{okJ6br?LS(J1N|vqOyt4FsU+lX4LS``?&q*O#q0xbVA35dEF`guT z#zWlIN_pkM9**=B4tdF|Jv@pt1W)$xsLv4m)5D`1A@r+<$6&_C-#t2>;=Aph@8>j| zk(l;m^_k{`v=ol}38I&JdX#1e9_#7RnBh2o;zd^P2gXLn64*-Ij!B<6aMt5MXC=d| ziCo*b43$N5bkCux#Y@(`X|qOLJYX?r!D!-EpVo%rfl8qpFJTPWMnk%Kd*7q zia2-YoCoV|j&|dqgJ$PW0+r5Cy3XE^TAxyVOl~XRogaTn_450*Zn&*kv&N>zcFxQ9 z75_8U&iiXeoO4qOkCV*UddgVcX6lc%4@wRY21jnkZcU&+Q!$ee8KDBwIXY#wIVrF`9YjX zN0tj_h*lficUus;=inci#xO&+&y_4uuHt7t10@0tj&N-0Qj*AEiDH%GF=txa#LFhz z7{%s9#|_Kjmp z6RY%0nf#a8^Jmn({w0uZa8L>8o`!_LUI*><&8`+qYi)SH>FzG6eerJULF>=m-0Si` vdaqiu@zPh`Nz8v2^1B^O5aFR6@l3qs-n7*JJ!USz{K??y>gTe~DWM4fA5*B* literal 1809 zcmb7Fc{m%`7FR@KYrW1`Dos_HMy;t1QktN)+7hLf1|!9nmYGS=;ZY5mSh`r+YG@*K z(T0qsG`6ZG!U!hHH`J1n7A@6@SfZpU;-xcx%s=ms_rCj``}^+i-gEA`_ndprwE&ct zwuYgGl9H0P_bK;41>XEBAZ0~=!8CbU0cz2{UhYaeU)%lms$vDf^LBSVlS&s0`2?`X z{?5eOcN3`n&ahWq@SXS$|bjxWS%7Qs*-fYFUj}Eu&s&UBkDe?q-4tof~oV=#B1g7{*jx*SB`v!8Z>|T}gFLBxFsdz-B zO|a@#U~x!1e1GAh?VTtNEp|7<%;&S=PHmLeq#$Pf)b!=-o5#ZzhI2CR<)y=` z|5|~YpHHg9IEVSG)AP-S)kM-X+GsbzeO8{Y*Z9(C1Q zY@GP5$cVT;(i_F$tl(S6;ligg7BN#h?sAV8DX9a9tu|v#p5=FX9NEfRilFOaB@r)& z(t=?QrQs*{<;Rs;MbB>6WkkIE`H??byx({?Z-JebN0eWKNzp-}DGlG~?3rvZ>BoUe z#H*eX`CzTc=gQ`XY73pxN>s6_LH(Vu2p>zN6=C~k=1O(Lm}q78hmJeQ6Ghk5O@m?c zzy4cNDAn__w^J9*C;9GGi@EfYF$xw`>4c^yKhowI45ieSC^yTJ-M$*)B;lSE-NtLn5rU6 z$H=&*ve1$zG!=jwkKr41`2fL`^I5iJ!{?lZ12u4<>@!*bkuu6Wm(&Qb(skovvZ&V| zV9&dtdIIW7r>mmP3}|QaS>zd?o`ah61zPH|;|4)T`$#ey$+F+M6-G1+aPdWCN1_~S z(ZWG)Zuqt_4g9!@5TNvj;_cGuVtM;AHY3yr4FkNJzz8m58x(P1k>6nAbZFRiJnI!= zQZw_%$F3Jh9(qs+uS39?8(CXv4l&F&x%<%UUn)_L#_^dN*A+K217bKeN`lLq_db|V zXcuB39j9tVID}=mh4x9ECqgDgt+_i|pqL_IXVSKr6vWT)A(!n#2qcJ9EY8%IDcZwc^Eppc8N`J$}yi`PZ%V2i`L& z64u6_S(^4bYfh;)w<^Uy9q-B5EnpVMRWDiq|N9MYpfPjXQx?4TP>R$|6y|-vR#}u>v^fg(p-wsljQcr z&I-j*7O+(xty?=qe_#(Gzei5B{ms&_{xA8~>j{;aePDVa02lpc`rw4Z!@${QLKp%# ntdd|P@;?86eEk2dOl$!s6W1};0Z$thHBQOf1LgkoB$o6aJD_A_ diff --git a/strawApp/src/main/res/mipmap-xxxhdpi/ic_launcher.png b/strawApp/src/main/res/mipmap-xxxhdpi/ic_launcher.png index edd54e2eb2689cbca5a3480edd8988a69be8cf5e..3004b5dfbfe0394ca3a9b20999c06747737891b2 100644 GIT binary patch literal 1200 zcmeAS@N?(olHy`uVBq!ia0vp^2SAvE2}s`E_d5Vcu_bxCyD(bUW(<@d`VykFciA;03JVA_3JMMwF|mm0*0#dWb6>xE@vH0A6yXcD(q^?A->(gqude$$ zt2Fk05Kx6wubZ}5n9ZK22iJewzq$PQyXf%ym%dttYG^Ikcy)E&tr0n7+BWmrx-KTEnVH4`;SR}Z zQQcWQ8E1U5UH3Bf&dgkRi&@I}@-nprr_XHByFm={^2nW39$p%U;Z!@~gawYrk{7fdP2D|enjJ$64>9ZO-*1Y+}p!W6fdiC$} zwjaLw-!H8_Ap}%$IsN>e4-XeA->=!SW5;HcIKA+vb^6!P^`Eh@~Ctcqj zGrOVc)uE&Halik(WtNx!_xjM!b@@958NZ%edeqx}zwNg-)%yR--hE$}p9yr#&ripN z{pBk^K6x1&D{rL9_|?_kJxrOgbp3hd)e{?bUHL!ps)xf}iBl)CR2Ec9UjtD)rS5cy^}HJ%(VqsW@@m&o)|8a3>lOh;BUdOXC})>(@t-&`Yikm-(WYmM4*-QL zwX}f3|HQ7nyLIa;@7o)|G=1~)^E$iF-q+i&ES)3%;>XJOyX_Xb{X3Xml&*yXQ_uLcja0)FZEGNvz$0ufOg*pw& zH`@~i1y@ePx&tV7dfTE=e7x-i3ZmW6kpO zl`0{=#zaMlK%v?&SQX-b00~IqJZ-QA!LR@IF>mDap4DK4T!1{aa{BHd`ja~3wKyPI zNO4!$OMX5&#ePg(r=1T!f3Uc$*>yd?+PE4Puc{zHijTP*|n>4;@%gs(`gMM%gkj4ZSD4I=cSX1c@fQxU*$_kWb98^`eGL9Y^rf?$%d|b zQy5|>Q-4(IgDTGN3Xk&?-tP}f$|7gB_;tnML<`^;s(Yacbq`Ogr02zjawmBb55y?%>nsSXEqeBw$rp<9We|w7FEE`QyGwG? z`%pETt2VH>-qzxeT|sGhT2~-d3l_I`b-K{eP^);hhdF~3Xi||7Qx$0{${#4RGGKWL zLXNg|U|tY0!zLs+s60_mAe4E$R7k`5)j%O3G9Og2&)(5>D||+V&D;T-BLLu00P&g*8MPm}hY3w`y@jWNCNkh7Lr6Z&E)=@C%<_R1h%EN@^qhM*W}l6x zB}h1^!z&eT*trpuM$LfF=0NtV08`%tTxQK-2I;(sRM%!8Z{<)4r+h(R-HjaL?1?PM zD5C3fCZ0q!=xyFXZjLW2Zq0}fSFJmzxBLn)#ly{!wLQ_X(6YMoE)nx+hHqQk#_Wyq zfv}1iv~f>Jj!0{_zB1|fqb%AN!puS?4#pr5qS5?i!L0@AZsd3p7-G(@*6Ti&_5Fky zR6%jeKBZjUS=oy}j^g{(*K}VdDqLalhBjD?Lq%t>Cx-}$yP-9W-gtr|h3G!GhMmHu zB%=O3?Q>TlAs3~sEe~8XZH7TY-cplu-N;8R0J|`q?uFSF$p=)%mDv0q~m-B}#Ph?LMk3pcmBC4ugml7>Fb=Hkhp8s`{@>(ZSKZE9P{k zAs)wT_~tTIG3(gQ&36Fo@+(-{{T&c7;gRlA1Y%hz69m=P--8dsTH%t%3#FsWo?|tOXASQA zOQF?;DExBO`f_sj@kG&^MtzXf!TjTT;a2+{5OOxs zmL(g91gBhnqmOi?2MiB(S`S3&{7QYn8(qd5gP~4+2wRUxu7h~Ennp5K$aw>VcL7HG z!^)gq&Sg}SZI4~w2^L0>zcR#?+?r-xr@8s08+Odi=xf0d>odTI%hJ@DE@s-T+mJ$# z#@xqr-Gu*WEUzM}p`R*(iVGw)|M(oDA{sY7N5ykbbHkkSvo*!oP~oJeyEGlJF67zw zG%Zf`UJ}u${log^uR2_2)kaUWJEYLYH)mzJ9*ZWlQ({$`>Z4-RtNpc*+%Yfr*WY=0?*eXDaLjNtnx!AHC;CxEs_7lbq|yAaDwOA>{IG=zVNUUMw2BLc=wXB!2j5@XTVydrPZ*^Seh zdq()D-}hlxW;BgQ_-$Bw7?EZJMlYvY=(?)k$ivDF>*cK96EbM(bTdvlE$%_Uv+DJQ z@^;&ZwU~!LsqL5bGbhA~>z-WQysDaYFG;F7A70fyvB}XDb0EE24~WLzRs?s34jDuj%-& cpV<(feB~KiITJAk_FsI~Cr_dNvbYfQHxo3P)&Kwi diff --git a/strawApp/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png b/strawApp/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png index edd54e2eb2689cbca5a3480edd8988a69be8cf5e..3004b5dfbfe0394ca3a9b20999c06747737891b2 100644 GIT binary patch literal 1200 zcmeAS@N?(olHy`uVBq!ia0vp^2SAvE2}s`E_d5Vcu_bxCyD(bUW(<@d`VykFciA;03JVA_3JMMwF|mm0*0#dWb6>xE@vH0A6yXcD(q^?A->(gqude$$ zt2Fk05Kx6wubZ}5n9ZK22iJewzq$PQyXf%ym%dttYG^Ikcy)E&tr0n7+BWmrx-KTEnVH4`;SR}Z zQQcWQ8E1U5UH3Bf&dgkRi&@I}@-nprr_XHByFm={^2nW39$p%U;Z!@~gawYrk{7fdP2D|enjJ$64>9ZO-*1Y+}p!W6fdiC$} zwjaLw-!H8_Ap}%$IsN>e4-XeA->=!SW5;HcIKA+vb^6!P^`Eh@~Ctcqj zGrOVc)uE&Halik(WtNx!_xjM!b@@958NZ%edeqx}zwNg-)%yR--hE$}p9yr#&ripN z{pBk^K6x1&D{rL9_|?_kJxrOgbp3hd)e{?bUHL!ps)xf}iBl)CR2Ec9UjtD)rS5cy^}HJ%(VqsW@@m&o)|8a3>lOh;BUdOXC})>(@t-&`Yikm-(WYmM4*-QL zwX}f3|HQ7nyLIa;@7o)|G=1~)^E$iF-q+i&ES)3%;>XJOyX_Xb{X3Xml&*yXQ_uLcja0)FZEGNvz$0ufOg*pw& zH`@~i1y@ePx&tV7dfTE=e7x-i3ZmW6kpO zl`0{=#zaMlK%v?&SQX-b00~IqJZ-QA!LR@IF>mDap4DK4T!1{aa{BHd`ja~3wKyPI zNO4!$OMX5&#ePg(r=1T!f3Uc$*>yd?+PE4Puc{zHijTP*|n>4;@%gs(`gMM%gkj4ZSD4I=cSX1c@fQxU*$_kWb98^`eGL9Y^rf?$%d|b zQy5|>Q-4(IgDTGN3Xk&?-tP}f$|7gB_;tnML<`^;s(Yacbq`Ogr02zjawmBb55y?%>nsSXEqeBw$rp<9We|w7FEE`QyGwG? z`%pETt2VH>-qzxeT|sGhT2~-d3l_I`b-K{eP^);hhdF~3Xi||7Qx$0{${#4RGGKWL zLXNg|U|tY0!zLs+s60_mAe4E$R7k`5)j%O3G9Og2&)(5>D||+V&D;T-BLLu00P&g*8MPm}hY3w`y@jWNCNkh7Lr6Z&E)=@C%<_R1h%EN@^qhM*W}l6x zB}h1^!z&eT*trpuM$LfF=0NtV08`%tTxQK-2I;(sRM%!8Z{<)4r+h(R-HjaL?1?PM zD5C3fCZ0q!=xyFXZjLW2Zq0}fSFJmzxBLn)#ly{!wLQ_X(6YMoE)nx+hHqQk#_Wyq zfv}1iv~f>Jj!0{_zB1|fqb%AN!puS?4#pr5qS5?i!L0@AZsd3p7-G(@*6Ti&_5Fky zR6%jeKBZjUS=oy}j^g{(*K}VdDqLalhBjD?Lq%t>Cx-}$yP-9W-gtr|h3G!GhMmHu zB%=O3?Q>TlAs3~sEe~8XZH7TY-cplu-N;8R0J|`q?uFSF$p=)%mDv0q~m-B}#Ph?LMk3pcmBC4ugml7>Fb=Hkhp8s`{@>(ZSKZE9P{k zAs)wT_~tTIG3(gQ&36Fo@+(-{{T&c7;gRlA1Y%hz69m=P--8dsTH%t%3#FsWo?|tOXASQA zOQF?;DExBO`f_sj@kG&^MtzXf!TjTT;a2+{5OOxs zmL(g91gBhnqmOi?2MiB(S`S3&{7QYn8(qd5gP~4+2wRUxu7h~Ennp5K$aw>VcL7HG z!^)gq&Sg}SZI4~w2^L0>zcR#?+?r-xr@8s08+Odi=xf0d>odTI%hJ@DE@s-T+mJ$# z#@xqr-Gu*WEUzM}p`R*(iVGw)|M(oDA{sY7N5ykbbHkkSvo*!oP~oJeyEGlJF67zw zG%Zf`UJ}u${log^uR2_2)kaUWJEYLYH)mzJ9*ZWlQ({$`>Z4-RtNpc*+%Yfr*WY=0?*eXDaLjNtnx!AHC;CxEs_7lbq|yAaDwOA>{IG=zVNUUMw2BLc=wXB!2j5@XTVydrPZ*^Seh zdq()D-}hlxW;BgQ_-$Bw7?EZJMlYvY=(?)k$ivDF>*cK96EbM(bTdvlE$%_Uv+DJQ z@^;&ZwU~!LsqL5bGbhA~>z-WQysDaYFG;F7A70fyvB}XDb0EE24~WLzRs?s34jDuj%-& cpV<(feB~KiITJAk_FsI~Cr_dNvbYfQHxo3P)&Kwi From 9aafc003cb36e4f6e8e502e4cf0e7856423f6a28 Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 12:19:12 -0700 Subject: [PATCH 15/72] vc=31: smoother swipe-to-minimize MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Rewrote the drag-to-dismiss state machine. Old version launched a coroutine per pointer event to call Animatable.snapTo (which is suspend) — multiple launches racing per frame caused the stutter. Two-state pattern now: liveDrag (mutableFloatStateOf) — updated synchronously inside rememberDraggableState's callback. One state write per pointer event, no coroutine spawn during the drag itself. releaseAnim (Animatable) — driven by a single coroutine in Modifier.draggable's onDragStopped. Either spring-back to 0 or slide off-screen + onMinimize. graphicsLayer reads liveDrag when actively dragging, releaseAnim otherwise — a single Boolean gate. Bonus: dismiss now SLIDES the page off-screen before popping nav, instead of cutting. tween(220ms, FastOutLinearInEasing). Spring-back on a short drag uses MediumBouncy/MediumLow for a real spring feel instead of a hard snap. Fling-velocity threshold (600dp/s) also counts — flick-down past 600dp/s dismisses even if the drag distance was short. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- .../straw/feature/detail/VideoDetailScreen.kt | 92 +++++++++++++------ 2 files changed, 66 insertions(+), 30 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 021a8e0ff..ce37f0b7c 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 30 -const val STRAW_VERSION_NAME = "0.1.0-AP" +const val STRAW_VERSION_CODE = 31 +const val STRAW_VERSION_NAME = "0.1.0-AQ" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index 502314b25..59f48f148 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -13,11 +13,15 @@ import android.util.Rational import android.widget.Toast import androidx.annotation.OptIn import androidx.compose.animation.core.Animatable +import androidx.compose.animation.core.FastOutLinearInEasing +import androidx.compose.animation.core.Spring import androidx.compose.animation.core.spring import androidx.compose.animation.core.tween import androidx.compose.foundation.background import androidx.compose.foundation.clickable -import androidx.compose.foundation.gestures.detectVerticalDragGestures +import androidx.compose.foundation.gestures.Orientation +import androidx.compose.foundation.gestures.draggable +import androidx.compose.foundation.gestures.rememberDraggableState import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Column @@ -63,14 +67,13 @@ import androidx.compose.runtime.collectAsState import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember -import androidx.compose.runtime.rememberCoroutineScope import androidx.compose.runtime.setValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.draw.clip import androidx.compose.ui.graphics.Color import androidx.compose.ui.graphics.graphicsLayer -import androidx.compose.ui.input.pointer.pointerInput +import androidx.compose.ui.platform.LocalConfiguration import androidx.compose.ui.platform.LocalContext import androidx.compose.ui.platform.LocalDensity import androidx.compose.ui.text.font.FontWeight @@ -98,7 +101,6 @@ import com.sulkta.straw.feature.search.StreamItem import com.sulkta.straw.util.formatCount import com.sulkta.straw.util.formatViews import com.sulkta.straw.util.stripHtml -import kotlinx.coroutines.launch @OptIn(ExperimentalLayoutApi::class, UnstableApi::class) @Composable @@ -132,39 +134,73 @@ fun VideoDetailScreen( } // Swipe-down to minimize. The drag handle is the inline player surface - // (the 16:9 box at the top); we translate the WHOLE page with it so the + // at the top of the page; we translate the WHOLE page with it so the // motion reads as "the video is being tucked away" rather than "this - // one widget slid." The graphicsLayer + alpha/scale fade keeps it - // smooth — no per-pixel coroutine churn from offset { }. + // one widget slid." + // + // Two-state pattern so the drag stays smooth at 120fps: + // liveDrag — mutableFloatStateOf updated SYNCHRONOUSLY in + // rememberDraggableState's callback. One state write + // per pointer event, no coroutine spawn. + // releaseAnim — Animatable driven by a single coroutine that + // runs only when the finger leaves (spring back + // if short, slide off-screen + onMinimize if past + // threshold or flung). + // graphicsLayer reads whichever is active via the `dragging` flag. + // The old single-Animatable / scope.launch-per-pixel pattern + // raced coroutines for every drag delta and stuttered on fast + // gestures; this doesn't. val density = LocalDensity.current + val configuration = LocalConfiguration.current val dismissThresholdPx = with(density) { 140.dp.toPx() } - val dragY = remember { Animatable(0f) } - val scope = rememberCoroutineScope() - val playerDragModifier = Modifier.pointerInput(Unit) { - detectVerticalDragGestures( - onDragEnd = { - if (dragY.value > dismissThresholdPx) { - onMinimize() - } else { - scope.launch { dragY.animateTo(0f, spring()) } - } - }, - onDragCancel = { - scope.launch { dragY.animateTo(0f, spring()) } - }, - onVerticalDrag = { _, dy -> - scope.launch { - dragY.snapTo((dragY.value + dy).coerceAtLeast(0f)) - } - }, - ) + val flingVelocityThreshold = with(density) { 600.dp.toPx() } + val screenHeightPx = with(density) { configuration.screenHeightDp.dp.toPx() } + var liveDrag by remember { mutableStateOf(0f) } + var dragging by remember { mutableStateOf(false) } + val releaseAnim = remember { Animatable(0f) } + val draggableState = rememberDraggableState { delta -> + liveDrag = (liveDrag + delta).coerceAtLeast(0f) } + val playerDragModifier = Modifier.draggable( + orientation = Orientation.Vertical, + state = draggableState, + onDragStarted = { + releaseAnim.stop() + liveDrag = releaseAnim.value + dragging = true + }, + onDragStopped = { velocity -> + val shouldDismiss = + liveDrag > dismissThresholdPx || velocity > flingVelocityThreshold + releaseAnim.snapTo(liveDrag) + dragging = false + if (shouldDismiss) { + // Slide the rest of the way off-screen, then pop. The + // pop happens AFTER the animation so the user sees the + // page leave under their finger instead of a hard cut. + releaseAnim.animateTo( + screenHeightPx, + tween(durationMillis = 220, easing = FastOutLinearInEasing), + ) + onMinimize() + } else { + releaseAnim.animateTo( + 0f, + spring( + dampingRatio = Spring.DampingRatioMediumBouncy, + stiffness = Spring.StiffnessMediumLow, + ), + ) + } + liveDrag = 0f + }, + ) Column( modifier = Modifier .fillMaxSize() .graphicsLayer { - val y = dragY.value + val y = if (dragging) liveDrag else releaseAnim.value translationY = y val p = (y / dismissThresholdPx).coerceIn(0f, 1f) alpha = 1f - p * 0.4f From 544035b30c47c311edbbf548e0022eaa6dc4c61b Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 12:34:02 -0700 Subject: [PATCH 16/72] =?UTF-8?q?vc=3D32:=20subs=20feed=20=E2=80=94=20date?= =?UTF-8?q?s,=20watched=20filter,=20infinite=20scroll,=20avatar=20fallback?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Subscription feed is now actually a feed instead of a teaser. Rust (strawcore wrapper) Added upload_date_relative and uploader_avatar to SearchItem so Kotlin can see both. strawcore-core already extracts upload_date relative ("2 days ago") on every StreamInfoItem and uploader_avatars on most — we were just throwing them away in from_core. Fixed. StreamItem uploadDateRelative + uploaderAvatar fields added. Every construction site (search/channel/detail/feed) plumbs them through. SubscriptionFeedViewModel Per-channel cap 5 → 30. With 30 subs that's up to 900 items in memory; ConcurrentHashMap entries are small enough. Sort by parsed relative recency (RECENCY_RE on the "N ago" string, signed seconds-ago, tied items break by viewCount). Opportunistic avatar backfill: every successful channelInfo fetch updates the stored ChannelRef.avatar via Subscriptions.updateAvatar when strawcore returns a non-null avatar — fixes the "I just subbed to a channel and the chip has no icon" case where the channel header parser missed the avatar at subscribe time but the feed-fetch layout returns one. SubsPane (StrawHome) Hide-watched FilterChip (session-sticky). Cross-references History.watches by 11-char YT video ID; filters out anything you've already watched. "All caught up — nothing unwatched" empty state. Infinite scroll: PAGE_SIZE = 20. derivedStateOf-gated snapshotFlow watches the LazyListState's lastVisibleItem index; when within 5 items of the bottom, bumps visibleCount by 20. "Loading more..." spinner at the bottom while there's more to show. Visible-count resets to PAGE_SIZE when the underlying list shrinks (refresh dropped items, filter just engaged). FeedRow now shows: uploader · views · "3 days ago". SubChip Lettered fallback when ch.avatar is null. PrimaryContainer-tinted circle with the first letter — no more broken-image placeholder while the feed-fetch backfills the real avatar. SubscriptionsStore updateAvatar(url, avatar) for the backfill path. Atomic via updateAndGet, persists to SharedPreferences. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- rust/strawcore/src/search.rs | 11 ++ .../main/kotlin/com/sulkta/straw/StrawHome.kt | 138 +++++++++++++++++- .../sulkta/straw/data/SubscriptionsStore.kt | 13 ++ .../straw/feature/channel/ChannelViewModel.kt | 2 + .../feature/detail/VideoDetailViewModel.kt | 4 + .../feature/feed/SubscriptionFeedViewModel.kt | 93 +++++++++--- .../straw/feature/search/SearchViewModel.kt | 5 + 8 files changed, 244 insertions(+), 26 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index ce37f0b7c..e6a729b1a 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 31 -const val STRAW_VERSION_NAME = "0.1.0-AQ" +const val STRAW_VERSION_CODE = 32 +const val STRAW_VERSION_NAME = "0.1.0-AR" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/rust/strawcore/src/search.rs b/rust/strawcore/src/search.rs index b4f96395e..c7f573459 100644 --- a/rust/strawcore/src/search.rs +++ b/rust/strawcore/src/search.rs @@ -15,11 +15,16 @@ pub struct SearchItem { pub title: String, pub uploader: String, pub uploader_url: Option, + pub uploader_avatar: Option, pub thumbnail: Option, /// Duration in seconds. 0 = live/unknown. pub duration_seconds: i64, /// Reported view count. 0 = unknown. pub view_count: i64, + /// Relative upload date as YT renders it ("2 days ago", "3 weeks + /// ago"). Empty if not extracted. Strawcore-core already populates + /// this on StreamInfoItem; we just pass it through. + pub upload_date_relative: String, } pub(crate) fn from_core(item: StreamInfoItem) -> SearchItem { @@ -32,11 +37,16 @@ pub(crate) fn from_core(item: StreamInfoItem) -> SearchItem { .thumbnails .last() .map(|i| i.url().to_string()); + let uploader_avatar = item + .uploader_avatars + .last() + .map(|i| i.url().to_string()); SearchItem { url: item.url, title: item.name, uploader: item.uploader_name, uploader_url, + uploader_avatar, thumbnail, duration_seconds: item.duration_seconds, view_count: if item.view_count < 0 { @@ -44,6 +54,7 @@ pub(crate) fn from_core(item: StreamInfoItem) -> SearchItem { } else { item.view_count }, + upload_date_relative: item.upload_date_relative, } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt index 85c4b9a6e..dd23aeae4 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt @@ -24,6 +24,7 @@ import androidx.compose.foundation.layout.width import androidx.compose.foundation.lazy.LazyColumn import androidx.compose.foundation.lazy.LazyRow import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.lazy.rememberLazyListState import androidx.compose.foundation.shape.CircleShape import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material.icons.Icons @@ -37,6 +38,8 @@ import androidx.compose.material.icons.filled.Settings import androidx.compose.material3.CircularProgressIndicator import androidx.compose.material3.DrawerValue import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.FilterChip +import androidx.compose.material3.FilterChipDefaults import androidx.compose.material3.HorizontalDivider import androidx.compose.material3.Icon import androidx.compose.material3.IconButton @@ -54,11 +57,14 @@ import androidx.compose.material3.rememberDrawerState import androidx.compose.runtime.Composable import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.derivedStateOf import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableIntStateOf import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember import androidx.compose.runtime.rememberCoroutineScope import androidx.compose.runtime.setValue +import androidx.compose.runtime.snapshotFlow import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.draw.clip @@ -262,8 +268,35 @@ private fun SubsPane( ) { val subs by Subscriptions.get().subs.collectAsState() val feed by feedVm.ui.collectAsState() + val watches by History.get().watches.collectAsState() LaunchedEffect(subs) { feedVm.refreshIfStale() } + // Filter + pagination state. hideWatched is sticky for the session + // (no SharedPreferences yet — easy to add if Cobb wants persistence). + // visibleCount starts at PAGE_SIZE and grows by PAGE_SIZE every time + // the scroll passes ~5 items from the bottom of what's currently + // visible. + var hideWatched by remember { mutableStateOf(false) } + var visibleCount by remember { mutableIntStateOf(PAGE_SIZE) } + + // O(1) lookup for the watched-filter; rebuild only when watches + // change. Just the video IDs because URLs vary by tracking params. + val watchedIds = remember(watches) { watches.map { it.videoId }.toSet() } + + val filteredItems = remember(feed.items, hideWatched, watchedIds) { + if (!hideWatched) feed.items + else feed.items.filterNot { extractVideoId(it.url) in watchedIds } + } + // Reset pagination when the underlying list changes so the user + // doesn't end up looking at "no more items" after a refresh. + LaunchedEffect(filteredItems) { + if (visibleCount > filteredItems.size.coerceAtLeast(PAGE_SIZE)) { + visibleCount = PAGE_SIZE + } + } + val displayed = filteredItems.take(visibleCount) + val hasMore = filteredItems.size > visibleCount + Column { if (subs.isEmpty()) { Text( @@ -287,6 +320,13 @@ private fun SubsPane( color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.weight(1f), ) + FilterChip( + selected = hideWatched, + onClick = { hideWatched = !hideWatched }, + label = { Text("Hide watched") }, + colors = FilterChipDefaults.filterChipColors(), + ) + Spacer(modifier = Modifier.width(8.dp)) TextButton(onClick = { feedVm.refresh() }) { Text(if (feed.loading) "..." else "Refresh") } @@ -329,18 +369,76 @@ private fun SubsPane( color = MaterialTheme.colorScheme.error, ) } + feed.items.isNotEmpty() && filteredItems.isEmpty() -> { + Text( + "All caught up — nothing unwatched.", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } else -> { - LazyColumn { - items(feed.items) { item -> + val listState = rememberLazyListState() + // Bump visibleCount when the user scrolls within 5 items + // of the current bottom. snapshotFlow + derivedStateOf + // keeps this off the per-frame recompose path. + val nearBottom by remember { + derivedStateOf { + val info = listState.layoutInfo + val lastVisible = info.visibleItemsInfo.lastOrNull()?.index ?: -1 + lastVisible >= info.totalItemsCount - 5 + } + } + LaunchedEffect(displayed.size, hasMore) { + snapshotFlow { nearBottom }.collect { atEnd -> + if (atEnd && hasMore) { + visibleCount = (visibleCount + PAGE_SIZE) + .coerceAtMost(filteredItems.size) + } + } + } + LazyColumn(state = listState) { + items(displayed) { item -> FeedRow(item) { onOpenVideo(item.url, item.title) } HorizontalDivider() } + if (hasMore) { + item { + Row( + modifier = Modifier + .fillMaxWidth() + .padding(16.dp), + horizontalArrangement = Arrangement.Center, + verticalAlignment = Alignment.CenterVertically, + ) { + CircularProgressIndicator(modifier = Modifier.size(16.dp)) + Spacer(modifier = Modifier.width(8.dp)) + Text( + "Loading more...", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } + } } } } } } +private const val PAGE_SIZE = 20 + +/** + * Extract the YouTube video ID from a watch URL so we can cross-check + * against History.watches (which stores videoId, not full URL). Handles + * the common forms: youtube.com/watch?v=XXXXXXXXXXX and youtu.be/X... + * Returns empty string when nothing matches — callers compare against + * watchedIds, so an empty string just won't filter anything out. + */ +private val VIDEO_ID_RE = Regex("(?:v=|/)([A-Za-z0-9_-]{11})(?:[?&#].*)?$") +private fun extractVideoId(url: String): String = + VIDEO_ID_RE.find(url)?.groupValues?.getOrNull(1).orEmpty() + @Composable private fun FeedRow(item: StreamItem, onClick: () -> Unit) { Row( @@ -374,6 +472,10 @@ private fun FeedRow(item: StreamItem, onClick: () -> Unit) { append(" · ") append(formatViews(item.viewCount)) } + if (item.uploadDateRelative.isNotBlank()) { + append(" · ") + append(item.uploadDateRelative) + } }, style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant, @@ -437,11 +539,33 @@ private fun SubChip( .clickable { onOpenChannel(ch.url, ch.name) }, horizontalAlignment = Alignment.CenterHorizontally, ) { - AsyncImage( - model = ch.avatar, - contentDescription = null, - modifier = Modifier.size(56.dp).clip(CircleShape), - ) + if (ch.avatar.isNullOrBlank()) { + // Lettered fallback — strawcore can return a null avatar + // when the channel header layout doesn't include one (more + // common on smaller channels). Feed-fetch backfills this + // asynchronously via Subscriptions.updateAvatar, but until + // it arrives we still want SOMETHING visible. + Box( + modifier = Modifier + .size(56.dp) + .clip(CircleShape) + .background(MaterialTheme.colorScheme.primaryContainer), + contentAlignment = Alignment.Center, + ) { + Text( + text = ch.name.firstOrNull()?.uppercase().orEmpty(), + style = MaterialTheme.typography.titleMedium, + color = MaterialTheme.colorScheme.onPrimaryContainer, + fontWeight = FontWeight.SemiBold, + ) + } + } else { + AsyncImage( + model = ch.avatar, + contentDescription = null, + modifier = Modifier.size(56.dp).clip(CircleShape), + ) + } Spacer(modifier = Modifier.height(4.dp)) Text( text = ch.name, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt index b90d9b406..303ac4678 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt @@ -51,6 +51,19 @@ class SubscriptionsStore(context: Context) { persist(next) } + /** + * Update the cached avatar for an already-subscribed channel. Used + * by the subs feed fetch when it pulls a fresh ChannelInfo and the + * stored ChannelRef has a null avatar (channel header parser missed + * it at subscribe time). No-op for non-subscribed URLs. + */ + fun updateAvatar(channelUrl: String, avatar: String) { + val next = _subs.updateAndGet { cur -> + cur.map { if (it.url == channelUrl) it.copy(avatar = avatar) else it } + } + persist(next) + } + fun clear() { // Same atomic-update path as toggle — protects against a concurrent // toggle racing the clear and persisting [new-item] after the diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt index 90dd8ea05..fe3a38adc 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt @@ -42,9 +42,11 @@ class ChannelViewModel : ViewModel() { title = v.title.ifBlank { "(no title)" }, uploader = v.uploader, uploaderUrl = v.uploaderUrl, + uploaderAvatar = v.uploaderAvatar ?: ch.avatar, thumbnail = v.thumbnail, durationSeconds = v.durationSeconds, viewCount = v.viewCount, + uploadDateRelative = v.uploadDateRelative, ) } _ui.value = ChannelUiState( diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt index 476615c25..43eaceebb 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt @@ -129,9 +129,11 @@ class VideoDetailViewModel : ViewModel() { title = r.title.ifBlank { "(no title)" }, uploader = r.uploader, uploaderUrl = r.uploaderUrl, + uploaderAvatar = r.uploaderAvatar, thumbnail = r.thumbnail, durationSeconds = r.durationSeconds, viewCount = r.viewCount, + uploadDateRelative = r.uploadDateRelative, ) } @@ -151,9 +153,11 @@ class VideoDetailViewModel : ViewModel() { title = v.title.ifBlank { "(no title)" }, uploader = v.uploader.ifBlank { uploader }, uploaderUrl = v.uploaderUrl ?: uploaderUrl, + uploaderAvatar = v.uploaderAvatar ?: ch.avatar, thumbnail = v.thumbnail, durationSeconds = v.durationSeconds, viewCount = v.viewCount, + uploadDateRelative = v.uploadDateRelative, ) } }.getOrDefault(emptyList()) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt index f69be037f..b6fc0c49b 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt @@ -3,18 +3,15 @@ * SPDX-License-Identifier: GPL-3.0-or-later * * Aggregate latest videos across all subscribed channels into a single - * feed. Fans out per-channel channelInfo() fetches in parallel, caches - * each channel's videos independently, merges by view-count desc, caps - * at 200 items. + * feed. Per-channel fan-out with independent TTL caches. Bigger per + * channel limit so the feed actually feels "show me everything new", + * sorted by parsed relative upload date so the merged list reads + * newest-first across channels. * - * Each per-channel cache entry has its own TTL so adding one new - * subscription doesn't invalidate the other 49 — only the new one - * actually goes to the network on the next refresh. - * - * Concurrency hardening: cancel any in-flight refresh when a new one - * starts, cap parallelism with a Semaphore so 100+ subs don't slam YT, - * time-bound each per-channel fetch so one hung channel can't stall the - * whole batch. + * Also opportunistically refreshes a channel's avatar in + * SubscriptionsStore — strawcore can occasionally return null on first + * subscribe (the channel header layout varies); a subsequent feed fetch + * will fill it in automatically. */ package com.sulkta.straw.feature.feed @@ -63,6 +60,13 @@ class SubscriptionFeedViewModel : ViewModel() { /** Cap parallel network fetches even with 100+ subs. */ private val parallelism = 8 + /** + * Videos pulled per channel. Bumped from 5 → 30 so "show me + * everything new from my subs" actually has body to it; cheap to + * keep in memory at this size (30 subs * 30 videos = 900 max). + */ + private val perChannelMax = 30 + /** Live refresh job, so spam-tapping Refresh doesn't fan out racing fetches. */ private var inFlight: Job? = null @@ -116,19 +120,30 @@ class SubscriptionFeedViewModel : ViewModel() { } private suspend fun fetchChannelInto(ch: ChannelRef) { - val perChannelMax = 5 - val fetched = withTimeoutOrNull(perChannelTimeoutMs) { + val outcome = withTimeoutOrNull(perChannelTimeoutMs) { runCatching { val info = uniffi.strawcore.channelInfo(ch.url) + // Opportunistic avatar refresh: if our stored ChannelRef + // didn't capture an avatar at subscribe-time (channel + // header parser missed it, or user subscribed before the + // page loaded), backfill from the channel info now. + val freshAvatar = info.avatar + if (!freshAvatar.isNullOrBlank() && freshAvatar != ch.avatar) { + runCatching { + Subscriptions.get().updateAvatar(ch.url, freshAvatar) + } + } info.videos.take(perChannelMax).map { v -> StreamItem( url = v.url, title = v.title.ifBlank { "(no title)" }, uploader = v.uploader.ifBlank { ch.name }, uploaderUrl = v.uploaderUrl ?: ch.url, + uploaderAvatar = v.uploaderAvatar ?: freshAvatar ?: ch.avatar, thumbnail = v.thumbnail, durationSeconds = v.durationSeconds, viewCount = v.viewCount, + uploadDateRelative = v.uploadDateRelative, ) } }.onFailure { @@ -141,8 +156,8 @@ class SubscriptionFeedViewModel : ViewModel() { // Only update the cache on a successful fetch. A timeout/error // leaves any prior cache entry intact, so a glitchy channel // doesn't blank your feed for that channel. - if (fetched.isNotEmpty()) { - channelCache[ch.url] = ChannelCacheEntry(System.currentTimeMillis(), fetched) + if (outcome.isNotEmpty()) { + channelCache[ch.url] = ChannelCacheEntry(System.currentTimeMillis(), outcome) } } @@ -152,7 +167,51 @@ class SubscriptionFeedViewModel : ViewModel() { // fall out of the feed immediately. channelCache.keys.toList().forEach { if (it !in subUrls) channelCache.remove(it) } return channels.flatMap { ch -> channelCache[ch.url]?.items.orEmpty() } - .sortedByDescending { it.viewCount } - .take(200) + // Newest-first across channels. Falls back to viewCount when + // we couldn't parse the relative date (older items + live + // streams come back without one). + .sortedWith( + compareByDescending { it.recencyScore() } + .thenByDescending { it.viewCount }, + ) + // Generous cap. Anything past this is almost certainly noise + // for a feed view; pagination in the UI further slices this. + .take(500) } } + +/** + * Convert "2 days ago" / "3 weeks ago" / "Streamed 5 hours ago" style + * strings into approximate seconds-ago. Higher = more recent (so default + * sort is descending). Returns Long.MIN_VALUE when we can't parse — those + * sink to the bottom of the feed. + * + * Strawcore-core (and YT before it) emits these in English-only locale + * for the InnerTube web client; if we ever localize the extractor this + * regex needs to grow. + */ +private val RECENCY_RE = Regex( + """(\d+)\s+(second|minute|hour|day|week|month|year)s?\s+ago""", + RegexOption.IGNORE_CASE, +) + +private fun StreamItem.recencyScore(): Long { + val s = uploadDateRelative + if (s.isBlank()) return Long.MIN_VALUE + val m = RECENCY_RE.find(s) ?: return Long.MIN_VALUE + val n = m.groupValues[1].toLongOrNull() ?: return Long.MIN_VALUE + val unitSecs: Long = when (m.groupValues[2].lowercase()) { + "second" -> 1 + "minute" -> 60 + "hour" -> 3600 + "day" -> 86_400 + "week" -> 604_800 + "month" -> 2_592_000 // approx 30 days + "year" -> 31_536_000 + else -> return Long.MIN_VALUE + } + // Sign flip: smaller "seconds ago" → larger score (more recent). + // Cap at a sane horizon so a "1 second ago" doesn't overwhelm the + // viewCount tiebreaker on items that are functionally tied. + return -(n * unitSecs) +} diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt index e48aecd83..f44ce5f0f 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt @@ -25,9 +25,12 @@ data class StreamItem( val title: String, val uploader: String, val uploaderUrl: String?, + val uploaderAvatar: String? = null, val thumbnail: String?, val durationSeconds: Long, val viewCount: Long, + /** "2 days ago" / "3 weeks ago" / empty if not extracted. */ + val uploadDateRelative: String = "", ) class SearchViewModel : ViewModel() { @@ -53,9 +56,11 @@ class SearchViewModel : ViewModel() { title = r.title.ifBlank { "(no title)" }, uploader = r.uploader, uploaderUrl = r.uploaderUrl, + uploaderAvatar = r.uploaderAvatar, thumbnail = r.thumbnail, durationSeconds = r.durationSeconds, viewCount = r.viewCount, + uploadDateRelative = r.uploadDateRelative, ) } _ui.value = _ui.value.copy(loading = false, results = items) From 2afdcf3d5cd709d73becd21aecb9810dd2cd0495 Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 12:38:50 -0700 Subject: [PATCH 17/72] =?UTF-8?q?vc=3D32=20fix:=20drop=20SearchItem.upload?= =?UTF-8?q?er=5Favatar=20=E2=80=94=20not=20on=20StreamInfoItem?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit I confused StreamInfo (the big single-video struct, has uploader_avatars: ImageSet) with StreamInfoItem (the card struct used in search results / channel video lists / related streams — no uploader_avatars field). cargoBuildHost caught it: E0609 no field `uploader_avatars`. Drop the field from SearchItem (and from the Kotlin construction sites). For the subs feed and "more from this channel" we already use the channel-level avatar from ChannelInfo.avatar, which is the right granularity anyway (every video from one channel shares one avatar). Per-card uploader avatars on search/related stay null until strawcore-core extracts them on StreamInfoItem too. --- rust/strawcore/src/search.rs | 6 ------ .../com/sulkta/straw/feature/channel/ChannelViewModel.kt | 2 +- .../com/sulkta/straw/feature/detail/VideoDetailViewModel.kt | 3 +-- .../sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt | 2 +- .../com/sulkta/straw/feature/search/SearchViewModel.kt | 1 - 5 files changed, 3 insertions(+), 11 deletions(-) diff --git a/rust/strawcore/src/search.rs b/rust/strawcore/src/search.rs index c7f573459..b85b7ce7f 100644 --- a/rust/strawcore/src/search.rs +++ b/rust/strawcore/src/search.rs @@ -15,7 +15,6 @@ pub struct SearchItem { pub title: String, pub uploader: String, pub uploader_url: Option, - pub uploader_avatar: Option, pub thumbnail: Option, /// Duration in seconds. 0 = live/unknown. pub duration_seconds: i64, @@ -37,16 +36,11 @@ pub(crate) fn from_core(item: StreamInfoItem) -> SearchItem { .thumbnails .last() .map(|i| i.url().to_string()); - let uploader_avatar = item - .uploader_avatars - .last() - .map(|i| i.url().to_string()); SearchItem { url: item.url, title: item.name, uploader: item.uploader_name, uploader_url, - uploader_avatar, thumbnail, duration_seconds: item.duration_seconds, view_count: if item.view_count < 0 { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt index fe3a38adc..027d0bfa9 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt @@ -42,7 +42,7 @@ class ChannelViewModel : ViewModel() { title = v.title.ifBlank { "(no title)" }, uploader = v.uploader, uploaderUrl = v.uploaderUrl, - uploaderAvatar = v.uploaderAvatar ?: ch.avatar, + uploaderAvatar = ch.avatar, thumbnail = v.thumbnail, durationSeconds = v.durationSeconds, viewCount = v.viewCount, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt index 43eaceebb..e269b3f6c 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt @@ -129,7 +129,6 @@ class VideoDetailViewModel : ViewModel() { title = r.title.ifBlank { "(no title)" }, uploader = r.uploader, uploaderUrl = r.uploaderUrl, - uploaderAvatar = r.uploaderAvatar, thumbnail = r.thumbnail, durationSeconds = r.durationSeconds, viewCount = r.viewCount, @@ -153,7 +152,7 @@ class VideoDetailViewModel : ViewModel() { title = v.title.ifBlank { "(no title)" }, uploader = v.uploader.ifBlank { uploader }, uploaderUrl = v.uploaderUrl ?: uploaderUrl, - uploaderAvatar = v.uploaderAvatar ?: ch.avatar, + uploaderAvatar = ch.avatar, thumbnail = v.thumbnail, durationSeconds = v.durationSeconds, viewCount = v.viewCount, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt index b6fc0c49b..bb6ce845d 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt @@ -139,7 +139,7 @@ class SubscriptionFeedViewModel : ViewModel() { title = v.title.ifBlank { "(no title)" }, uploader = v.uploader.ifBlank { ch.name }, uploaderUrl = v.uploaderUrl ?: ch.url, - uploaderAvatar = v.uploaderAvatar ?: freshAvatar ?: ch.avatar, + uploaderAvatar = freshAvatar ?: ch.avatar, thumbnail = v.thumbnail, durationSeconds = v.durationSeconds, viewCount = v.viewCount, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt index f44ce5f0f..40ff14603 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt @@ -56,7 +56,6 @@ class SearchViewModel : ViewModel() { title = r.title.ifBlank { "(no title)" }, uploader = r.uploader, uploaderUrl = r.uploaderUrl, - uploaderAvatar = r.uploaderAvatar, thumbnail = r.thumbnail, durationSeconds = r.durationSeconds, viewCount = r.viewCount, From 69560889ae2b4399fb75607ceef7d013af2dfbb5 Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 12:50:13 -0700 Subject: [PATCH 18/72] vc=33: persistent feed cache + strawcore avatar fix (via strawcore-core) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Channel-avatar issue and the sluggish-load issue both addressed. strawcore-core (Sulkta-Coop/strawcore @ 7c71511) — separate repo, already committed + pushed: Channel parser was only pulling avatar from the legacy c4TabbedHeaderRenderer branch. The newer pageHeaderRenderer (most channels with a 2024+ refreshed header — including WTYP) was returning empty avatars. Added a deep-nested ViewModel walk for pageHeaderRenderer, plus a metadata.channelMetadataRenderer .avatar.thumbnails[] backfill. WTYP and other re-headered channels should now show their icon. Persistent feed cache (data/FeedCacheStore.kt): New SharedPreferences-backed JSON store. ~225 KB at the upper bound (30 subs * 30 items * ~250 bytes), well within SP's comfort zone. Survives process death. SubscriptionFeedViewModel: Hydrates from FeedCacheStore on init. The Subs tab now paints cached items in one frame on cold start, then refreshes stale channels in the background. Persists the cache after each successful refresh via Dispatchers.IO. Per-channel TTL bumped 10min → 30min (disk cache amortizes the cost; stale-from-disk + background-refresh feels like instant). Per-channel timeout 15s → 10s (slow channel rides cached value instead of stalling the batch). Parallelism 8 → 12 (less network-bound now that UI doesn't wait for first byte). StreamItem now @Serializable so the cache can encode it. FeedCache.init wired into StrawApp.onCreate alongside the other SharedPreferences-backed stores. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- .../main/kotlin/com/sulkta/straw/StrawApp.kt | 2 + .../feature/feed/SubscriptionFeedViewModel.kt | 62 ++++++++++++++++--- .../straw/feature/search/SearchViewModel.kt | 1 + 4 files changed, 58 insertions(+), 11 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index e6a729b1a..9319ebcd7 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 32 -const val STRAW_VERSION_NAME = "0.1.0-AR" +const val STRAW_VERSION_CODE = 33 +const val STRAW_VERSION_NAME = "0.1.0-AS" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt index ca36407c9..95be0a44e 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt @@ -6,6 +6,7 @@ package com.sulkta.straw import android.app.Application +import com.sulkta.straw.data.FeedCache import com.sulkta.straw.data.History import com.sulkta.straw.data.Playlists import com.sulkta.straw.data.Settings @@ -23,5 +24,6 @@ class StrawApp : Application() { Settings.init(this) Subscriptions.init(this) Playlists.init(this) + FeedCache.init(this) } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt index bb6ce845d..03eb764f7 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt @@ -19,9 +19,12 @@ package com.sulkta.straw.feature.feed import androidx.lifecycle.ViewModel import androidx.lifecycle.viewModelScope import com.sulkta.straw.data.ChannelRef +import com.sulkta.straw.data.FeedCache +import com.sulkta.straw.data.FeedCacheEntry import com.sulkta.straw.data.Subscriptions import com.sulkta.straw.feature.search.StreamItem import com.sulkta.straw.util.strawLogW +import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.Job import kotlinx.coroutines.async import kotlinx.coroutines.awaitAll @@ -33,6 +36,7 @@ import kotlinx.coroutines.flow.update import kotlinx.coroutines.launch import kotlinx.coroutines.sync.Semaphore import kotlinx.coroutines.sync.withPermit +import kotlinx.coroutines.withContext import kotlinx.coroutines.withTimeoutOrNull import java.util.concurrent.ConcurrentHashMap @@ -47,18 +51,52 @@ class SubscriptionFeedViewModel : ViewModel() { private val _ui = MutableStateFlow(SubscriptionFeedUiState()) val ui: StateFlow = _ui.asStateFlow() - /** Per-channel cache: each entry refreshes independently. */ - private data class ChannelCacheEntry(val fetchedAt: Long, val items: List) - private val channelCache = ConcurrentHashMap() + /** + * Per-channel cache: each entry refreshes independently. Hydrated + * from disk on init via FeedCacheStore so cold app starts can show + * the last successful fetch instantly. ConcurrentHashMap because + * fetchChannelInto writes concurrently from the per-channel + * coroutines; mergeFromCache and refreshIfStale read. + */ + private val channelCache = ConcurrentHashMap() /** Per-channel TTL — Refresh just re-fetches stale entries. */ - private val perChannelTtlMs = 10L * 60 * 1000 + private val perChannelTtlMs = 30L * 60 * 1000 - /** Per-channel fetch timeout — slowest channel can't stall the batch. */ - private val perChannelTimeoutMs = 15_000L + init { + // Hydrate from disk and immediately render the cached items so + // the Subs tab paints in one frame instead of after the network + // round-trip. The refresh that follows replaces stale entries + // in-place — items animate to their new positions via LazyColumn + // key stability (URLs are stable across fetches). + val saved = FeedCache.get().load() + if (saved.isNotEmpty()) { + channelCache.putAll(saved) + val channels = Subscriptions.get().subs.value + if (channels.isNotEmpty()) { + _ui.value = _ui.value.copy( + items = mergeFromCache(channels), + lastFetchedAt = saved.values.maxOfOrNull { it.fetchedAt } ?: 0L, + ) + } + } + } - /** Cap parallel network fetches even with 100+ subs. */ - private val parallelism = 8 + /** + * Per-channel fetch timeout. 10s instead of 15s — a channel that + * hasn't responded in 10s is likely a transient network hiccup or a + * dead channel handle; better to drop it from the batch and ride + * the disk-cache stale value than block the whole feed. + */ + private val perChannelTimeoutMs = 10_000L + + /** + * Parallel network fetches. 12 instead of 8 — with the disk cache + * now buffering UI from network latency, the dominant cost is + * end-to-end batch completion, which is bottle-necked by the + * slowest network round-trip in each parallel group. + */ + private val parallelism = 12 /** * Videos pulled per channel. Bumped from 5 → 30 so "show me @@ -108,6 +146,12 @@ class SubscriptionFeedViewModel : ViewModel() { lastFetchedAt = System.currentTimeMillis(), ) } + // Persist what we just freshened. Off the main thread — + // JSON encode on 30 subs * 30 items is small but not + // free, and SharedPreferences.apply is async anyway. + withContext(Dispatchers.IO) { + runCatching { FeedCache.get().save(channelCache.toMap()) } + } } catch (t: Throwable) { _ui.update { it.copy( @@ -157,7 +201,7 @@ class SubscriptionFeedViewModel : ViewModel() { // leaves any prior cache entry intact, so a glitchy channel // doesn't blank your feed for that channel. if (outcome.isNotEmpty()) { - channelCache[ch.url] = ChannelCacheEntry(System.currentTimeMillis(), outcome) + channelCache[ch.url] = FeedCacheEntry(System.currentTimeMillis(), outcome) } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt index 40ff14603..0b3cc78b3 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt @@ -20,6 +20,7 @@ data class SearchUiState( val error: String? = null, ) +@kotlinx.serialization.Serializable data class StreamItem( val url: String, val title: String, From c74b06436f6795d2fee76952908dbd1c9650f185 Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 12:54:09 -0700 Subject: [PATCH 19/72] vc=33 fix: add FeedCacheStore.kt to git git commit -am only stages tracked files. The new file existed locally but wasn't in the previous commit; build failed with Unresolved reference 'FeedCache' on every site that used it. --- .../com/sulkta/straw/data/FeedCacheStore.kt | 71 +++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/data/FeedCacheStore.kt diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/FeedCacheStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/FeedCacheStore.kt new file mode 100644 index 000000000..70d9a2c1b --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/FeedCacheStore.kt @@ -0,0 +1,71 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Persistent per-channel cache for the subscription feed. Survives + * process death, so opening Subs after a cold start shows the last + * successful fetch immediately instead of waiting 5+ seconds for 30 + * channel browses to resolve. + * + * Storage: SharedPreferences with a single JSON blob. Total payload is + * small (30 subs * 30 items * ~250 bytes = ~225 KB), well within SP's + * comfortable size and well below the multi-MB threshold where you'd + * want to graduate to Room or a file. + * + * Concurrency: writes from the feed VM are debounced via the single + * `persist` call inside fetchChannelInto's success path. Reads happen + * on VM init and are synchronous. + */ + +package com.sulkta.straw.data + +import android.content.Context +import android.content.SharedPreferences +import com.sulkta.straw.feature.search.StreamItem +import kotlinx.serialization.Serializable +import kotlinx.serialization.json.Json + +@Serializable +data class FeedCacheEntry( + val fetchedAt: Long, + val items: List, +) + +private const val PREFS = "straw_feed_cache" +private const val KEY = "cache_v1" + +class FeedCacheStore(context: Context) { + private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) + private val json = Json { ignoreUnknownKeys = true; isLenient = true } + + /** Snapshot of the disk cache. Returns empty map if nothing saved. */ + fun load(): Map = runCatching { + val s = sp.getString(KEY, null) ?: return emptyMap() + json.decodeFromString>(s) + }.getOrDefault(emptyMap()) + + /** Atomic write. Caller is responsible for diffing if needed. */ + fun save(map: Map) { + val s = json.encodeToString(map) + sp.edit().putString(KEY, s).apply() + } + + fun clear() { + sp.edit().remove(KEY).apply() + } +} + +object FeedCache { + @Volatile private var instance: FeedCacheStore? = null + + fun init(context: Context) { + if (instance == null) { + synchronized(this) { + if (instance == null) instance = FeedCacheStore(context.applicationContext) + } + } + } + + fun get(): FeedCacheStore = instance + ?: error("FeedCacheStore not initialized — call FeedCache.init(context)") +} From a776fbf2e419f05f3f3df45fe907e3385614200a Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 13:01:41 -0700 Subject: [PATCH 20/72] =?UTF-8?q?vc=3D34:=20settings=20batch=20=E2=80=94?= =?UTF-8?q?=20theme,=20cache=20toggle,=20log=20dump,=20reactive=20search?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Five things land together — same surface, all the data/settings flow: SettingsStore additions themeMode: System / Light / Dark (default System) cacheEnabled: Bool (default true). Single toggle gates both the subs feed cache (FeedCacheStore) and the new search cache. Theme override StrawActivity reads Settings.themeMode and bypasses isSystemInDarkTheme when Light or Dark is chosen. Changes apply immediately via StateFlow recomposition — no restart needed. SearchCacheStore (new) SharedPreferences JSON of the last 30 searches with 20 items each (~150 KB cap). Serialized via @Serializable StreamItem (already serializable since vc=33). Reactive search SearchViewModel.onQueryChange now scans the merged corpus (saved searches + subs feed cache, ~1500 records max) as the user types past 2 chars. Matches on title or uploader (case-insensitive), dedup by URL, cap 60. UI shows a "Cached results · …" hint when the visible list is from cache so users know it's not the network result yet. submit() now paints any matching cached query immediately, then kicks the network. Network results overwrite cache on success and the cached preview survives network failures so offline users still see something. Cache opt-out Settings switch "Enable local cache" wipes both stores when flipped off. FeedCacheVM + SearchVM both short-circuit their read/write paths when the flag is false. Log dump util/LogDump captures this PID's logcat (-d -v threadtime --pid=) to cacheDir, returns a chooser Intent via FileProvider. New Settings → "Export logs…" button. Toast surfaces the failure reason if the dump command itself fails (sandbox-restricted devices etc.). FileProvider declared in manifest with cache-path "logs"; XML at res/xml/file_paths.xml. Authority = ${applicationId}.fileprovider. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- strawApp/src/main/AndroidManifest.xml | 11 ++ .../kotlin/com/sulkta/straw/StrawActivity.kt | 13 ++- .../main/kotlin/com/sulkta/straw/StrawApp.kt | 2 + .../com/sulkta/straw/data/SearchCacheStore.kt | 81 +++++++++++++ .../com/sulkta/straw/data/SettingsStore.kt | 29 +++++ .../feature/feed/SubscriptionFeedViewModel.kt | 12 +- .../straw/feature/search/SearchScreen.kt | 19 ++- .../straw/feature/search/SearchViewModel.kt | 90 +++++++++++++- .../straw/feature/settings/SettingsScreen.kt | 110 ++++++++++++++++++ .../kotlin/com/sulkta/straw/util/LogDump.kt | 76 ++++++++++++ strawApp/src/main/res/xml/file_paths.xml | 8 ++ 12 files changed, 443 insertions(+), 12 deletions(-) create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/util/LogDump.kt create mode 100644 strawApp/src/main/res/xml/file_paths.xml diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 9319ebcd7..1b854d719 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 33 -const val STRAW_VERSION_NAME = "0.1.0-AS" +const val STRAW_VERSION_CODE = 34 +const val STRAW_VERSION_NAME = "0.1.0-AT" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/AndroidManifest.xml b/strawApp/src/main/AndroidManifest.xml index 87ff57336..d3d86d3e0 100644 --- a/strawApp/src/main/AndroidManifest.xml +++ b/strawApp/src/main/AndroidManifest.xml @@ -60,5 +60,16 @@ + + + + + diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt index 2a5cc65e9..86bc9f577 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt @@ -25,6 +25,8 @@ import androidx.compose.runtime.getValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.media3.common.util.UnstableApi +import com.sulkta.straw.data.Settings +import com.sulkta.straw.data.ThemeMode import com.sulkta.straw.feature.channel.ChannelScreen import com.sulkta.straw.feature.detail.VideoDetailScreen import com.sulkta.straw.feature.download.DownloadsScreen @@ -67,7 +69,16 @@ class StrawActivity : ComponentActivity() { val startUrl = pickYouTubeUrl(intent) setContent { - val scheme = if (isSystemInDarkTheme()) strawDarkColors() else strawLightColors() + // Theme picker: System follows OS, Light/Dark force the + // matching scheme regardless of system setting. + val themeMode by Settings.get().themeMode.collectAsState() + val systemDark = isSystemInDarkTheme() + val dark = when (themeMode) { + ThemeMode.System -> systemDark + ThemeMode.Light -> false + ThemeMode.Dark -> true + } + val scheme = if (dark) strawDarkColors() else strawLightColors() // One MediaController for the whole activity. Every screen pulls // it via LocalStrawController; the minibar overlay below uses it // too. Single player, single source of truth. diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt index 95be0a44e..df0e041e1 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt @@ -9,6 +9,7 @@ import android.app.Application import com.sulkta.straw.data.FeedCache import com.sulkta.straw.data.History import com.sulkta.straw.data.Playlists +import com.sulkta.straw.data.SearchCache import com.sulkta.straw.data.Settings import com.sulkta.straw.data.Subscriptions @@ -25,5 +26,6 @@ class StrawApp : Application() { Subscriptions.init(this) Playlists.init(this) FeedCache.init(this) + SearchCache.init(this) } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt new file mode 100644 index 000000000..7dc05cc62 --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt @@ -0,0 +1,81 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Search-result cache. Holds the last N executed queries and their + * result lists so: + * - Re-running a recent query paints from cache in one frame. + * - Reactive-as-you-type filtering can scan all cached items as + * the user types, surfacing matches before they hit Search. + * + * Sized for SharedPreferences: 30 queries * 20 items each * ~250 bytes + * = ~150 KB worst case. + * + * Skips entirely when Settings.cacheEnabled is false — caller checks + * the flag before reading/writing. + */ + +package com.sulkta.straw.data + +import android.content.Context +import android.content.SharedPreferences +import com.sulkta.straw.feature.search.StreamItem +import kotlinx.serialization.Serializable +import kotlinx.serialization.json.Json + +@Serializable +data class SearchCacheEntry( + val query: String, + val fetchedAt: Long, + val items: List, +) + +private const val PREFS = "straw_search_cache" +private const val KEY = "search_v1" +private const val MAX_QUERIES = 30 +private const val MAX_ITEMS_PER_QUERY = 20 + +class SearchCacheStore(context: Context) { + private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) + private val json = Json { ignoreUnknownKeys = true; isLenient = true } + + fun load(): List = runCatching { + val s = sp.getString(KEY, null) ?: return emptyList() + json.decodeFromString>(s) + }.getOrDefault(emptyList()) + + /** + * Record a freshly-fetched query result. Idempotent: a re-run of + * the same query overwrites the prior entry rather than duplicating. + * Oldest entries fall off when MAX_QUERIES is exceeded. + */ + fun record(query: String, items: List) { + val q = query.trim() + if (q.isEmpty() || items.isEmpty()) return + val capped = items.take(MAX_ITEMS_PER_QUERY) + val now = System.currentTimeMillis() + val current = load() + val without = current.filterNot { it.query.equals(q, ignoreCase = true) } + val next = (listOf(SearchCacheEntry(q, now, capped)) + without).take(MAX_QUERIES) + sp.edit().putString(KEY, json.encodeToString(next)).apply() + } + + fun clear() { + sp.edit().remove(KEY).apply() + } +} + +object SearchCache { + @Volatile private var instance: SearchCacheStore? = null + + fun init(context: Context) { + if (instance == null) { + synchronized(this) { + if (instance == null) instance = SearchCacheStore(context.applicationContext) + } + } + } + + fun get(): SearchCacheStore = instance + ?: error("SearchCacheStore not initialized — call SearchCache.init(context)") +} diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt index 484cfdfe8..499ace926 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt @@ -37,9 +37,17 @@ enum class MaxResolution(val label: String, val ceiling: Int) { P144("144p", 144), } +enum class ThemeMode(val label: String) { + System("Follow system"), + Light("Light"), + Dark("Dark"), +} + private const val PREFS = "straw_settings" private const val KEY_SB_CATS = "sb_categories_v1" private const val KEY_MAX_RES = "max_resolution_v1" +private const val KEY_THEME = "theme_mode_v1" +private const val KEY_CACHE_ENABLED = "cache_enabled_v1" class SettingsStore(context: Context) { private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) @@ -50,6 +58,12 @@ class SettingsStore(context: Context) { private val _maxResolution = MutableStateFlow(loadMaxResolution()) val maxResolution: StateFlow = _maxResolution.asStateFlow() + private val _themeMode = MutableStateFlow(loadThemeMode()) + val themeMode: StateFlow = _themeMode.asStateFlow() + + private val _cacheEnabled = MutableStateFlow(sp.getBoolean(KEY_CACHE_ENABLED, true)) + val cacheEnabled: StateFlow = _cacheEnabled.asStateFlow() + fun toggle(cat: SbCategory) { // Atomic toggle via updateAndGet — see AUD-HIGH note in HistoryStore. val next = _sbCategories.updateAndGet { cur -> @@ -63,6 +77,16 @@ class SettingsStore(context: Context) { sp.edit().putString(KEY_MAX_RES, r.name).apply() } + fun setThemeMode(t: ThemeMode) { + _themeMode.value = t + sp.edit().putString(KEY_THEME, t.name).apply() + } + + fun setCacheEnabled(enabled: Boolean) { + _cacheEnabled.value = enabled + sp.edit().putBoolean(KEY_CACHE_ENABLED, enabled).apply() + } + private fun loadCategories(): Set { val raw = sp.getStringSet(KEY_SB_CATS, null) return if (raw == null) { @@ -77,6 +101,11 @@ class SettingsStore(context: Context) { val name = sp.getString(KEY_MAX_RES, null) ?: return MaxResolution.Auto return MaxResolution.entries.firstOrNull { it.name == name } ?: MaxResolution.Auto } + + private fun loadThemeMode(): ThemeMode { + val name = sp.getString(KEY_THEME, null) ?: return ThemeMode.System + return ThemeMode.entries.firstOrNull { it.name == name } ?: ThemeMode.System + } } object Settings { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt index 03eb764f7..2503a828c 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt @@ -21,6 +21,7 @@ import androidx.lifecycle.viewModelScope import com.sulkta.straw.data.ChannelRef import com.sulkta.straw.data.FeedCache import com.sulkta.straw.data.FeedCacheEntry +import com.sulkta.straw.data.Settings import com.sulkta.straw.data.Subscriptions import com.sulkta.straw.feature.search.StreamItem import com.sulkta.straw.util.strawLogW @@ -69,7 +70,9 @@ class SubscriptionFeedViewModel : ViewModel() { // round-trip. The refresh that follows replaces stale entries // in-place — items animate to their new positions via LazyColumn // key stability (URLs are stable across fetches). - val saved = FeedCache.get().load() + // Skip the hydrate when the user has disabled caching — they + // explicitly don't want disk usage for this. + val saved = if (Settings.get().cacheEnabled.value) FeedCache.get().load() else emptyMap() if (saved.isNotEmpty()) { channelCache.putAll(saved) val channels = Subscriptions.get().subs.value @@ -149,8 +152,11 @@ class SubscriptionFeedViewModel : ViewModel() { // Persist what we just freshened. Off the main thread — // JSON encode on 30 subs * 30 items is small but not // free, and SharedPreferences.apply is async anyway. - withContext(Dispatchers.IO) { - runCatching { FeedCache.get().save(channelCache.toMap()) } + // Skipped entirely when the user has disabled caching. + if (Settings.get().cacheEnabled.value) { + withContext(Dispatchers.IO) { + runCatching { FeedCache.get().save(channelCache.toMap()) } + } } } catch (t: Throwable) { _ui.update { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt index a6809ebc4..fce5263c0 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt @@ -116,10 +116,21 @@ fun SearchScreen( contentAlignment = Alignment.Center, ) { Text("hit enter to search") } - else -> LazyColumn(modifier = Modifier.fillMaxSize()) { - items(state.results) { item -> - ResultRow(item = item) { onOpenVideo(item.url, item.title) } - HorizontalDivider() + else -> Column(modifier = Modifier.fillMaxSize()) { + if (state.fromCache) { + Text( + text = if (state.loading) "Cached results · refreshing…" + else "Cached results · hit Search for fresh", + style = MaterialTheme.typography.labelSmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + modifier = Modifier.padding(bottom = 4.dp), + ) + } + LazyColumn(modifier = Modifier.fillMaxSize()) { + items(state.results) { item -> + ResultRow(item = item) { onOpenVideo(item.url, item.title) } + HorizontalDivider() + } } } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt index 0b3cc78b3..a816c18b2 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt @@ -7,17 +7,28 @@ package com.sulkta.straw.feature.search import androidx.lifecycle.ViewModel import androidx.lifecycle.viewModelScope +import com.sulkta.straw.data.FeedCache import com.sulkta.straw.data.History +import com.sulkta.straw.data.SearchCache +import com.sulkta.straw.data.Settings +import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.asStateFlow import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext data class SearchUiState( val query: String = "", val results: List = emptyList(), val loading: Boolean = false, val error: String? = null, + /** + * True when the visible results came from the local cache and we + * have not yet replaced them with a network response. Lets the UI + * show a faint "from cache" hint without blocking the list. + */ + val fromCache: Boolean = false, ) @kotlinx.serialization.Serializable @@ -40,12 +51,53 @@ class SearchViewModel : ViewModel() { fun onQueryChange(q: String) { _ui.value = _ui.value.copy(query = q) + // Reactive filter: scan every cached item (search-cache + subs + // feed-cache) as the user types. Cheap, runs in-memory, gives + // instant feedback before they hit Enter. Disabled when the + // user has turned off the cache feature. + if (Settings.get().cacheEnabled.value && q.trim().length >= 2) { + val matches = reactiveFilter(q.trim()) + if (matches.isNotEmpty()) { + _ui.value = _ui.value.copy( + results = matches, + fromCache = true, + loading = false, + error = null, + ) + } + } else if (q.isBlank()) { + // Clear cached preview if the box is cleared. + _ui.value = _ui.value.copy(results = emptyList(), fromCache = false) + } } fun submit() { val q = _ui.value.query.trim() if (q.isEmpty()) return - _ui.value = _ui.value.copy(loading = true, error = null, results = emptyList()) + + // Cache hit on submit: show immediately, kick off a refresh + // behind it so the user gets fresh items shortly after. + val cached = if (Settings.get().cacheEnabled.value) { + SearchCache.get().load() + .firstOrNull { it.query.equals(q, ignoreCase = true) } + ?.items + } else null + if (cached != null && cached.isNotEmpty()) { + _ui.value = _ui.value.copy( + loading = true, + error = null, + results = cached, + fromCache = true, + ) + } else { + _ui.value = _ui.value.copy( + loading = true, + error = null, + results = emptyList(), + fromCache = false, + ) + } + viewModelScope.launch { try { // strawcore.search() is suspend on the tokio runtime baked @@ -63,11 +115,22 @@ class SearchViewModel : ViewModel() { uploadDateRelative = r.uploadDateRelative, ) } - _ui.value = _ui.value.copy(loading = false, results = items) + _ui.value = _ui.value.copy( + loading = false, + results = items, + fromCache = false, + ) // Record AFTER the search succeeds so mistyped queries // that error out don't pollute the recent-searches list. runCatching { History.get().recordSearch(q) } + if (Settings.get().cacheEnabled.value) { + withContext(Dispatchers.IO) { + runCatching { SearchCache.get().record(q, items) } + } + } } catch (t: Throwable) { + // Keep the cached preview visible on network failure so + // the user still has something to look at while offline. _ui.value = _ui.value.copy( loading = false, error = t.message ?: t.javaClass.simpleName, @@ -75,4 +138,27 @@ class SearchViewModel : ViewModel() { } } } + + /** + * Walk the merged corpus of cached items (every saved search + + * every subs-feed channel cache) and return items whose title or + * uploader contains the query — case-insensitive, dedup by URL. + * Cheap: even with 30 cached queries * 20 items + 30 channels * 30 + * items it's < 1500 records, plenty fast for an in-memory filter. + */ + private fun reactiveFilter(q: String): List { + val needle = q.lowercase() + val pool = buildList { + SearchCache.get().load().forEach { addAll(it.items) } + FeedCache.get().load().values.forEach { addAll(it.items) } + } + return pool.asSequence() + .filter { item -> + item.title.lowercase().contains(needle) + || item.uploader.lowercase().contains(needle) + } + .distinctBy { it.url } + .take(60) + .toList() + } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt index f3e704b0d..1f8339ca8 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt @@ -40,12 +40,17 @@ import androidx.compose.ui.Modifier import androidx.compose.ui.platform.LocalContext import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.unit.dp +import android.widget.Toast +import com.sulkta.straw.data.FeedCache import com.sulkta.straw.data.History import com.sulkta.straw.data.MaxResolution import com.sulkta.straw.data.SbCategory +import com.sulkta.straw.data.SearchCache import com.sulkta.straw.data.Settings +import com.sulkta.straw.data.ThemeMode import com.sulkta.straw.feature.dataimport.ImportResult import com.sulkta.straw.feature.dataimport.SettingsImport +import com.sulkta.straw.util.LogDump import kotlinx.coroutines.launch @Composable @@ -134,6 +139,81 @@ fun SettingsScreen() { HorizontalDivider() } + Spacer(modifier = Modifier.height(32.dp)) + Text( + "Appearance", + style = MaterialTheme.typography.titleMedium, + fontWeight = FontWeight.SemiBold, + ) + Spacer(modifier = Modifier.height(4.dp)) + Text( + "Light, dark, or follow the system setting.", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + Spacer(modifier = Modifier.height(12.dp)) + val theme by store.themeMode.collectAsState() + ThemeMode.entries.forEach { t -> + Row( + modifier = Modifier + .fillMaxWidth() + .clickable { store.setThemeMode(t) } + .padding(vertical = 10.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Text( + text = if (t == theme) "• ${t.label}" else " ${t.label}", + style = MaterialTheme.typography.bodyLarge, + color = if (t == theme) MaterialTheme.colorScheme.primary + else MaterialTheme.colorScheme.onSurface, + ) + } + HorizontalDivider() + } + + Spacer(modifier = Modifier.height(32.dp)) + Text( + "Local cache", + style = MaterialTheme.typography.titleMedium, + fontWeight = FontWeight.SemiBold, + ) + Spacer(modifier = Modifier.height(4.dp)) + Text( + "Caches the subs feed and recent searches on disk so the app " + + "paints instantly on cold start and you can search " + + "previously-seen videos with no network. ~400 KB max. " + + "Turn it off to save space on low-storage devices.", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + Spacer(modifier = Modifier.height(12.dp)) + val cacheEnabled by store.cacheEnabled.collectAsState() + Row( + modifier = Modifier + .fillMaxWidth() + .padding(vertical = 6.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.SpaceBetween, + ) { + Text( + "Enable local cache", + style = MaterialTheme.typography.bodyLarge, + fontWeight = FontWeight.SemiBold, + ) + Switch( + checked = cacheEnabled, + onCheckedChange = { checked -> + store.setCacheEnabled(checked) + if (!checked) { + // Wipe on disable — leaving stale bytes around + // defeats the purpose of opting out. + FeedCache.get().clear() + SearchCache.get().clear() + } + }, + ) + } + Spacer(modifier = Modifier.height(32.dp)) Text( "History", @@ -150,6 +230,36 @@ fun SettingsScreen() { } } + Spacer(modifier = Modifier.height(32.dp)) + Text( + "Diagnostics", + style = MaterialTheme.typography.titleMedium, + fontWeight = FontWeight.SemiBold, + ) + Spacer(modifier = Modifier.height(4.dp)) + Text( + "Dump this app's recent logcat to a text file and open the " + + "system share sheet — attach it when reporting an issue.", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + Spacer(modifier = Modifier.height(12.dp)) + OutlinedButton(onClick = { + val outcome = LogDump.capture(context) + outcome.onSuccess { intent -> + context.startActivity(android.content.Intent.createChooser(intent, "Share Straw logs")) + } + outcome.onFailure { t -> + Toast.makeText( + context, + "Log dump failed: ${t.message ?: t.javaClass.simpleName}", + Toast.LENGTH_LONG, + ).show() + } + }) { + Text("Export logs…") + } + Spacer(modifier = Modifier.height(32.dp)) Text( "Import from NewPipe / Tubular", diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/util/LogDump.kt b/strawApp/src/main/kotlin/com/sulkta/straw/util/LogDump.kt new file mode 100644 index 000000000..9b4675aeb --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/util/LogDump.kt @@ -0,0 +1,76 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Capture this process's logcat into a file and return a share Intent. + * Used from the Settings → "Export logs" action so users can attach a + * log dump when reporting a problem. + * + * NOTE: Android limits logcat-via-Runtime.exec to the calling app's + * own UID on API 30+, so this captures Straw's own log lines only + * (plus a sliver of system-wide messages tagged by our PID). No + * other app's logs are exposed. + */ + +package com.sulkta.straw.util + +import android.content.Context +import android.content.Intent +import android.net.Uri +import android.os.Process +import androidx.core.content.FileProvider +import java.io.File +import java.io.IOException +import java.text.SimpleDateFormat +import java.util.Date +import java.util.Locale + +object LogDump { + + /** + * Pull recent logcat, write to a file in cacheDir, return a + * share-able Intent. Caller is responsible for `startActivity`. + * Returns null when the dump command itself fails — the caller + * shows a Toast with the error. + */ + fun capture(context: Context): Result = runCatching { + val pid = Process.myPid() + val timestamp = SimpleDateFormat("yyyyMMdd-HHmmss", Locale.US).format(Date()) + val outFile = File(context.cacheDir, "straw-logs-$timestamp.txt") + + // -d dump-and-exit (no follow), -v threadtime is the + // most-greppable format, and the --pid filter restricts to + // our process so we don't accidentally exfiltrate sibling + // apps' chatter even when the system would allow it. + val cmd = arrayOf( + "logcat", + "-d", + "-v", + "threadtime", + "--pid=$pid", + ) + val proc = ProcessBuilder(*cmd) + .redirectErrorStream(true) + .start() + outFile.outputStream().use { out -> + proc.inputStream.copyTo(out) + } + val exit = proc.waitFor() + if (exit != 0) { + throw IOException("logcat exit=$exit") + } + if (outFile.length() == 0L) { + throw IOException("logcat produced 0 bytes (sandbox restriction?)") + } + + // FileProvider authority — declared in AndroidManifest below. + val authority = "${context.packageName}.fileprovider" + val uri: Uri = FileProvider.getUriForFile(context, authority, outFile) + Intent(Intent.ACTION_SEND).apply { + type = "text/plain" + putExtra(Intent.EXTRA_STREAM, uri) + putExtra(Intent.EXTRA_SUBJECT, "Straw logs $timestamp") + addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION) + } + } +} diff --git a/strawApp/src/main/res/xml/file_paths.xml b/strawApp/src/main/res/xml/file_paths.xml new file mode 100644 index 000000000..92e012475 --- /dev/null +++ b/strawApp/src/main/res/xml/file_paths.xml @@ -0,0 +1,8 @@ + + + + + From e76a325faa6758592d0875d00f1dd852b2b04ae3 Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 13:27:30 -0700 Subject: [PATCH 21/72] =?UTF-8?q?vc=3D35:=20audit-fix=20sprint=20=E2=80=94?= =?UTF-8?q?=205=20CRIT=20+=2014=20HIGH=20+=20opportunistic=20MEDs?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Three Opus max-effort audits (CVE/security, code-health, function- correctness) on the vc=34 surface returned a consolidated punch list of 5 CRIT + 14 HIGH + ~10 MED. This commit lands all CRIT + HIGH + the cheap MEDs in one cohesive pass. CRIT — privacy + main-thread blocks S1 IosSafeHttpDataSource was logging full pre-signed googlevideo URLs (signature/sig/pot/expire/cpn) via raw android.util.Log.i (no DEBUG gate). Then LogDump.capture would scrape its own PID's logcat and ship it via the share sheet — a "report a bug to Telegram" silently exfiltrated session credentials. Fixed by switching all log calls to strawLogD/strawLogW (gated on BuildConfig.DEBUG), dropping the full-URL log entirely, and adding a regex scrub pass in LogDump for googlevideo URLs + signed-param keys before the file hits disk. S2 Downloader.enqueue handed signed googlevideo URLs to the system DownloadManager, where they leak into DM's SQLite, logcat, the system notification, and apps holding ACCESS_DOWNLOAD_MANAGER. Set VISIBILITY_HIDDEN + setVisibleInDownloadsUi(false) so the URL never surfaces in any external surface. Added the DOWNLOAD_WITHOUT_NOTIFICATION permission DM requires. S3 SettingsImport extracted the user's full newpipe.db (every sub, watch, search) into cacheDir, deleted on finally. A force-kill mid-import left the DB on disk indefinitely. Wrapped cleanup in withContext(NonCancellable), switched workDir to createTempFile (unguessable name), and added StrawApp.onCreate sweep of stale newpipe-import-* dirs on every cold start. C1 SearchViewModel.reactiveFilter ran a fresh SharedPreferences. getString + Json.decodeFromString on FeedCache (~225 KB) AND SearchCache (~150 KB) on EVERY keystroke. Hoisted into a MutableStateFlow> pool, built once on Dispatchers.IO at VM init and refreshed after each successful submit. Reactive filter now walks an in-memory list. C2 SubscriptionFeedViewModel.init did the same FeedCache.load() synchronously on the main thread at construction (first compose pass blocked on the JSON decode). Moved into viewModelScope.launch + withContext(Dispatchers.IO). HIGH — function correctness + defense in depth B1+B2 SearchScreen when-branch order: loading + error short- circuited before the results branch, hiding the cached preview the VM explicitly kept visible on cache-hit + on network failure. Refactored to render the cached list under a thin progress bar / error banner instead. B3 Downloads "tap completed row" silently failed since minSdk 24 (FileUriExposedException on the file:// URI). Route through FileProvider with new file_paths.xml entries for Movies/audio + Movies/video. B6 Manifest VIEW intent-filter was missing music.youtube.com and youtube-nocookie.com hosts even though YT_HOSTS allowed them — added both. B7 SponsorBlockSkipLoop fired one Toast per skip with no rate limit; sponsor-dense videos painted 20+ Toasts over 40s after the seeks completed. 3s rate limit per cur.streamUrl. Q8 resolvePlayback.pickVideo fallback used maxByOrNull when the comment said "lowest available" — a 480p-capped user on a 1080p-only upload got 1080p (their data cap blown). Switched to minByOrNull { height } when nothing fits the cap. S1 SettingsImport extractZip had no size or entry-count caps — zip-bomb could fill cacheDir. Added MAX_DB_BYTES (256 MB), MAX_PREFS_BYTES (1 MB), MAX_ZIP_ENTRIES (64). copyBounded / readBoundedBytes helpers replace the unbounded copyTo / readBytes. S2 Manifest: android:allowBackup=false + android:dataExtractionRules=@xml/data_extraction_rules.xml + android:fullBackupContent=false. Excludes root/file/database/ sharedpref/external from both cloud-backup and device-transfer so the user's full search + watch history doesn't ride to Google Drive. S3 Dropped isLenient = true from every Json {} instance (7 sites across data/ and net/). Lenient parser was buying nothing on data we wrote ourselves and was a hardening gap on the third- party SponsorBlock + RYD endpoints (community-run; malformed payload could feed bad timestamps into the skip loop). S4 SubscriptionsStore.addAll + HistoryStore.recordAllWatches bulk methods, used by SettingsImport. Per-row toggle was O(N²) + N SP writes; bulk path is O(N) + 1 write. C3 SubsPane infinite-scroll LaunchedEffect keyed on (displayed.size, hasMore) — both mutated BY the effect. The collector cancelled itself mid-stream and dropped emissions, producing "scroll to bottom, nothing more loads". Re-keyed on listState + filteredCount; the collect lambda reads state through the snapshotFlow producer to avoid stale captures. C7 liveDrag + playbackSpeed: mutableFloatStateOf instead of mutableStateOf — no Float boxing on the 100Hz drag callback. C8 LogDump.capture is now suspend on Dispatchers.IO. The Settings click handler launches into scope; button shows "Exporting…" while in flight. MED — cheap wins picked up in passing Q9 reactiveFilter clears the cached preview when current query no longer has any matches (was leaving stale results visible). Q10 Hide-watched filter excludes blank video IDs from watchedIds — a blank in the set used to match every malformed-URL feed item and silently hide them. Q13 PiP button in VideoDetail bails with a Toast on null controller OR null resolved playback (was falling through to enterPictureInPictureMode with no stream). C17 SpeedPickerDialog row used fillMaxSize inside an AlertDialog; only the first row got non-zero height. Fixed to fillMaxWidth. Deferred to vc=36 follow-up (touch surface area we don't want to churn in the same ship): - C6 atomic setPlayingFrom guard in StrawMediaController - S3 (full) — direct-streaming download replacing DownloadManager - MED-C16 LazyColumn refactor in VideoDetailScreen - MED-Q12 loadedUrl assignment ordering hardening --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- strawApp/src/main/AndroidManifest.xml | 16 +- .../kotlin/com/sulkta/straw/StrawActivity.kt | 8 +- .../main/kotlin/com/sulkta/straw/StrawApp.kt | 6 + .../main/kotlin/com/sulkta/straw/StrawHome.kt | 29 +++- .../com/sulkta/straw/data/FeedCacheStore.kt | 2 +- .../com/sulkta/straw/data/HistoryStore.kt | 26 +++- .../com/sulkta/straw/data/PlaylistsStore.kt | 2 +- .../com/sulkta/straw/data/SearchCacheStore.kt | 2 +- .../sulkta/straw/data/SubscriptionsStore.kt | 27 +++- .../feature/dataimport/SettingsImport.kt | 137 ++++++++++++++---- .../straw/feature/detail/VideoDetailScreen.kt | 35 +++-- .../feature/detail/VideoDetailViewModel.kt | 19 ++- .../straw/feature/download/Downloader.kt | 15 +- .../straw/feature/download/DownloadsScreen.kt | 21 ++- .../feature/feed/SubscriptionFeedViewModel.kt | 16 +- .../straw/feature/player/PlayerScreen.kt | 15 +- .../straw/feature/search/SearchScreen.kt | 25 +++- .../straw/feature/search/SearchViewModel.kt | 55 +++++-- .../straw/feature/settings/SettingsScreen.kt | 38 +++-- .../sulkta/straw/net/IosSafeHttpDataSource.kt | 25 ++-- .../kotlin/com/sulkta/straw/net/RydClient.kt | 2 +- .../sulkta/straw/net/SponsorBlockClient.kt | 2 +- .../kotlin/com/sulkta/straw/util/LogDump.kt | 128 ++++++++++------ .../main/res/xml/data_extraction_rules.xml | 28 ++++ strawApp/src/main/res/xml/file_paths.xml | 14 +- 26 files changed, 531 insertions(+), 166 deletions(-) create mode 100644 strawApp/src/main/res/xml/data_extraction_rules.xml diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 1b854d719..4ba83af96 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 34 -const val STRAW_VERSION_NAME = "0.1.0-AT" +const val STRAW_VERSION_CODE = 35 +const val STRAW_VERSION_NAME = "0.1.0-AU" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/AndroidManifest.xml b/strawApp/src/main/AndroidManifest.xml index d3d86d3e0..dff4e3cc1 100644 --- a/strawApp/src/main/AndroidManifest.xml +++ b/strawApp/src/main/AndroidManifest.xml @@ -11,12 +11,20 @@ + + + - + @@ -39,6 +50,9 @@ + + + diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt index 86bc9f577..ead83af3f 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt @@ -207,7 +207,13 @@ class StrawActivity : ComponentActivity() { // Explicit scheme + host check — defense in depth vs the // manifest intent-filter; apps can synth intents that // bypass filter scheme matching on exported activities. - if (intent.scheme?.lowercase() !in setOf("https", "http")) return null + // HTTPS only — matches the manifest VIEW filter so an explicit + // ComponentName intent can't smuggle an http:// URL past the + // filter check. Defense in depth; the YT_URL_RE still allows + // http for the ACTION_SEND substring case where the URL is + // embedded in attacker-controlled text and we want to match + // common share-sheet links, but VIEW must be tighter. + if (intent.scheme?.lowercase() != "https") return null if (!looksLikeYouTube(data)) return null data } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt index df0e041e1..a6ae34c13 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt @@ -12,6 +12,7 @@ import com.sulkta.straw.data.Playlists import com.sulkta.straw.data.SearchCache import com.sulkta.straw.data.Settings import com.sulkta.straw.data.Subscriptions +import com.sulkta.straw.feature.dataimport.SettingsImport class StrawApp : Application() { override fun onCreate() { @@ -27,5 +28,10 @@ class StrawApp : Application() { Playlists.init(this) FeedCache.init(this) SearchCache.init(this) + // Sweep any newpipe-import-* work-dirs left in cacheDir by a + // previous import that was killed mid-extraction. CRIT from + // the vc=34 security audit — the user's full NewPipe DB would + // otherwise live in cacheDir until the next deleteRecursively. + SettingsImport.sweepStale(this) } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt index dd23aeae4..ff2d26d34 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt @@ -280,8 +280,12 @@ private fun SubsPane( var visibleCount by remember { mutableIntStateOf(PAGE_SIZE) } // O(1) lookup for the watched-filter; rebuild only when watches - // change. Just the video IDs because URLs vary by tracking params. - val watchedIds = remember(watches) { watches.map { it.videoId }.toSet() } + // change. Drop blank IDs — `recordWatch` doesn't gate on those, + // and a blank in the set would `extractVideoId(url)=""` match + // EVERY malformed-URL item and silently hide them all. + val watchedIds = remember(watches) { + watches.map { it.videoId }.filter { it.isNotBlank() }.toSet() + } val filteredItems = remember(feed.items, hideWatched, watchedIds) { if (!hideWatched) feed.items @@ -388,11 +392,24 @@ private fun SubsPane( lastVisible >= info.totalItemsCount - 5 } } - LaunchedEffect(displayed.size, hasMore) { - snapshotFlow { nearBottom }.collect { atEnd -> - if (atEnd && hasMore) { + // Key on listState only — the previous key set + // (displayed.size, hasMore) was mutated BY this effect, + // which cancelled the snapshotFlow collector mid-stream + // and produced the "scrolled to bottom, nothing loads" + // bug from the vc=34 audit. + // + // hasMore and filteredItems are read inside the + // snapshotFlow producer (not closed over from outside) + // so Compose re-reads them on each frame instead of + // capturing the stale value at lambda-creation time. + val filteredCount = filteredItems.size + LaunchedEffect(listState, filteredCount) { + snapshotFlow { + nearBottom && visibleCount < filteredCount + }.collect { shouldGrow -> + if (shouldGrow) { visibleCount = (visibleCount + PAGE_SIZE) - .coerceAtMost(filteredItems.size) + .coerceAtMost(filteredCount) } } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/FeedCacheStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/FeedCacheStore.kt index 70d9a2c1b..0464d25a3 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/FeedCacheStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/FeedCacheStore.kt @@ -36,7 +36,7 @@ private const val KEY = "cache_v1" class FeedCacheStore(context: Context) { private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) - private val json = Json { ignoreUnknownKeys = true; isLenient = true } + private val json = Json { ignoreUnknownKeys = true } /** Snapshot of the disk cache. Returns empty map if nothing saved. */ fun load(): Map = runCatching { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt index cc04a788c..7ecc397d7 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt @@ -36,7 +36,7 @@ private const val MAX_SEARCHES = 20 class HistoryStore(context: Context) { private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) - private val json = Json { ignoreUnknownKeys = true; isLenient = true } + private val json = Json { ignoreUnknownKeys = true } private val _watches = MutableStateFlow(loadWatches()) val watches: StateFlow> = _watches.asStateFlow() @@ -56,6 +56,30 @@ class HistoryStore(context: Context) { sp.edit().putString(KEY_WATCHES, json.encodeToString(next)).apply() } + /** + * Bulk import. Callers (currently SettingsImport) feed + * oldest→newest so the most-recent entries end up at the front + * of the capped list. Single SP write — vc=34 audit flagged the + * per-row recordWatch in importHistory as a write-storm vector. + */ + fun recordAllWatches(items: List) { + if (items.isEmpty()) return + val next = _watches.updateAndGet { current -> + val seen = current.map { it.videoId }.toMutableSet() + val merged = current.toMutableList() + for (item in items) { + if (item.videoId.isBlank()) continue + if (item.videoId in seen) { + merged.removeAll { it.videoId == item.videoId } + } + seen.add(item.videoId) + merged.add(0, item) + } + merged.take(MAX_WATCHES) + } + sp.edit().putString(KEY_WATCHES, json.encodeToString(next)).apply() + } + fun recordSearch(query: String) { val q = query.trim() if (q.isEmpty()) return diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/PlaylistsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/PlaylistsStore.kt index cf72bd597..57f8979f6 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/PlaylistsStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/PlaylistsStore.kt @@ -47,7 +47,7 @@ private const val KEY = "playlists_v1" class PlaylistsStore(context: Context) { private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) - private val json = Json { ignoreUnknownKeys = true; isLenient = true } + private val json = Json { ignoreUnknownKeys = true } private val _playlists = MutableStateFlow(load()) val playlists: StateFlow> = _playlists.asStateFlow() diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt index 7dc05cc62..10f5a961d 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt @@ -37,7 +37,7 @@ private const val MAX_ITEMS_PER_QUERY = 20 class SearchCacheStore(context: Context) { private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) - private val json = Json { ignoreUnknownKeys = true; isLenient = true } + private val json = Json { ignoreUnknownKeys = true } fun load(): List = runCatching { val s = sp.getString(KEY, null) ?: return emptyList() diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt index 303ac4678..e4d897927 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt @@ -29,7 +29,7 @@ private const val KEY = "subs_v1" class SubscriptionsStore(context: Context) { private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) - private val json = Json { ignoreUnknownKeys = true; isLenient = true } + private val json = Json { ignoreUnknownKeys = true } private val _subs = MutableStateFlow(load()) val subs: StateFlow> = _subs.asStateFlow() @@ -64,6 +64,31 @@ class SubscriptionsStore(context: Context) { persist(next) } + /** + * Bulk-add. Single persist instead of N. Per-call `toggle()` was + * O(N²) + N SP writes, which the vc=34 security audit flagged as + * a DoS vector for hostile NewPipe-export imports. Single linear + * scan to dedup, one persist regardless of input size. Returns the + * count of NEW (not previously-subscribed) channels added so the + * caller can report an "added X" stat. + */ + fun addAll(refs: List): Int { + var added = 0 + val next = _subs.updateAndGet { cur -> + val byUrl = cur.associateBy { it.url }.toMutableMap() + for (r in refs) { + if (r.url.isBlank()) continue + if (r.url !in byUrl) { + byUrl[r.url] = r + added++ + } + } + byUrl.values.toList() + } + persist(next) + return added + } + fun clear() { // Same atomic-update path as toggle — protects against a concurrent // toggle racing the clear and persisting [new-item] after the diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/dataimport/SettingsImport.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/dataimport/SettingsImport.kt index 4e138788e..f2bab6d72 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/dataimport/SettingsImport.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/dataimport/SettingsImport.kt @@ -38,6 +38,7 @@ import com.sulkta.straw.data.WatchHistoryItem import java.io.File import java.util.zip.ZipInputStream import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.NonCancellable import kotlinx.coroutines.withContext import kotlinx.serialization.json.Json import kotlinx.serialization.json.JsonObject @@ -106,10 +107,29 @@ object SettingsImport { runCatching { runInner(context, zipUri) } } - private fun runInner(context: Context, zipUri: Uri): ImportResult { + /** + * Sweep stale import work-dirs left behind by a previous run that + * was killed mid-extraction. CRIT from the vc=34 security audit: + * a force-killed import leaves the user's full newpipe.db sitting + * in cacheDir indefinitely. StrawApp.onCreate calls this on every + * cold start. + */ + fun sweepStale(context: Context) { + runCatching { + context.cacheDir.listFiles { f -> + f.isDirectory && f.name.startsWith("newpipe-import-") + }?.forEach { it.deleteRecursively() } + } + } + + private suspend fun runInner(context: Context, zipUri: Uri): ImportResult { val warnings = mutableListOf() - val workDir = File(context.cacheDir, "newpipe-import-${System.currentTimeMillis()}") - workDir.mkdirs() + // createTempFile returns an unguessable name and 0600 perms by + // default, replacing the predictable currentTimeMillis suffix + // that an attacker could pre-create a symlink at. + val workDir = File.createTempFile("newpipe-import-", "", context.cacheDir).also { + it.delete(); it.mkdirs() + } try { val (dbFile, prefsJson) = extractZip(context, zipUri, workDir, warnings) @@ -132,10 +152,22 @@ object SettingsImport { warnings = warnings, ) } finally { - workDir.deleteRecursively() + // NonCancellable guarantees the cleanup runs even when the + // outer coroutine was cancelled — without it a user + // navigating away mid-import (or low-memory killer firing) + // left the full newpipe.db in cacheDir until the next + // cold-start sweep. + withContext(NonCancellable) { + workDir.deleteRecursively() + } } } + // Defense against zip-bomb / malformed exports. + private const val MAX_DB_BYTES: Long = 256L * 1024 * 1024 + private const val MAX_PREFS_BYTES: Long = 1L * 1024 * 1024 + private const val MAX_ZIP_ENTRIES: Int = 64 + private fun extractZip( context: Context, zipUri: Uri, @@ -144,24 +176,37 @@ object SettingsImport { ): Pair { var dbFile: File? = null var prefs: JsonObject? = null + var entryCount = 0 context.contentResolver.openInputStream(zipUri)?.use { input -> ZipInputStream(input).use { zip -> while (true) { val entry = zip.nextEntry ?: break + entryCount++ + if (entryCount > MAX_ZIP_ENTRIES) { + warnings += "archive has >$MAX_ZIP_ENTRIES entries — aborting" + return null to null + } when (entry.name) { "newpipe.db" -> { val out = File(workDir, "newpipe.db") - out.outputStream().use { os -> - zip.copyTo(os, bufferSize = 64 * 1024) + val written = copyBounded(zip, out, MAX_DB_BYTES) + if (written < 0L) { + warnings += "newpipe.db exceeds ${MAX_DB_BYTES / (1024 * 1024)} MB — aborting" + out.delete() + return null to null } dbFile = out } "preferences.json" -> { - val bytes = zip.readBytes() - prefs = runCatching { - Json.parseToJsonElement(bytes.decodeToString()) as? JsonObject - }.getOrNull() - if (prefs == null) warnings += "preferences.json present but unparseable" + val bytes = readBoundedBytes(zip, MAX_PREFS_BYTES) + if (bytes == null) { + warnings += "preferences.json exceeds ${MAX_PREFS_BYTES / 1024} KB — skipping" + } else { + prefs = runCatching { + Json.parseToJsonElement(bytes.decodeToString()) as? JsonObject + }.getOrNull() + if (prefs == null) warnings += "preferences.json present but unparseable" + } } // newpipe.settings is the legacy XML form; preferences.json // supersedes it in every modern export. Skip. @@ -176,14 +221,51 @@ object SettingsImport { return dbFile to prefs } + /** + * Bounded copy. Returns bytes-written on success, -1 if `cap` was + * exceeded. Used instead of `copyTo` so a 16 GB zip-bomb doesn't + * fill the user's cacheDir before we notice. + */ + private fun copyBounded(src: java.io.InputStream, dst: File, cap: Long): Long { + dst.outputStream().use { os -> + val buf = ByteArray(64 * 1024) + var total = 0L + while (true) { + val n = src.read(buf) + if (n <= 0) break + total += n + if (total > cap) return -1L + os.write(buf, 0, n) + } + return total + } + } + + private fun readBoundedBytes(src: java.io.InputStream, cap: Long): ByteArray? { + val baos = java.io.ByteArrayOutputStream() + val buf = ByteArray(16 * 1024) + var total = 0L + while (true) { + val n = src.read(buf) + if (n <= 0) break + total += n + if (total > cap) return null + baos.write(buf, 0, n) + } + return baos.toByteArray() + } + private data class SubsResult(val added: Int, val skipped: Int) private fun importSubscriptions(dbFile: File): SubsResult { val store = Subscriptions.get() - var added = 0 + // Cap input row count too — hostile NewPipe export with a + // million rows would still walk the cursor fully without this. + val maxRows = 10_000 var skipped = 0 + val staged = mutableListOf() openDb(dbFile).use { db -> db.rawQuery( - "SELECT url, name, avatar_url, service_id FROM subscriptions", + "SELECT url, name, avatar_url, service_id FROM subscriptions LIMIT $maxRows", null, ).use { c -> while (c.moveToNext()) { @@ -195,13 +277,12 @@ object SettingsImport { val url = c.getString(0) ?: continue val name = c.getString(1) ?: continue val avatar = c.getString(2) - if (!store.isSubscribed(url)) { - store.toggle(ChannelRef(url = url, name = name, avatar = avatar)) - added++ - } + staged += ChannelRef(url = url, name = name, avatar = avatar) } } } + // Single dedup + single persist regardless of N. + val added = store.addAll(staged) return SubsResult(added, skipped) } @@ -293,12 +374,17 @@ object SettingsImport { db.rawQuery("SELECT COUNT(*) FROM stream_history", null).use { c -> if (c.moveToNext()) watchesAvailable = c.getInt(0) } + // Stage rows in memory, then one bulk write — same DoS + // mitigation as importSubscriptions. recordWatch did N SP + // writes and an O(N) dedup per row. + val staged = mutableListOf() db.rawQuery( """ SELECT s.url, s.title, s.uploader, s.thumbnail_url, h.access_date, s.service_id FROM stream_history h JOIN streams s ON s.uid = h.stream_id ORDER BY h.access_date ASC + LIMIT 50000 """.trimIndent(), null, ).use { c -> @@ -309,19 +395,18 @@ object SettingsImport { val uploader = c.getString(2) ?: "" val thumb = c.getString(3) val videoId = extractYtVideoId(url) ?: continue - historyStore.recordWatch( - WatchHistoryItem( - url = url, - videoId = videoId, - title = title, - uploader = uploader, - thumbnail = thumb, - watchedAt = c.getLong(4), - ), + staged += WatchHistoryItem( + url = url, + videoId = videoId, + title = title, + uploader = uploader, + thumbnail = thumb, + watchedAt = c.getLong(4), ) watchesSeen++ } } + historyStore.recordAllWatches(staged) // Resume positions — counted, not stored. Future task hooks into // a ResumePositionsStore. diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index 59f48f148..8e6304966 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -65,6 +65,7 @@ import androidx.compose.runtime.DisposableEffect import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.collectAsState import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableFloatStateOf import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember import androidx.compose.runtime.setValue @@ -155,7 +156,9 @@ fun VideoDetailScreen( val dismissThresholdPx = with(density) { 140.dp.toPx() } val flingVelocityThreshold = with(density) { 600.dp.toPx() } val screenHeightPx = with(density) { configuration.screenHeightDp.dp.toPx() } - var liveDrag by remember { mutableStateOf(0f) } + // mutableFloatStateOf avoids boxing on every drag delta — the + // draggable callback fires 100+ times/s on a fast swipe. + var liveDrag by remember { mutableFloatStateOf(0f) } var dragging by remember { mutableStateOf(false) } val releaseAnim = remember { Animatable(0f) } val draggableState = rememberDraggableState { delta -> @@ -385,21 +388,23 @@ fun VideoDetailScreen( Toast.makeText(context, "PiP needs Android 8+", Toast.LENGTH_SHORT).show() return@OutlinedButton } - // PiP needs the controller to actually be playing - // this video, same as Background — otherwise we - // pop out into nothing. + // PiP into nothing isn't useful — bail with a + // Toast if there's no controller / no resolved + // playback to push into it. vc=34 audit Q-13. val c = controller - if (c != null && NowPlaying.current.value?.streamUrl != streamUrl) { - val r = state.resolved - if (r != null) { - c.setPlayingFrom( - streamUrl = streamUrl, - title = d.title, - uploader = d.uploader, - thumbnail = d.thumbnail, - resolved = r, - ) - } + val r = state.resolved + if (c == null || r == null) { + Toast.makeText(context, "stream not ready", Toast.LENGTH_SHORT).show() + return@OutlinedButton + } + if (NowPlaying.current.value?.streamUrl != streamUrl) { + c.setPlayingFrom( + streamUrl = streamUrl, + title = d.title, + uploader = d.uploader, + thumbnail = d.thumbnail, + resolved = r, + ) } val params = PictureInPictureParams.Builder() .setAspectRatio(Rational(16, 9)) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt index e269b3f6c..19e2b2fb5 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt @@ -195,13 +195,22 @@ class VideoDetailViewModel : ViewModel() { segments: List, ): ResolvedPlayback { val maxRes = Settings.get().maxResolution.value.ceiling - // Filter by max-resolution ceiling but fall back to the lowest - // available if the ceiling excludes everything (e.g. a 360p-only - // upload with the user on a 480p cap). + // Pick the highest-bitrate stream that still fits the user's + // cap. Fallback: when every available stream EXCEEDS the cap + // (e.g. a 1080p-only upload with the user on a 480p cap), pick + // the LOWEST-height one — that's the closest-to-cap option and + // honors the user's intent ("don't blow my data plan") even + // when their exact target isn't available. vc=34 audit Q-8 — + // previously this fell back to max-bitrate, which was the + // worst possible choice for someone on a 480p cap. fun pickVideo(streams: List): String? { if (streams.isEmpty()) return null - val pool = streams.filter { it.height <= maxRes }.ifEmpty { streams } - return pool.maxByOrNull { it.bitrate }?.url + val capped = streams.filter { it.height <= maxRes } + return if (capped.isNotEmpty()) { + capped.maxByOrNull { it.bitrate }?.url + } else { + streams.minByOrNull { it.height }?.url + } } return ResolvedPlayback( title = info.title, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/Downloader.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/Downloader.kt index bdb7dcce3..6ce34060e 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/Downloader.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/Downloader.kt @@ -51,11 +51,24 @@ object Downloader { val filename = "$safeTitle${kind.ext}" val dm = ctx.getSystemService(Context.DOWNLOAD_SERVICE) as DownloadManager + // SECURITY: pre-signed googlevideo URLs leak to anything reading + // DownloadManager state (system notification stack, downloads UI, + // apps with ACCESS_DOWNLOAD_MANAGER). We can't hide the URL from + // DM itself without re-implementing the download, but we can hide + // it from every surface DM forwards to: + // setNotificationVisibility(HIDDEN) — no system notification + // surfaces the URL via tap-to-open / accessibility scrapers. + // setVisibleInDownloadsUi(false) — the Downloads system app + // won't list this entry, so a user opening Files / Downloads + // can't long-press → details → see the URL. + // Our own DownloadsScreen reads progress out of DM via the ID + // returned below, so user-facing UX is unaffected. val req = runCatching { DownloadManager.Request(Uri.parse(url)) .setTitle(title) .setDescription("Straw — ${kind.name.lowercase()}") - .setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED) + .setNotificationVisibility(DownloadManager.Request.VISIBILITY_HIDDEN) + .setVisibleInDownloadsUi(false) .setAllowedOverMetered(true) .setAllowedOverRoaming(true) .setDestinationInExternalFilesDir( diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/DownloadsScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/DownloadsScreen.kt index 5872a5c17..30ec8cc94 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/DownloadsScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/DownloadsScreen.kt @@ -156,8 +156,27 @@ private fun DownloadRowView( .fillMaxWidth() .clickable(enabled = openable) { row.localUri?.let { uri -> + // DownloadManager returns a file:// URI for the + // setDestinationInExternalFilesDir target. Passing + // that across an app boundary throws + // FileUriExposedException on every API >= 24 since + // minSdk 24. Route through FileProvider so the + // receiver gets a grantable content:// URI instead. + val shareUri = runCatching { + val src = Uri.parse(uri) + val path = src.path + if (src.scheme == "file" && path != null) { + androidx.core.content.FileProvider.getUriForFile( + context, + "${context.packageName}.fileprovider", + java.io.File(path), + ) + } else { + src + } + }.getOrNull() ?: return@let val intent = Intent(Intent.ACTION_VIEW).apply { - setDataAndType(Uri.parse(uri), row.mediaType ?: "*/*") + setDataAndType(shareUri, row.mediaType ?: "*/*") addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION) } runCatching { context.startActivity(intent) } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt index 2503a828c..fbdff939b 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt @@ -66,14 +66,14 @@ class SubscriptionFeedViewModel : ViewModel() { init { // Hydrate from disk and immediately render the cached items so - // the Subs tab paints in one frame instead of after the network - // round-trip. The refresh that follows replaces stale entries - // in-place — items animate to their new positions via LazyColumn - // key stability (URLs are stable across fetches). - // Skip the hydrate when the user has disabled caching — they - // explicitly don't want disk usage for this. - val saved = if (Settings.get().cacheEnabled.value) FeedCache.get().load() else emptyMap() - if (saved.isNotEmpty()) { + // the Subs tab paints before the network round-trip resolves. + // vc=34 audit CRIT: previously this ran synchronously on the + // main thread at VM construction, blocking the first compose + // pass on a ~225 KB Json.decodeFromString. + viewModelScope.launch { + if (!Settings.get().cacheEnabled.value) return@launch + val saved = withContext(Dispatchers.IO) { FeedCache.get().load() } + if (saved.isEmpty()) return@launch channelCache.putAll(saved) val channels = Subscriptions.get().subs.value if (channels.isNotEmpty()) { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt index 0c3ee8f01..47eccf046 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt @@ -52,6 +52,7 @@ import androidx.compose.runtime.Composable import androidx.compose.runtime.DisposableEffect import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableFloatStateOf import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember import androidx.compose.runtime.setValue @@ -89,7 +90,7 @@ fun PlayerScreen( val state by vm.ui.collectAsStateWithLifecycle() LaunchedEffect(streamUrl) { vm.load(streamUrl) } - var playbackSpeed by remember { mutableStateOf(1.0f) } + var playbackSpeed by remember { mutableFloatStateOf(1.0f) } var audioOnly by remember { mutableStateOf(false) } var showSpeedDialog by remember { mutableStateOf(false) } @@ -301,7 +302,7 @@ private fun SpeedPickerDialog( options.forEach { s -> Row( modifier = Modifier - .fillMaxSize() + .fillMaxWidth() .clickable { onPick(s) } .padding(vertical = 12.dp), verticalAlignment = Alignment.CenterVertically, @@ -341,6 +342,10 @@ fun SponsorBlockSkipLoop() { val segments = cur.segments if (segments.isEmpty() || controller == null) return val skipped = remember(cur.streamUrl) { mutableSetOf() } + // Rate-limit the skip Toast — back-to-back segments in + // sponsor-dense videos used to queue 20+ Toasts that paint over + // the screen for 40s after the actual seek (vc=34 audit HIGH-B7). + var lastToastAt by remember(cur.streamUrl) { mutableStateOf(0L) } LaunchedEffect(cur.streamUrl, controller) { while (true) { delay(150) @@ -360,7 +365,11 @@ fun SponsorBlockSkipLoop() { controller.seekTo(targetMs) } s.UUID?.let { skipped.add(it) } - Toast.makeText(context, "skipped ${s.category}", Toast.LENGTH_SHORT).show() + val now = System.currentTimeMillis() + if (now - lastToastAt > 3000) { + Toast.makeText(context, "skipped ${s.category}", Toast.LENGTH_SHORT).show() + lastToastAt = now + } } } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt index fce5263c0..c0c7a3434 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt @@ -69,12 +69,19 @@ fun SearchScreen( Spacer(modifier = Modifier.height(12.dp)) when { - state.loading -> Box( + // Loading WITH cached results: thin progress bar above the + // list, results stay visible. vc=34 audit B-1 — the prior + // order short-circuited to a centered spinner and hid the + // cached preview the VM was trying to show. + state.loading && state.results.isEmpty() -> Box( modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center, ) { CircularProgressIndicator() } - state.error != null -> Box( + // Error WITH cached results: thin error banner above the + // list. Audit B-2 — error branch used to clobber the + // cached preview the VM explicitly kept. + state.error != null && state.results.isEmpty() -> Box( modifier = Modifier.fillMaxSize().padding(16.dp), contentAlignment = Alignment.Center, ) { @@ -117,6 +124,20 @@ fun SearchScreen( ) { Text("hit enter to search") } else -> Column(modifier = Modifier.fillMaxSize()) { + if (state.loading) { + androidx.compose.material3.LinearProgressIndicator( + modifier = Modifier.fillMaxWidth(), + ) + Spacer(modifier = Modifier.height(4.dp)) + } + if (state.error != null) { + Text( + text = "refresh failed: ${state.error}", + style = MaterialTheme.typography.labelSmall, + color = MaterialTheme.colorScheme.error, + modifier = Modifier.padding(bottom = 4.dp), + ) + } if (state.fromCache) { Text( text = if (state.loading) "Cached results · refreshing…" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt index a816c18b2..6cb952a1f 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt @@ -49,12 +49,34 @@ class SearchViewModel : ViewModel() { private val _ui = MutableStateFlow(SearchUiState()) val ui: StateFlow = _ui.asStateFlow() + /** + * In-memory snapshot of the disk corpus (saved search results + + * subs feed cache) for reactive filtering. Hydrated on Dispatchers.IO + * once at VM construction and refreshed after a successful submit. + * vc=34 audit CRIT — the previous implementation hit + * SharedPreferences + JSON-decoded ~225 KB on every keystroke, + * blocking the main thread. + */ + private val pool = MutableStateFlow>(emptyList()) + + init { + viewModelScope.launch { + if (Settings.get().cacheEnabled.value) { + pool.value = withContext(Dispatchers.IO) { buildPool() } + } + } + } + + private fun buildPool(): List = buildList { + runCatching { SearchCache.get().load().forEach { addAll(it.items) } } + runCatching { FeedCache.get().load().values.forEach { addAll(it.items) } } + }.distinctBy { it.url } + fun onQueryChange(q: String) { _ui.value = _ui.value.copy(query = q) - // Reactive filter: scan every cached item (search-cache + subs - // feed-cache) as the user types. Cheap, runs in-memory, gives - // instant feedback before they hit Enter. Disabled when the - // user has turned off the cache feature. + // Reactive filter: scan the in-memory `pool` as the user types. + // Pool is a List walked once per keystroke — bounded + // (~1500 items typical), no disk I/O, no JSON decode. if (Settings.get().cacheEnabled.value && q.trim().length >= 2) { val matches = reactiveFilter(q.trim()) if (matches.isNotEmpty()) { @@ -64,6 +86,11 @@ class SearchViewModel : ViewModel() { loading = false, error = null, ) + } else if (_ui.value.fromCache) { + // User typed past what the cache can answer — drop the + // stale preview rather than leaving the prior query's + // results on screen pretending to match. + _ui.value = _ui.value.copy(results = emptyList(), fromCache = false) } } else if (q.isBlank()) { // Clear cached preview if the box is cleared. @@ -126,6 +153,10 @@ class SearchViewModel : ViewModel() { if (Settings.get().cacheEnabled.value) { withContext(Dispatchers.IO) { runCatching { SearchCache.get().record(q, items) } + // Refresh the in-memory pool with the new + // entries so subsequent reactive filters see + // them without waiting for a process restart. + pool.value = buildPool() } } } catch (t: Throwable) { @@ -140,24 +171,18 @@ class SearchViewModel : ViewModel() { } /** - * Walk the merged corpus of cached items (every saved search + - * every subs-feed channel cache) and return items whose title or - * uploader contains the query — case-insensitive, dedup by URL. - * Cheap: even with 30 cached queries * 20 items + 30 channels * 30 - * items it's < 1500 records, plenty fast for an in-memory filter. + * Walk the in-memory `pool` and return items whose title or uploader + * contains the query. Case-insensitive, capped at 60 results. + * No disk I/O on the hot path — `pool` is refreshed off-thread + * after each successful submit and at VM construction. */ private fun reactiveFilter(q: String): List { val needle = q.lowercase() - val pool = buildList { - SearchCache.get().load().forEach { addAll(it.items) } - FeedCache.get().load().values.forEach { addAll(it.items) } - } - return pool.asSequence() + return pool.value.asSequence() .filter { item -> item.title.lowercase().contains(needle) || item.uploader.lowercase().contains(needle) } - .distinctBy { it.url } .take(60) .toList() } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt index 1f8339ca8..c5e834837 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt @@ -244,20 +244,30 @@ fun SettingsScreen() { color = MaterialTheme.colorScheme.onSurfaceVariant, ) Spacer(modifier = Modifier.height(12.dp)) - OutlinedButton(onClick = { - val outcome = LogDump.capture(context) - outcome.onSuccess { intent -> - context.startActivity(android.content.Intent.createChooser(intent, "Share Straw logs")) - } - outcome.onFailure { t -> - Toast.makeText( - context, - "Log dump failed: ${t.message ?: t.javaClass.simpleName}", - Toast.LENGTH_LONG, - ).show() - } - }) { - Text("Export logs…") + var logDumping by remember { mutableStateOf(false) } + OutlinedButton( + enabled = !logDumping, + onClick = { + logDumping = true + scope.launch { + val outcome = LogDump.capture(context) + logDumping = false + outcome.onSuccess { intent -> + context.startActivity( + android.content.Intent.createChooser(intent, "Share Straw logs"), + ) + } + outcome.onFailure { t -> + Toast.makeText( + context, + "Log dump failed: ${t.message ?: t.javaClass.simpleName}", + Toast.LENGTH_LONG, + ).show() + } + } + }, + ) { + Text(if (logDumping) "Exporting…" else "Export logs…") } Spacer(modifier = Modifier.height(32.dp)) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/net/IosSafeHttpDataSource.kt b/strawApp/src/main/kotlin/com/sulkta/straw/net/IosSafeHttpDataSource.kt index ffb92672f..d0e1108ba 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/net/IosSafeHttpDataSource.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/net/IosSafeHttpDataSource.kt @@ -21,11 +21,12 @@ package com.sulkta.straw.net -import android.util.Log import androidx.media3.common.C import androidx.media3.common.util.UnstableApi import androidx.media3.datasource.DataSpec import androidx.media3.datasource.HttpDataSource +import com.sulkta.straw.util.strawLogD +import com.sulkta.straw.util.strawLogW private const val TAG = "IosSafeDS" @@ -60,17 +61,19 @@ class IosSafeHttpDataSource( // come out as `bytes=N-M` (closed, accepted by googlevideo iOS URLs) // instead of `bytes=N-` (open, rejected with 403). val bounded = dataSpec.buildUpon().setLength(requestLen).build() - // Surface itag + mime from query so we can tell video vs audio apart in logs. + // Surface itag + mime from query so we can tell video vs audio apart in + // logs. SECURITY: do NOT include the full URL — pre-signed googlevideo + // URLs contain session-bound credentials (signature, sig, pot, expire, + // cpn) that would otherwise ride a `LogDump.capture` straight into the + // user's share-sheet target. Host + itag is enough to debug from. val u = dataSpec.uri val itag = u.getQueryParameter("itag") val mime = u.getQueryParameter("mime") - Log.i( - TAG, - "open: pos=${bounded.position} len=${bounded.length} " + - "(origLen=${dataSpec.length}, chunkBytes=$chunkBytes) " + - "itag=$itag mime=$mime host=${u.host}", - ) - Log.i(TAG, "open url=${u.toString()}") + strawLogD(TAG) { + "open: host=${u.host} itag=$itag mime=$mime " + + "pos=${bounded.position} len=${bounded.length} " + + "(origLen=${dataSpec.length}, chunkBytes=$chunkBytes)" + } originalSpec = dataSpec totalRead = 0 // inner.open() returns the BOUNDED chunk's length. Track it so we @@ -78,10 +81,10 @@ class IosSafeHttpDataSource( chunkRemaining = try { inner.open(bounded) } catch (t: Throwable) { - Log.w(TAG, "open failed: ${t.javaClass.simpleName}: ${t.message}") + strawLogW(TAG, t) { "open failed: ${t.javaClass.simpleName}" } throw t } - Log.i(TAG, "open: inner returned chunkRemaining=$chunkRemaining") + strawLogD(TAG) { "open: inner chunkRemaining=$chunkRemaining" } // Report the original (potentially unbounded) length to the caller — // ExoPlayer cares about the overall length, not our internal chunking. return if (dataSpec.length == C.LENGTH_UNSET.toLong()) { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/net/RydClient.kt b/strawApp/src/main/kotlin/com/sulkta/straw/net/RydClient.kt index 817597596..6a5bb17d8 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/net/RydClient.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/net/RydClient.kt @@ -25,7 +25,7 @@ data class RydVotes( object RydClient { private const val TAG = "StrawRyd" - private val json = Json { ignoreUnknownKeys = true; isLenient = true } + private val json = Json { ignoreUnknownKeys = true } /** Blocking — call from Dispatchers.IO. */ fun fetch(videoId: String): RydVotes? { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/net/SponsorBlockClient.kt b/strawApp/src/main/kotlin/com/sulkta/straw/net/SponsorBlockClient.kt index 9979e58f8..77688c5ed 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/net/SponsorBlockClient.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/net/SponsorBlockClient.kt @@ -34,7 +34,7 @@ data class SbSegment( object SponsorBlockClient { private const val TAG = "StrawSb" - private val json = Json { ignoreUnknownKeys = true; isLenient = true } + private val json = Json { ignoreUnknownKeys = true } fun fetch( videoId: String, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/util/LogDump.kt b/strawApp/src/main/kotlin/com/sulkta/straw/util/LogDump.kt index 9b4675aeb..d66eac8a6 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/util/LogDump.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/util/LogDump.kt @@ -6,10 +6,14 @@ * Used from the Settings → "Export logs" action so users can attach a * log dump when reporting a problem. * - * NOTE: Android limits logcat-via-Runtime.exec to the calling app's - * own UID on API 30+, so this captures Straw's own log lines only - * (plus a sliver of system-wide messages tagged by our PID). No - * other app's logs are exposed. + * SECURITY: The dump is filtered before being written to disk — + * pre-signed googlevideo URLs, OAuth-style tokens, and anything + * matching the leak patterns below get scrubbed line-by-line. Without + * this, a user reporting a bug to Telegram would hand the chooser app + * their currently-playing session-bound streaming credentials. + * + * Android also limits logcat-via-Runtime.exec to the calling app's + * own UID on API 30+, so this captures Straw's own log lines only. */ package com.sulkta.straw.util @@ -24,53 +28,89 @@ import java.io.IOException import java.text.SimpleDateFormat import java.util.Date import java.util.Locale +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext object LogDump { /** - * Pull recent logcat, write to a file in cacheDir, return a - * share-able Intent. Caller is responsible for `startActivity`. - * Returns null when the dump command itself fails — the caller - * shows a Toast with the error. + * Pull recent logcat, scrub sensitive substrings, write to a file + * in cacheDir, return a share-able Intent. Suspend so callers can + * stay off the main thread — `proc.waitFor()` plus a multi-MB + * `copyTo` is firmly an IO operation. */ - fun capture(context: Context): Result = runCatching { - val pid = Process.myPid() - val timestamp = SimpleDateFormat("yyyyMMdd-HHmmss", Locale.US).format(Date()) - val outFile = File(context.cacheDir, "straw-logs-$timestamp.txt") + suspend fun capture(context: Context): Result = withContext(Dispatchers.IO) { + runCatching { + val pid = Process.myPid() + val timestamp = SimpleDateFormat("yyyyMMdd-HHmmss", Locale.US).format(Date()) + val outFile = File(context.cacheDir, "straw-logs-$timestamp.txt") + val tmpFile = File(context.cacheDir, "straw-logs-$timestamp.txt.tmp") - // -d dump-and-exit (no follow), -v threadtime is the - // most-greppable format, and the --pid filter restricts to - // our process so we don't accidentally exfiltrate sibling - // apps' chatter even when the system would allow it. - val cmd = arrayOf( - "logcat", - "-d", - "-v", - "threadtime", - "--pid=$pid", - ) - val proc = ProcessBuilder(*cmd) - .redirectErrorStream(true) - .start() - outFile.outputStream().use { out -> - proc.inputStream.copyTo(out) - } - val exit = proc.waitFor() - if (exit != 0) { - throw IOException("logcat exit=$exit") - } - if (outFile.length() == 0L) { - throw IOException("logcat produced 0 bytes (sandbox restriction?)") - } + // Sweep old dumps before writing the new one so cacheDir + // doesn't grow per export. + context.cacheDir.listFiles { _, name -> + name.startsWith("straw-logs-") && (name.endsWith(".txt") || name.endsWith(".tmp")) + }?.forEach { it.delete() } - // FileProvider authority — declared in AndroidManifest below. - val authority = "${context.packageName}.fileprovider" - val uri: Uri = FileProvider.getUriForFile(context, authority, outFile) - Intent(Intent.ACTION_SEND).apply { - type = "text/plain" - putExtra(Intent.EXTRA_STREAM, uri) - putExtra(Intent.EXTRA_SUBJECT, "Straw logs $timestamp") - addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION) + // -d dump-and-exit (no follow), -v threadtime is the + // most-greppable format, --pid filter restricts to our + // process so we don't exfiltrate sibling apps' chatter. + val cmd = arrayOf("logcat", "-d", "-v", "threadtime", "--pid=$pid") + val proc = ProcessBuilder(*cmd).redirectErrorStream(true).start() + tmpFile.bufferedWriter().use { out -> + proc.inputStream.bufferedReader().useLines { lines -> + lines.forEach { line -> + out.write(scrubLine(line)) + out.newLine() + } + } + } + val exit = proc.waitFor() + if (exit != 0) { + tmpFile.delete() + throw IOException("logcat exit=$exit") + } + if (tmpFile.length() == 0L) { + tmpFile.delete() + throw IOException("logcat produced 0 bytes (sandbox restriction?)") + } + // Atomic-ish: only rename to final name on full success. + if (!tmpFile.renameTo(outFile)) { + tmpFile.delete() + throw IOException("rename failed") + } + + val authority = "${context.packageName}.fileprovider" + val uri: Uri = FileProvider.getUriForFile(context, authority, outFile) + Intent(Intent.ACTION_SEND).apply { + type = "text/plain" + putExtra(Intent.EXTRA_STREAM, uri) + putExtra(Intent.EXTRA_SUBJECT, "Straw logs $timestamp") + addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION) + } } } + + /** + * Pre-redact known credential-shaped substrings before they hit + * disk. Cheap line-level pass — adversarial-perfect would need a + * URL parser, but the regex approach catches every documented + * leak vector at zero allocation cost. + */ + internal fun scrubLine(line: String): String { + var s = line + // Pre-signed googlevideo URLs: keep host visible, drop path+query. + s = GOOGLEVIDEO_URL_RE.replace(s, "https://.googlevideo.com/") + // Any remaining signed-param shapes that snuck through other URLs. + s = SIGNED_PARAM_RE.replace(s, "$1=") + return s + } + + private val GOOGLEVIDEO_URL_RE = Regex( + """https?://[a-zA-Z0-9.-]*googlevideo\.com/\S+""", + ) + private val SIGNED_PARAM_RE = Regex( + """\b(signature|sig|pot|cpn|expire|ip|mn|ms|mo|pl)=([^&\s"']+)""", + RegexOption.IGNORE_CASE, + ) } diff --git a/strawApp/src/main/res/xml/data_extraction_rules.xml b/strawApp/src/main/res/xml/data_extraction_rules.xml new file mode 100644 index 000000000..163056f5c --- /dev/null +++ b/strawApp/src/main/res/xml/data_extraction_rules.xml @@ -0,0 +1,28 @@ + + + + + + + + + + + + + + + + + + diff --git a/strawApp/src/main/res/xml/file_paths.xml b/strawApp/src/main/res/xml/file_paths.xml index 92e012475..2cd9f5c6f 100644 --- a/strawApp/src/main/res/xml/file_paths.xml +++ b/strawApp/src/main/res/xml/file_paths.xml @@ -1,8 +1,14 @@ - + + + + + From 8f7ec129b31a9e3c037cc32fa43c27e707f7381a Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 13:31:02 -0700 Subject: [PATCH 22/72] vc=35 fix: missing fillMaxWidth import in PlayerScreen --- .../main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt | 1 + 1 file changed, 1 insertion(+) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt index 47eccf046..9a110a69c 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt @@ -29,6 +29,7 @@ import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.WindowInsets import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.safeDrawing import androidx.compose.foundation.layout.size From d1ee9379e070cd86a260e8c2861e22d5db6ada03 Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 13:43:45 -0700 Subject: [PATCH 23/72] =?UTF-8?q?vc=3D36:=20audit-fix=20tail=20=E2=80=94?= =?UTF-8?q?=20atomic=20setPlayingFrom,=20cache=20wipe,=20polish?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The deferred items from the vc=35 audit-fix sprint. Smaller surface, real impact: HIGH-C6 — atomic setPlayingFrom claim StrawMediaController.setPlayingFrom previously did if (NowPlaying.current.value?.streamUrl == streamUrl) return setMediaItem(...); prepare(); play() NowPlaying.set(...) When the inline player and fullscreen Player effects fired in the same composition pass (an inline → fullscreen transition), both checks could see the stale NowPlaying value, both passed the guard, both ran setMediaItem + prepare + play. Result: an audible "did the video just restart?" stutter that was hard to reproduce. New: NowPlaying.claim(item) uses MutableStateFlow.compareAndSet in a CAS loop. Returns true ONLY for the caller that won the race; losing caller bails before touching the controller. The guard is now actually atomic, not a check-then-set. MED-Q11 — minibar surfaces playback errors Background button takes the user to Home with audio continuing in the foreground service. If that audio then fails (transient network drop on the resolved URL), neither the inline-player error listener nor PlayerScreen's exist anymore — only the minibar is observing. Added onPlayerError to MinibarOverlay's listener: Toast the errorCodeName + clear NowPlaying so the minibar hides itself rather than claiming a dead session is loaded. MED-Q15 — pre-compute recencyScore once mergeFromCache's compareByDescending invoked recencyScore() twice per pair (compareBy semantics), so ~1800 regex matches on a 900- item merge. Pair the score with the item once, sort the pair, take the items back. N matches. MED-C13 — Settings cache-wipe also clears in-memory VM SubscriptionFeedViewModel.clearInMemoryCache() exposed; Settings's Switch.onCheckedChange(false) now calls it alongside the disk wipe. Without this the feed kept rendering its in-memory mirror until process death. MED-C5 — drop StrawHome.formatDurationShort Near-duplicate of util.formatDuration. Used util's version + the existing `if (durationSeconds > 0)` guard at the call site already produces identical output (util returns "" on sec <= 0). MED-C19 — drop unused Surface import in StrawHome. NowPlaying gained one public method (claim). Everything else is internal-only churn. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +-- .../main/kotlin/com/sulkta/straw/StrawHome.kt | 11 ++----- .../feature/feed/SubscriptionFeedViewModel.kt | 31 ++++++++++++++----- .../straw/feature/player/MinibarOverlay.kt | 14 +++++++++ .../sulkta/straw/feature/player/NowPlaying.kt | 25 +++++++++++++++ .../feature/player/StrawMediaController.kt | 15 ++++++--- .../straw/feature/settings/SettingsScreen.kt | 7 +++++ 7 files changed, 83 insertions(+), 24 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 4ba83af96..901e66c2e 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 35 -const val STRAW_VERSION_NAME = "0.1.0-AU" +const val STRAW_VERSION_CODE = 36 +const val STRAW_VERSION_NAME = "0.1.0-AV" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt index ff2d26d34..2461a8182 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt @@ -48,7 +48,6 @@ import androidx.compose.material3.ModalDrawerSheet import androidx.compose.material3.ModalNavigationDrawer import androidx.compose.material3.NavigationDrawerItem import androidx.compose.material3.Scaffold -import androidx.compose.material3.Surface import androidx.compose.material3.Text import androidx.compose.material3.TextButton import androidx.compose.material3.TopAppBar @@ -81,6 +80,7 @@ import com.sulkta.straw.data.WatchHistoryItem import com.sulkta.straw.feature.feed.SubscriptionFeedViewModel import com.sulkta.straw.feature.search.StreamItem import com.sulkta.straw.OverlayDimColor +import com.sulkta.straw.util.formatDuration import com.sulkta.straw.util.formatViews import kotlinx.coroutines.launch @@ -524,7 +524,7 @@ private fun ThumbnailWithDuration( ) if (durationSeconds > 0) { Text( - text = formatDurationShort(durationSeconds), + text = formatDuration(durationSeconds), style = MaterialTheme.typography.labelSmall, color = androidx.compose.ui.graphics.Color.White, modifier = Modifier @@ -538,13 +538,6 @@ private fun ThumbnailWithDuration( } } -private fun formatDurationShort(totalSec: Long): String { - val h = totalSec / 3600 - val m = (totalSec % 3600) / 60 - val s = totalSec % 60 - return if (h > 0) "%d:%02d:%02d".format(h, m, s) else "%d:%02d".format(m, s) -} - @Composable private fun SubChip( ch: ChannelRef, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt index fbdff939b..e5a6408c4 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt @@ -214,19 +214,34 @@ class SubscriptionFeedViewModel : ViewModel() { private fun mergeFromCache(channels: List): List { val subUrls = channels.map { it.url }.toSet() // Drop cache entries for unsubscribed channels so removed subs - // fall out of the feed immediately. + // fall out of the feed immediately. (Has a side effect on the + // ConcurrentHashMap — kept here for atomicity vs. a separate + // pass.) channelCache.keys.toList().forEach { if (it !in subUrls) channelCache.remove(it) } + // Newest-first across channels. Pre-compute recencyScore once + // per item — vc=35 audit MED-Q15: sortedWith's comparator was + // invoking the regex twice per pair, so ~1800 regex matches on + // a 900-item merge. Pairing the score before sort drops that + // to N matches. return channels.flatMap { ch -> channelCache[ch.url]?.items.orEmpty() } - // Newest-first across channels. Falls back to viewCount when - // we couldn't parse the relative date (older items + live - // streams come back without one). + .map { it to it.recencyScore() } .sortedWith( - compareByDescending { it.recencyScore() } - .thenByDescending { it.viewCount }, + compareByDescending> { it.second } + .thenByDescending { it.first.viewCount }, ) - // Generous cap. Anything past this is almost certainly noise - // for a feed view; pagination in the UI further slices this. .take(500) + .map { it.first } + } + + /** + * Clear in-memory cache. Called from Settings when the user flips + * off the local-cache toggle — disk wipe via FeedCacheStore.clear() + * was already there, but the VM kept its in-memory mirror so items + * stayed visible until process death. vc=35 audit MED-C13. + */ + fun clearInMemoryCache() { + channelCache.clear() + _ui.value = _ui.value.copy(items = emptyList(), lastFetchedAt = 0L) } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/MinibarOverlay.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/MinibarOverlay.kt index b9dbdcda6..a66cff9a6 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/MinibarOverlay.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/MinibarOverlay.kt @@ -69,11 +69,25 @@ fun MinibarOverlay( // Reflect the controller's play state in the play/pause icon. Listening // is the only reliable way; isPlaying snapshots stale between events. var isPlaying by remember { mutableStateOf(controller.isPlaying) } + val ctx = androidx.compose.ui.platform.LocalContext.current DisposableEffect(controller) { val listener = object : Player.Listener { override fun onIsPlayingChanged(playing: Boolean) { isPlaying = playing } + // vc=35 audit MED-Q11: if Background-button took the user + // to Home and the foreground audio fails, the only Player + // surface still listening is this minibar. Surface a Toast + // + clear NowPlaying so the minibar hides itself rather + // than claiming an already-dead session is "loaded". + override fun onPlayerError(error: androidx.media3.common.PlaybackException) { + android.widget.Toast.makeText( + ctx, + "playback error: ${error.errorCodeName}", + android.widget.Toast.LENGTH_LONG, + ).show() + NowPlaying.clear() + } } controller.addListener(listener) isPlaying = controller.isPlaying diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/NowPlaying.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/NowPlaying.kt index 75e00f29c..7c9cf6420 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/NowPlaying.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/NowPlaying.kt @@ -36,6 +36,31 @@ object NowPlaying { _current.value = item } + /** + * Atomically claim playback for `streamUrl`. Returns true if this + * call WON the claim (caller should now do setMediaItem + prepare + + * play). Returns false if someone else has already set the same + * streamUrl — typically because the inline-player effect and the + * fullscreen Player effect both fired in the same window during + * an inline→fullscreen transition. The losing caller does nothing; + * the winning caller's playback is already in flight. + * + * Uses MutableStateFlow.compareAndSet for the race-free transition. + * vc=35 audit HIGH-C6 — the previous "check NowPlaying then + * setPlayingFrom" sequence had a window where both checks could + * pass before either NowPlaying.set ran. + */ + fun claim(item: NowPlayingItem): Boolean { + while (true) { + val cur = _current.value + if (cur?.streamUrl == item.streamUrl) return false + if (_current.compareAndSet(cur, item)) return true + // Lost the CAS to a concurrent writer — retry against the + // fresh state. Bounded: at most a handful of competing + // callers in practice. + } + } + fun clear() { _current.value = null } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt index 498dc96a9..5c3013c5a 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt @@ -82,11 +82,12 @@ fun MediaController.setPlayingFrom( resolved: ResolvedPlayback, startPositionMs: Long = 0L, ) { - val item = buildMediaItem(title, uploader, thumbnail, resolved) ?: return - setMediaItem(item, startPositionMs) - prepare() - playWhenReady = true - NowPlaying.set( + val mediaItem = buildMediaItem(title, uploader, thumbnail, resolved) ?: return + // Atomic claim BEFORE any controller mutation. If a concurrent + // caller already set this URL (inline player + fullscreen Player + // racing each other on the same transition), we bail before + // double-priming the player. vc=35 audit HIGH-C6. + val claimed = NowPlaying.claim( NowPlayingItem( streamUrl = streamUrl, title = title, @@ -95,6 +96,10 @@ fun MediaController.setPlayingFrom( segments = resolved.segments, ), ) + if (!claimed) return + setMediaItem(mediaItem, startPositionMs) + prepare() + playWhenReady = true } @UnstableApi diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt index c5e834837..bc5e3583e 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt @@ -41,6 +41,7 @@ import androidx.compose.ui.platform.LocalContext import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.unit.dp import android.widget.Toast +import androidx.lifecycle.viewmodel.compose.viewModel import com.sulkta.straw.data.FeedCache import com.sulkta.straw.data.History import com.sulkta.straw.data.MaxResolution @@ -50,6 +51,7 @@ import com.sulkta.straw.data.Settings import com.sulkta.straw.data.ThemeMode import com.sulkta.straw.feature.dataimport.ImportResult import com.sulkta.straw.feature.dataimport.SettingsImport +import com.sulkta.straw.feature.feed.SubscriptionFeedViewModel import com.sulkta.straw.util.LogDump import kotlinx.coroutines.launch @@ -200,6 +202,7 @@ fun SettingsScreen() { style = MaterialTheme.typography.bodyLarge, fontWeight = FontWeight.SemiBold, ) + val feedVm: SubscriptionFeedViewModel = viewModel() Switch( checked = cacheEnabled, onCheckedChange = { checked -> @@ -209,6 +212,10 @@ fun SettingsScreen() { // defeats the purpose of opting out. FeedCache.get().clear() SearchCache.get().clear() + // vc=35 audit MED-C13 — wipe the in-memory + // copy too, otherwise items stayed visible + // until process death. + feedVm.clearInMemoryCache() } }, ) From 567423336ce4666f49da6e947796b476964060fb Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 14:05:58 -0700 Subject: [PATCH 24/72] =?UTF-8?q?vc=3D37:=20round-2=20audit-fix=20sprint?= =?UTF-8?q?=20=E2=80=94=202=20CRIT=20+=2011=20HIGH=20+=204=20MED?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Three round-2 Opus audits ran on the vc=35+vc=36 surface. CVE returned no new CRITs (round-1 fixes hold) but found 5 new HIGH. Code-health found 2 CRIT — both my own vc=35 regressions. Function- correctness found 5 BROKEN that the round-1 sweep missed. CRIT (from code-health round 2) R1 Subs feed avatar-backfill self-cancel loop. Subscriptions.updateAvatar emits a new _subs reference; SubsPane's LaunchedEffect(subs) reacts → refreshIfStale → refresh() → inFlight.cancel(). With N channels needing backfill the parallel-12 batch degenerated into N sequential single-channel fetches that kept aborting each other. Gated refreshIfStale on inFlight.isActive != true. R2 HistoryStore.recordAllWatches O(N²) input. The vc=35 bulk-import path collapsed N SP writes into 1 (good) but used ArrayList.add(0, item) inside a loop walking up to 50k input rows before take(50). ~1.25B shifts worst case. Rewritten: walk newest-first, filter blanks + seen IDs, stop at MAX_WATCHES. O(N) bounded by output cap. HIGH (from CVE round 2) CVE-1 PlayerScreen + VideoDetailScreen rendered raw error.message into the UI — Media3 HttpDataSource exceptions include the full request URI with sig=/pot=. User screenshots a playback error to a chat → full session credentials in the picture. Both surfaces now scrub via LogDump.scrubLine before rendering. CVE-2 SubscriptionsStore.addAll counter race — updateAndGet's lambda re-runs on CAS retry; var-outside- lambda increment double-counted. Now derives `added` from next.size - cur.size delta. CVE-3 sweepStale ran deleteRecursively() on cacheDir (up to ~256MB) on the main thread inside Application.onCreate. Moved to appScope.launch(Dispatchers.IO). CVE-MED-2 Expanded LogDump.SIGNED_PARAM_RE alternation to include n / lsig / ei / key / sparams. CVE-MED-3 PlayerScreen + VideoDetailScreen error handlers now also NowPlaying.clear() so the minibar doesn't keep claiming a dead session is loaded. CVE-MED-4 SettingsImport validates imported subscription / playlist / history URLs against IMPORT_ALLOWED_HOSTS at import time. Hostile NewPipe export can no longer smuggle attacker-controlled URLs. HIGH (from code-health round 2) R3 Store constructors hit SP + JSON-decode on main thread at Application.onCreate. Small stores (Settings, History, Subscriptions, Playlists) stay eager — sub-millisecond cost. Heavy stores (FeedCache ~225 KB, SearchCache ~150 KB) now lazy-init: their `init()` just stashes applicationContext; the actual Store + disk decode is built on first `get()`, which happens from VM IO-dispatched coroutines. R4 SearchViewModel.pool race with init coroutine. Switched pool to a plain @Volatile var (no observers anyway — LOW- R14) and exposed rebuildPool() so the cache-toggle handler and a future explicit hook can refresh it. R5 SubsPane first-paint empty flash. Seeded SubscriptionFeedUiState(loading = true) in the VM's initial state — the init coroutine always runs. R6 Dropped dead uploaderAvatar field on StreamItem. Written three places, read zero. Saved bytes in every cache entry. R7 Split mergeFromCache into pruneCacheToSubs + mergeFromCache (no side effect in the reader). Callers do prune then merge. R8 Settings cache-disable wipe now runs on Dispatchers.IO (3 SP-edit calls were on the UI thread). HIGH (from function-correctness round 2) B1 refresh() empty-channels also wipes disk cache (was in-memory only — disk orphans accumulated). B2 Settings cache OFF→ON now triggers feedVm.refresh() + searchVm.rebuildPool() so the user doesn't have to navigate away and back to repopulate. B3 SearchViewModel.submit() cache lookup was still doing SearchCache.get().load() on main (CRIT-C1 was only partial). Now uses entries.value (StateFlow snapshot). B5 SearchCacheStore.record now atomic via MutableStateFlow + updateAndGet (was load()→write() with no atomicity, so concurrent records lost entries). Q9 History.recordWatch wrapped in withContext(Dispatchers.IO). Q11 Minibar onPlayerError also stops the controller + clears media items (was leaking dead controller state). MED R10 Added comments at the 4 pre-flight NowPlaying checks noting they're optimizations, claim() is the safety guard. Prevents a future refactor recreating the round-1 race after deleting "the guard." R11 Minibar Toast continues but now layered with the controller.stop() + clearMediaItems(). CVE-MED-1 NowPlaying.claim updates metadata fields when the same URL is re-claimed (was returning false unconditionally, pinning truncated search titles over fresh-from-detail titles). Q3 onQueryChange clears state.error so a failed-submit's banner doesn't haunt the next reactive preview. Deferred to vc=38 (intentional cost/benefit): CVE HIGH-2 (Rust strawcore::search query= info-log) — needs a separate strawcore-core edit + rebuild. Logged as a follow-up. CVE HIGH-3 (DownloadManager setVisibleInDownloadsUi deprecated on API 29+) — only the direct-streaming download replacement is a full fix; that's a multi-day refactor. Q5/Q8 (SettingsImport hostile zip silent abort UX) — cosmetic dialog-title fix. Q12 (loadedUrl assignment ordering) — pre-existing, deferred again. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- .../main/kotlin/com/sulkta/straw/StrawApp.kt | 36 ++++++++++-- .../com/sulkta/straw/data/FeedCacheStore.kt | 28 ++++++--- .../com/sulkta/straw/data/HistoryStore.kt | 35 +++++++---- .../com/sulkta/straw/data/SearchCacheStore.kt | 54 ++++++++++++----- .../sulkta/straw/data/SubscriptionsStore.kt | 18 +++--- .../straw/feature/channel/ChannelViewModel.kt | 1 - .../feature/dataimport/SettingsImport.kt | 26 ++++++++- .../straw/feature/detail/VideoDetailScreen.kt | 21 ++++++- .../feature/detail/VideoDetailViewModel.kt | 29 ++++++---- .../feature/feed/SubscriptionFeedViewModel.kt | 48 +++++++++++---- .../straw/feature/player/MinibarOverlay.kt | 13 ++++- .../sulkta/straw/feature/player/NowPlaying.kt | 10 +++- .../straw/feature/player/PlayerScreen.kt | 14 ++++- .../straw/feature/search/SearchViewModel.kt | 58 ++++++++++++------- .../straw/feature/settings/SettingsScreen.kt | 33 ++++++++--- .../kotlin/com/sulkta/straw/util/LogDump.kt | 12 +++- 17 files changed, 328 insertions(+), 112 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 901e66c2e..4e4aea201 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 36 -const val STRAW_VERSION_NAME = "0.1.0-AV" +const val STRAW_VERSION_CODE = 37 +const val STRAW_VERSION_NAME = "0.1.0-AW" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt index a6ae34c13..2d867add7 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt @@ -13,8 +13,19 @@ import com.sulkta.straw.data.SearchCache import com.sulkta.straw.data.Settings import com.sulkta.straw.data.Subscriptions import com.sulkta.straw.feature.dataimport.SettingsImport +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.SupervisorJob +import kotlinx.coroutines.launch class StrawApp : Application() { + /** + * App-scoped coroutine scope for one-time startup work that + * shouldn't tie up Application.onCreate. SupervisorJob so a failure + * in one launch doesn't cascade. + */ + private val appScope = CoroutineScope(SupervisorJob() + Dispatchers.IO) + override fun onCreate() { super.onCreate() // Path C-7: route Rust `log::*` calls into Android logcat under tag @@ -22,16 +33,29 @@ class StrawApp : Application() { // strawcore is silently dropped, making playback regressions invisible // from `adb logcat`. uniffi.strawcore.initLogging() - History.init(this) + // Small + universally-accessed stores: synchronous init. + // Settings is a handful of SP keys (read on first compose for + // themeMode), History caps at 50 watches + 20 searches, + // Subscriptions is a single channel list — sub-millisecond + // cost on cold cache. Settings.init(this) + History.init(this) Subscriptions.init(this) Playlists.init(this) + // vc=36 audit HIGH-R3: FeedCache (~225 KB) + SearchCache + // (~150 KB) JSON-decode at construction. Stash the + // applicationContext eagerly (cheap) so `get()` is callable + // anywhere; the actual store construction (and the disk + // decode that goes with it) is lazy. ViewModels accessing + // these on IO trigger the construction there — never on the + // main thread. FeedCache.init(this) SearchCache.init(this) - // Sweep any newpipe-import-* work-dirs left in cacheDir by a - // previous import that was killed mid-extraction. CRIT from - // the vc=34 security audit — the user's full NewPipe DB would - // otherwise live in cacheDir until the next deleteRecursively. - SettingsImport.sweepStale(this) + // vc=36 audit CVE HIGH-5: sweepStale's deleteRecursively() + // can walk ~256 MB if a previous import was LMK-killed + // mid-extraction. Strictly off the main thread. + appScope.launch { + SettingsImport.sweepStale(this@StrawApp) + } } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/FeedCacheStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/FeedCacheStore.kt index 0464d25a3..deb46f2f6 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/FeedCacheStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/FeedCacheStore.kt @@ -56,16 +56,30 @@ class FeedCacheStore(context: Context) { } object FeedCache { + @Volatile private var appContext: Context? = null @Volatile private var instance: FeedCacheStore? = null + /** + * Lazy init: stash the applicationContext only. The actual Store + * (and the ~225 KB JSON decode that happens at construction) is + * deferred until the first `get()` call. Lets Application.onCreate + * return quickly while every caller still gets a valid Store — + * vc=36 audit HIGH-R3. Callers should access from a coroutine + * (IO dispatcher) where the lazy construction cost is acceptable. + */ fun init(context: Context) { - if (instance == null) { - synchronized(this) { - if (instance == null) instance = FeedCacheStore(context.applicationContext) - } - } + appContext = context.applicationContext } - fun get(): FeedCacheStore = instance - ?: error("FeedCacheStore not initialized — call FeedCache.init(context)") + fun get(): FeedCacheStore { + instance?.let { return it } + synchronized(this) { + instance?.let { return it } + val ctx = appContext + ?: error("FeedCacheStore not initialized — call FeedCache.init(context)") + val built = FeedCacheStore(ctx) + instance = built + return built + } + } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt index 7ecc397d7..8e944d7c6 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt @@ -58,24 +58,37 @@ class HistoryStore(context: Context) { /** * Bulk import. Callers (currently SettingsImport) feed - * oldest→newest so the most-recent entries end up at the front - * of the capped list. Single SP write — vc=34 audit flagged the + * oldest→newest. Single SP write — vc=34 audit flagged the * per-row recordWatch in importHistory as a write-storm vector. + * + * O(N) on input size, not O(N²). The vc=35 first cut had an + * `add(0, item)` inside a loop walking up to MAX_HISTORY_IMPORT + * (~50k) entries — ArrayList shift over `merged.size` each step, + * a billion+ shifts in the worst case for a final `take(50)` that + * discards 99.9% of the work. Round-2 audit CRIT-R2. + * + * New shape: walk input newest-first (reversed; SettingsImport + * fed oldest-first), filter blanks + already-seen videoIds, take + * up to MAX_WATCHES, prepend to current. Done in one pass with + * the capped output never exceeding MAX_WATCHES. */ fun recordAllWatches(items: List) { if (items.isEmpty()) return val next = _watches.updateAndGet { current -> - val seen = current.map { it.videoId }.toMutableSet() - val merged = current.toMutableList() - for (item in items) { + val seen = HashSet(current.size + items.size) + current.forEach { seen.add(it.videoId) } + val capacity = (MAX_WATCHES - current.size).coerceAtLeast(0) + if (capacity == 0) return@updateAndGet current + val fresh = ArrayList(capacity) + // Walk newest-first; stop as soon as we have capacity. + val it = items.listIterator(items.size) + while (it.hasPrevious() && fresh.size < capacity) { + val item = it.previous() if (item.videoId.isBlank()) continue - if (item.videoId in seen) { - merged.removeAll { it.videoId == item.videoId } - } - seen.add(item.videoId) - merged.add(0, item) + if (!seen.add(item.videoId)) continue + fresh.add(item) } - merged.take(MAX_WATCHES) + (fresh + current).take(MAX_WATCHES) } sp.edit().putString(KEY_WATCHES, json.encodeToString(next)).apply() } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt index 10f5a961d..ff917b7e4 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt @@ -11,6 +11,11 @@ * Sized for SharedPreferences: 30 queries * 20 items each * ~250 bytes * = ~150 KB worst case. * + * Backed by a MutableStateFlow loaded once at construction — + * record()/load() are atomic against concurrent calls. vc=36 audit + * B5: the prior load()→edit()→write() pattern would clobber a + * concurrent record() with whichever happened to persist last. + * * Skips entirely when Settings.cacheEnabled is false — caller checks * the flag before reading/writing. */ @@ -20,6 +25,10 @@ package com.sulkta.straw.data import android.content.Context import android.content.SharedPreferences import com.sulkta.straw.feature.search.StreamItem +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.updateAndGet import kotlinx.serialization.Serializable import kotlinx.serialization.json.Json @@ -39,43 +48,60 @@ class SearchCacheStore(context: Context) { private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) private val json = Json { ignoreUnknownKeys = true } - fun load(): List = runCatching { - val s = sp.getString(KEY, null) ?: return emptyList() - json.decodeFromString>(s) - }.getOrDefault(emptyList()) + private val _entries = MutableStateFlow(loadFromDisk()) + val entries: StateFlow> = _entries.asStateFlow() + + /** Snapshot of the cache. Used by the reactive search filter. */ + fun load(): List = _entries.value /** * Record a freshly-fetched query result. Idempotent: a re-run of * the same query overwrites the prior entry rather than duplicating. * Oldest entries fall off when MAX_QUERIES is exceeded. + * + * Atomic via updateAndGet — concurrent records don't lose entries. */ fun record(query: String, items: List) { val q = query.trim() if (q.isEmpty() || items.isEmpty()) return val capped = items.take(MAX_ITEMS_PER_QUERY) val now = System.currentTimeMillis() - val current = load() - val without = current.filterNot { it.query.equals(q, ignoreCase = true) } - val next = (listOf(SearchCacheEntry(q, now, capped)) + without).take(MAX_QUERIES) + val next = _entries.updateAndGet { current -> + val without = current.filterNot { it.query.equals(q, ignoreCase = true) } + (listOf(SearchCacheEntry(q, now, capped)) + without).take(MAX_QUERIES) + } sp.edit().putString(KEY, json.encodeToString(next)).apply() } fun clear() { + _entries.value = emptyList() sp.edit().remove(KEY).apply() } + + private fun loadFromDisk(): List = runCatching { + val s = sp.getString(KEY, null) ?: return emptyList() + json.decodeFromString>(s) + }.getOrDefault(emptyList()) } object SearchCache { + @Volatile private var appContext: Context? = null @Volatile private var instance: SearchCacheStore? = null + /** Lazy init — see FeedCache.init for the rationale. */ fun init(context: Context) { - if (instance == null) { - synchronized(this) { - if (instance == null) instance = SearchCacheStore(context.applicationContext) - } - } + appContext = context.applicationContext } - fun get(): SearchCacheStore = instance - ?: error("SearchCacheStore not initialized — call SearchCache.init(context)") + fun get(): SearchCacheStore { + instance?.let { return it } + synchronized(this) { + instance?.let { return it } + val ctx = appContext + ?: error("SearchCacheStore not initialized — call SearchCache.init(context)") + val built = SearchCacheStore(ctx) + instance = built + return built + } + } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt index e4d897927..9675b005e 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt @@ -73,20 +73,22 @@ class SubscriptionsStore(context: Context) { * caller can report an "added X" stat. */ fun addAll(refs: List): Int { - var added = 0 - val next = _subs.updateAndGet { cur -> - val byUrl = cur.associateBy { it.url }.toMutableMap() + // Derive `added` from the size delta INSTEAD of incrementing a + // var inside updateAndGet's lambda — that lambda can re-run + // under CAS contention (a concurrent toggle from the channel + // screen during a 500-row import), and a var-outside-lambda + // accumulates across retries. vc=36 audit CVE HIGH-4. + val cur = _subs.value + val next = _subs.updateAndGet { state -> + val byUrl = state.associateBy { it.url }.toMutableMap() for (r in refs) { if (r.url.isBlank()) continue - if (r.url !in byUrl) { - byUrl[r.url] = r - added++ - } + if (r.url !in byUrl) byUrl[r.url] = r } byUrl.values.toList() } persist(next) - return added + return next.size - cur.size } fun clear() { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt index 027d0bfa9..82a3d4245 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt @@ -42,7 +42,6 @@ class ChannelViewModel : ViewModel() { title = v.title.ifBlank { "(no title)" }, uploader = v.uploader, uploaderUrl = v.uploaderUrl, - uploaderAvatar = ch.avatar, thumbnail = v.thumbnail, durationSeconds = v.durationSeconds, viewCount = v.viewCount, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/dataimport/SettingsImport.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/dataimport/SettingsImport.kt index f2bab6d72..b35185009 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/dataimport/SettingsImport.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/dataimport/SettingsImport.kt @@ -102,6 +102,23 @@ object SettingsImport { // YouTube only — Straw doesn't extract from other services. private const val YT_SERVICE_ID = 0 + // Mirror of StrawActivity.YT_HOSTS — kept inline rather than + // imported because the activity holds the canonical copy and + // SettingsImport is the only other consumer. + // vc=36 audit CVE MED-4 — validate imported URLs at import time + // so a hostile NewPipe export can't smuggle attacker-controlled + // URLs into PlaylistStore / HistoryStore. + private val IMPORT_ALLOWED_HOSTS = setOf( + "youtube.com", "www.youtube.com", "m.youtube.com", + "music.youtube.com", "youtube-nocookie.com", "www.youtube-nocookie.com", + "youtu.be", + ) + + private fun isAllowedYtUrl(url: String): Boolean { + val host = runCatching { java.net.URI(url).host?.lowercase() }.getOrNull() ?: return false + return host in IMPORT_ALLOWED_HOSTS + } + suspend fun run(context: Context, zipUri: Uri): Result = withContext(Dispatchers.IO) { runCatching { runInner(context, zipUri) } @@ -275,6 +292,10 @@ object SettingsImport { continue } val url = c.getString(0) ?: continue + if (!isAllowedYtUrl(url)) { + skipped++ + continue + } val name = c.getString(1) ?: continue val avatar = c.getString(2) staged += ChannelRef(url = url, name = name, avatar = avatar) @@ -314,8 +335,10 @@ object SettingsImport { ).use { c -> while (c.moveToNext()) { if (c.getInt(4) != YT_SERVICE_ID) continue + val streamUrl = c.getString(0) ?: continue + if (!isAllowedYtUrl(streamUrl)) continue items += PlaylistItem( - streamUrl = c.getString(0) ?: continue, + streamUrl = streamUrl, title = c.getString(1) ?: "(no title)", thumbnail = c.getString(2), uploader = c.getString(3) ?: "", @@ -391,6 +414,7 @@ object SettingsImport { while (c.moveToNext()) { if (c.getInt(5) != YT_SERVICE_ID) continue val url = c.getString(0) ?: continue + if (!isAllowedYtUrl(url)) continue val title = c.getString(1) ?: continue val uploader = c.getString(2) ?: "" val thumb = c.getString(3) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index 8e6304966..d28b26527 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -99,6 +99,7 @@ import com.sulkta.straw.feature.player.LocalStrawController import com.sulkta.straw.feature.player.NowPlaying import com.sulkta.straw.feature.player.setPlayingFrom import com.sulkta.straw.feature.search.StreamItem +import com.sulkta.straw.util.LogDump import com.sulkta.straw.util.formatCount import com.sulkta.straw.util.formatViews import com.sulkta.straw.util.stripHtml @@ -346,6 +347,11 @@ fun VideoDetailScreen( // Make sure the controller is playing this video // before backing out — otherwise dropping to the // minibar would dismiss into an empty slot. + // Optimization: skip the MediaItem build if + // the controller is already on this URL. + // claim() in setPlayingFrom is the + // authoritative race-free guard — this + // check is just to avoid the work. if (NowPlaying.current.value?.streamUrl != streamUrl) { val r = state.resolved if (r == null) { @@ -397,6 +403,11 @@ fun VideoDetailScreen( Toast.makeText(context, "stream not ready", Toast.LENGTH_SHORT).show() return@OutlinedButton } + // Optimization: skip the MediaItem build if + // the controller is already on this URL. + // claim() in setPlayingFrom is the + // authoritative race-free guard — this + // check is just to avoid the work. if (NowPlaying.current.value?.streamUrl != streamUrl) { c.setPlayingFrom( streamUrl = streamUrl, @@ -714,6 +725,7 @@ private fun InlinePlayer( LaunchedEffect(controller, resolved, streamUrl) { val c = controller ?: return@LaunchedEffect val r = resolved ?: return@LaunchedEffect + // Optimization, not safety. claim() guards the race. if (NowPlaying.current.value?.streamUrl == streamUrl) return@LaunchedEffect c.setPlayingFrom( streamUrl = streamUrl, @@ -729,7 +741,14 @@ private fun InlinePlayer( val c = controller val listener = object : Player.Listener { override fun onPlayerError(error: androidx.media3.common.PlaybackException) { - playbackError = "${error.errorCodeName}: ${error.message ?: "(no message)"}" + // Scrub the message — Media3's HttpDataSource exceptions + // include the full signed URL in .message. vc=36 audit + // CVE HIGH-1. + val raw = error.message ?: "(no message)" + playbackError = "${error.errorCodeName}: ${LogDump.scrubLine(raw)}" + // Clear NowPlaying so the minibar drops the dead + // session. vc=36 audit MED-3. + NowPlaying.clear() } } c?.addListener(listener) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt index 19e2b2fb5..61e8744b8 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt @@ -101,17 +101,23 @@ class VideoDetailViewModel : ViewModel() { val title = info.title.ifBlank { "(no title)" } val uploader = info.uploader - runCatching { - History.get().recordWatch( - WatchHistoryItem( - url = streamUrl, - videoId = videoId, - title = title, - uploader = uploader, - thumbnail = thumb, - watchedAt = 0L, - ), - ) + // Move SP write off the main coroutine — recordWatch + // JSON-encodes the watch list (up to 50 entries) + + // sp.edit().apply(). Small but synchronous; vc=36 + // audit Q9. + withContext(Dispatchers.IO) { + runCatching { + History.get().recordWatch( + WatchHistoryItem( + url = streamUrl, + videoId = videoId, + title = title, + uploader = uploader, + thumbnail = thumb, + watchedAt = 0L, + ), + ) + } } val ryd = withContext(Dispatchers.IO) { @@ -152,7 +158,6 @@ class VideoDetailViewModel : ViewModel() { title = v.title.ifBlank { "(no title)" }, uploader = v.uploader.ifBlank { uploader }, uploaderUrl = v.uploaderUrl ?: uploaderUrl, - uploaderAvatar = ch.avatar, thumbnail = v.thumbnail, durationSeconds = v.durationSeconds, viewCount = v.viewCount, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt index e5a6408c4..2dffb22e9 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt @@ -49,7 +49,11 @@ data class SubscriptionFeedUiState( ) class SubscriptionFeedViewModel : ViewModel() { - private val _ui = MutableStateFlow(SubscriptionFeedUiState()) + // Seed loading=true: the init block always either hydrates from + // disk or fires a refresh, so the user should see the spinner + // (or cached content under it) rather than a one-frame flash of + // empty. vc=36 audit HIGH-R5. + private val _ui = MutableStateFlow(SubscriptionFeedUiState(loading = true)) val ui: StateFlow = _ui.asStateFlow() /** @@ -77,6 +81,7 @@ class SubscriptionFeedViewModel : ViewModel() { channelCache.putAll(saved) val channels = Subscriptions.get().subs.value if (channels.isNotEmpty()) { + pruneCacheToSubs(channels) _ui.value = _ui.value.copy( items = mergeFromCache(channels), lastFetchedAt = saved.values.maxOfOrNull { it.fetchedAt } ?: 0L, @@ -112,6 +117,14 @@ class SubscriptionFeedViewModel : ViewModel() { private var inFlight: Job? = null fun refreshIfStale() { + // Skip if a refresh is already in flight. vc=36 audit CRIT-R1: + // SubsPane's LaunchedEffect(subs) re-fires every time + // Subscriptions.updateAvatar emits a fresh list reference (which + // fetchChannelInto does opportunistically per channel). Without + // this gate, each per-channel avatar backfill cancels the + // parallel-12 batch and turns the refresh into N sequential + // single-channel fetches. + if (inFlight?.isActive == true) return val now = System.currentTimeMillis() val anyStale = Subscriptions.get().subs.value.any { ch -> val entry = channelCache[ch.url] @@ -125,6 +138,14 @@ class SubscriptionFeedViewModel : ViewModel() { if (channels.isEmpty()) { _ui.update { SubscriptionFeedUiState(loading = false, items = emptyList()) } channelCache.clear() + // Wipe disk too. vc=36 audit B1: previously the disk + // cache kept stale entries indefinitely after the user + // unsubscribed from everything. mergeFromCache eventually + // prunes them on the next merge, but they sat as orphans + // through cold starts in the meantime. + viewModelScope.launch(Dispatchers.IO) { + runCatching { FeedCache.get().clear() } + } return } inFlight?.cancel() @@ -142,6 +163,7 @@ class SubscriptionFeedViewModel : ViewModel() { .map { ch -> async { gate.withPermit { fetchChannelInto(ch) } } } .awaitAll() } + pruneCacheToSubs(channels) _ui.update { SubscriptionFeedUiState( loading = false, @@ -189,7 +211,6 @@ class SubscriptionFeedViewModel : ViewModel() { title = v.title.ifBlank { "(no title)" }, uploader = v.uploader.ifBlank { ch.name }, uploaderUrl = v.uploaderUrl ?: ch.url, - uploaderAvatar = freshAvatar ?: ch.avatar, thumbnail = v.thumbnail, durationSeconds = v.durationSeconds, viewCount = v.viewCount, @@ -211,18 +232,21 @@ class SubscriptionFeedViewModel : ViewModel() { } } - private fun mergeFromCache(channels: List): List { + private fun pruneCacheToSubs(channels: List) { val subUrls = channels.map { it.url }.toSet() - // Drop cache entries for unsubscribed channels so removed subs - // fall out of the feed immediately. (Has a side effect on the - // ConcurrentHashMap — kept here for atomicity vs. a separate - // pass.) channelCache.keys.toList().forEach { if (it !in subUrls) channelCache.remove(it) } - // Newest-first across channels. Pre-compute recencyScore once - // per item — vc=35 audit MED-Q15: sortedWith's comparator was - // invoking the regex twice per pair, so ~1800 regex matches on - // a 900-item merge. Pairing the score before sort drops that - // to N matches. + } + + private fun mergeFromCache(channels: List): List { + // Pure read. Caller is responsible for calling pruneCacheToSubs + // beforehand when channel-set changes matter — split here + // because the prior version's "merge" name hid a side-effecting + // prune that violated single-responsibility (vc=36 audit + // HIGH-R7). + // + // Pre-compute recencyScore once per item — vc=35 audit + // MED-Q15: sortedWith's comparator was invoking the regex + // twice per pair, so ~1800 regex matches on a 900-item merge. return channels.flatMap { ch -> channelCache[ch.url]?.items.orEmpty() } .map { it to it.recencyScore() } .sortedWith( diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/MinibarOverlay.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/MinibarOverlay.kt index a66cff9a6..596d609aa 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/MinibarOverlay.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/MinibarOverlay.kt @@ -77,15 +77,22 @@ fun MinibarOverlay( } // vc=35 audit MED-Q11: if Background-button took the user // to Home and the foreground audio fails, the only Player - // surface still listening is this minibar. Surface a Toast - // + clear NowPlaying so the minibar hides itself rather - // than claiming an already-dead session is "loaded". + // surface still listening is this minibar. + // vc=36 audit MED-3 + Q11: also stop the controller so a + // future tap doesn't seek into the dead state, AND clear + // NowPlaying so the minibar hides itself. (PlayerScreen + // and VideoDetailScreen's listeners also clear NowPlaying + // now, so this is the fallback when neither is alive.) override fun onPlayerError(error: androidx.media3.common.PlaybackException) { android.widget.Toast.makeText( ctx, "playback error: ${error.errorCodeName}", android.widget.Toast.LENGTH_LONG, ).show() + runCatching { + controller.stop() + controller.clearMediaItems() + } NowPlaying.clear() } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/NowPlaying.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/NowPlaying.kt index 7c9cf6420..247ed09ef 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/NowPlaying.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/NowPlaying.kt @@ -53,7 +53,15 @@ object NowPlaying { fun claim(item: NowPlayingItem): Boolean { while (true) { val cur = _current.value - if (cur?.streamUrl == item.streamUrl) return false + if (cur?.streamUrl == item.streamUrl) { + // Same URL — caller doesn't need to re-prepare the + // player, but if it brought richer metadata (full + // title vs the search-result truncation, fresh + // thumbnail, updated SponsorBlock segments) refresh + // those fields. vc=36 round-2 CVE MED-1. + if (cur != item) _current.compareAndSet(cur, item) + return false + } if (_current.compareAndSet(cur, item)) return true // Lost the CAS to a concurrent writer — retry against the // fresh state. Bounded: at most a handful of competing diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt index 9a110a69c..155f471c2 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt @@ -75,6 +75,7 @@ import androidx.media3.ui.PlayerView import com.sulkta.straw.OverlayChromeColor import com.sulkta.straw.feature.detail.VideoDetailViewModel import com.sulkta.straw.net.SbSegment +import com.sulkta.straw.util.LogDump import com.sulkta.straw.util.strawLogI import kotlinx.coroutines.delay @@ -108,6 +109,7 @@ fun PlayerScreen( val r = resolved ?: return@LaunchedEffect val uploader = detail?.uploader.orEmpty() val thumbnail = detail?.thumbnail + // Optimization, not safety. claim() guards the race. if (NowPlaying.current.value?.streamUrl == streamUrl) return@LaunchedEffect c.setPlayingFrom( streamUrl = streamUrl, @@ -124,7 +126,17 @@ fun PlayerScreen( val c = controller val listener = object : Player.Listener { override fun onPlayerError(error: androidx.media3.common.PlaybackException) { - playbackError = "${error.errorCodeName}: ${error.message ?: "(no message)"}" + // Scrub the message before rendering. Media3's + // HttpDataSource exceptions embed the full request URI + // (with signature= / pot= / cpn=) in the .message + // string — visible in the on-screen error banner and + // a screenshot away from being shared. vc=36 audit + // CVE HIGH-1. + val raw = error.message ?: "(no message)" + playbackError = "${error.errorCodeName}: ${LogDump.scrubLine(raw)}" + // Also clear NowPlaying so the minibar doesn't keep + // claiming a dead session is loaded. vc=36 audit MED-3. + NowPlaying.clear() } } c?.addListener(listener) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt index 6cb952a1f..4b938edd3 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt @@ -37,7 +37,6 @@ data class StreamItem( val title: String, val uploader: String, val uploaderUrl: String?, - val uploaderAvatar: String? = null, val thumbnail: String?, val durationSeconds: Long, val viewCount: Long, @@ -51,18 +50,36 @@ class SearchViewModel : ViewModel() { /** * In-memory snapshot of the disk corpus (saved search results + - * subs feed cache) for reactive filtering. Hydrated on Dispatchers.IO - * once at VM construction and refreshed after a successful submit. - * vc=34 audit CRIT — the previous implementation hit - * SharedPreferences + JSON-decoded ~225 KB on every keystroke, - * blocking the main thread. + * subs feed cache) for reactive filtering. Hydrated on + * Dispatchers.IO once at VM construction and refreshed after a + * successful submit. vc=34 audit CRIT-C1 — the previous + * implementation hit SharedPreferences + JSON-decoded ~225 KB on + * every keystroke, blocking the main thread. + * + * Plain @Volatile not StateFlow because nothing observes it + * (vc=36 audit LOW-R14 — the StateFlow synchronization buys + * nothing here). */ - private val pool = MutableStateFlow>(emptyList()) + @Volatile + private var pool: List = emptyList() init { + rebuildPool() + } + + /** + * Re-read both caches off the main thread and replace the pool + * snapshot. Called at construction and from Settings when the + * cache toggle flips ON (so a re-enable picks up freshly-seeded + * entries from a subsequent submit/refresh without waiting for + * process death). vc=36 audit B2/Q10. + */ + fun rebuildPool() { viewModelScope.launch { - if (Settings.get().cacheEnabled.value) { - pool.value = withContext(Dispatchers.IO) { buildPool() } + pool = if (Settings.get().cacheEnabled.value) { + withContext(Dispatchers.IO) { buildPool() } + } else { + emptyList() } } } @@ -73,10 +90,11 @@ class SearchViewModel : ViewModel() { }.distinctBy { it.url } fun onQueryChange(q: String) { - _ui.value = _ui.value.copy(query = q) - // Reactive filter: scan the in-memory `pool` as the user types. - // Pool is a List walked once per keystroke — bounded - // (~1500 items typical), no disk I/O, no JSON decode. + // Clear any prior error state when the user resumes typing — + // a failed submit's banner used to persist into the next + // reactive preview, looking like the new query had failed. + // vc=36 audit Q3. + _ui.value = _ui.value.copy(query = q, error = null) if (Settings.get().cacheEnabled.value && q.trim().length >= 2) { val matches = reactiveFilter(q.trim()) if (matches.isNotEmpty()) { @@ -84,16 +102,11 @@ class SearchViewModel : ViewModel() { results = matches, fromCache = true, loading = false, - error = null, ) } else if (_ui.value.fromCache) { - // User typed past what the cache can answer — drop the - // stale preview rather than leaving the prior query's - // results on screen pretending to match. _ui.value = _ui.value.copy(results = emptyList(), fromCache = false) } } else if (q.isBlank()) { - // Clear cached preview if the box is cleared. _ui.value = _ui.value.copy(results = emptyList(), fromCache = false) } } @@ -102,10 +115,13 @@ class SearchViewModel : ViewModel() { val q = _ui.value.query.trim() if (q.isEmpty()) return - // Cache hit on submit: show immediately, kick off a refresh - // behind it so the user gets fresh items shortly after. + // Cache hit on submit: show immediately, kick off refresh + // behind it. vc=36 audit B3 — the previous shape called + // `SearchCache.get().load()` on the main thread, doing the + // exact ~150 KB JSON decode the reactive-filter fix was + // supposed to eliminate. Now uses the StateFlow snapshot. val cached = if (Settings.get().cacheEnabled.value) { - SearchCache.get().load() + SearchCache.get().entries.value .firstOrNull { it.query.equals(q, ignoreCase = true) } ?.items } else null diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt index bc5e3583e..332e5b2f3 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt @@ -52,7 +52,10 @@ import com.sulkta.straw.data.ThemeMode import com.sulkta.straw.feature.dataimport.ImportResult import com.sulkta.straw.feature.dataimport.SettingsImport import com.sulkta.straw.feature.feed.SubscriptionFeedViewModel +import com.sulkta.straw.feature.search.SearchViewModel import com.sulkta.straw.util.LogDump +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext import kotlinx.coroutines.launch @Composable @@ -203,19 +206,31 @@ fun SettingsScreen() { fontWeight = FontWeight.SemiBold, ) val feedVm: SubscriptionFeedViewModel = viewModel() + val searchVm: SearchViewModel = viewModel() Switch( checked = cacheEnabled, onCheckedChange = { checked -> store.setCacheEnabled(checked) - if (!checked) { - // Wipe on disable — leaving stale bytes around - // defeats the purpose of opting out. - FeedCache.get().clear() - SearchCache.get().clear() - // vc=35 audit MED-C13 — wipe the in-memory - // copy too, otherwise items stayed visible - // until process death. - feedVm.clearInMemoryCache() + scope.launch { + if (!checked) { + withContext(Dispatchers.IO) { + runCatching { FeedCache.get().clear() } + runCatching { SearchCache.get().clear() } + } + feedVm.clearInMemoryCache() + // Drop the in-memory reactive-search pool + // too — without this, typing into Search + // still surfaces hits from the just-wiped + // disk cache. + searchVm.rebuildPool() + } else { + // Cache re-enabled: trigger a real refresh + // so the feed repopulates without waiting + // for the user to navigate away and back. + // vc=36 audit B2. + feedVm.refresh() + searchVm.rebuildPool() + } } }, ) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/util/LogDump.kt b/strawApp/src/main/kotlin/com/sulkta/straw/util/LogDump.kt index d66eac8a6..d5279a144 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/util/LogDump.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/util/LogDump.kt @@ -96,12 +96,20 @@ object LogDump { * disk. Cheap line-level pass — adversarial-perfect would need a * URL parser, but the regex approach catches every documented * leak vector at zero allocation cost. + * + * Public so error-handler call sites (PlayerScreen / VideoDetail + * `playbackError`) can scrub Media3's `PlaybackException.message` + * before rendering it to the user — that string includes the full + * request URI for HttpDataSource exceptions, which would otherwise + * be a leak via screenshot. vc=36 audit CVE HIGH-1. */ - internal fun scrubLine(line: String): String { + fun scrubLine(line: String): String { var s = line // Pre-signed googlevideo URLs: keep host visible, drop path+query. s = GOOGLEVIDEO_URL_RE.replace(s, "https://.googlevideo.com/") // Any remaining signed-param shapes that snuck through other URLs. + // Expanded set vc=36 audit CVE MED-2: + n (JS-deobfuscated n-sig), + // lsig (link signature), ei (encrypted event-id), key, sparams. s = SIGNED_PARAM_RE.replace(s, "$1=") return s } @@ -110,7 +118,7 @@ object LogDump { """https?://[a-zA-Z0-9.-]*googlevideo\.com/\S+""", ) private val SIGNED_PARAM_RE = Regex( - """\b(signature|sig|pot|cpn|expire|ip|mn|ms|mo|pl)=([^&\s"']+)""", + """\b(signature|sig|pot|cpn|expire|ip|mn|ms|mo|pl|n|lsig|ei|key|sparams)=([^&\s"']+)""", RegexOption.IGNORE_CASE, ) } From ec9d2f37afa749660f13d2ccb829151f74ae794c Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 14:09:11 -0700 Subject: [PATCH 25/72] vc=37 fix: pool changed from StateFlow to plain var; drop .value refs --- .../kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt index 4b938edd3..082d61fdb 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt @@ -172,7 +172,7 @@ class SearchViewModel : ViewModel() { // Refresh the in-memory pool with the new // entries so subsequent reactive filters see // them without waiting for a process restart. - pool.value = buildPool() + pool = buildPool() } } } catch (t: Throwable) { @@ -194,7 +194,7 @@ class SearchViewModel : ViewModel() { */ private fun reactiveFilter(q: String): List { val needle = q.lowercase() - return pool.value.asSequence() + return pool.asSequence() .filter { item -> item.title.lowercase().contains(needle) || item.uploader.lowercase().contains(needle) From 780bb6152c4e7c959d694c12775d6df3378bcd84 Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 14:11:00 -0700 Subject: [PATCH 26/72] vc=37 (rust): scrub PII from strawcore info-logs MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit CVE round-2 HIGH-2: android_logger is configured at info-level in release builds, so log::info!('strawcore::search query={}', query) emits the user's actual search query to logcat. LogDump.scrubLine's regex only catches googlevideo URLs + signed params — bare search text rides through into a Settings → Export Logs share-sheet attachment intact. Same for channel_info / stream_info URLs. Replaced the value-bearing logs with shape-only (query_len / input_len). The shape is enough to debug 'why did the search return empty?' without the privacy hit. --- rust/strawcore/src/channel.rs | 2 +- rust/strawcore/src/search.rs | 7 ++++++- rust/strawcore/src/stream.rs | 2 +- 3 files changed, 8 insertions(+), 3 deletions(-) diff --git a/rust/strawcore/src/channel.rs b/rust/strawcore/src/channel.rs index 67d48b8a9..3434905e5 100644 --- a/rust/strawcore/src/channel.rs +++ b/rust/strawcore/src/channel.rs @@ -23,7 +23,7 @@ pub struct ChannelInfo { #[uniffi::export(async_runtime = "tokio")] pub async fn channel_info(input: String) -> Result { - log::info!("strawcore::channel_info input={}", input); + log::info!("strawcore::channel_info input_len={}", input.len()); let identifier = resolve_channel_identifier(&input)?; let core = tokio::task::spawn_blocking(move || core_channel_info(identifier)) .await diff --git a/rust/strawcore/src/search.rs b/rust/strawcore/src/search.rs index b85b7ce7f..0a693ff61 100644 --- a/rust/strawcore/src/search.rs +++ b/rust/strawcore/src/search.rs @@ -54,7 +54,12 @@ pub(crate) fn from_core(item: StreamInfoItem) -> SearchItem { #[uniffi::export(async_runtime = "tokio")] pub async fn search(query: String) -> Result, StrawcoreError> { - log::info!("strawcore::search query={}", query); + // Don't log the query itself — searches are PII (sometimes + // names, sometimes embarrassing) and android_logger emits at + // info-level in release builds, which means they'd ride the + // Settings → Export Logs path straight into a user's chat. Log + // shape, not content. vc=36 audit CVE HIGH-2. + log::info!("strawcore::search query_len={}", query.len()); let result = tokio::task::spawn_blocking(move || { search_extractor::search(&query, SearchFilter::Videos) }) diff --git a/rust/strawcore/src/stream.rs b/rust/strawcore/src/stream.rs index 7a4ce6839..73da83e58 100644 --- a/rust/strawcore/src/stream.rs +++ b/rust/strawcore/src/stream.rs @@ -57,7 +57,7 @@ pub struct AudioStreamItem { #[uniffi::export(async_runtime = "tokio")] pub async fn stream_info(input: String) -> Result { - log::info!("strawcore::stream_info input={}", input); + log::info!("strawcore::stream_info input_len={}", input.len()); let video_id = resolve_video_id(&input)?; let video_id_for_call = video_id.clone(); let core = tokio::task::spawn_blocking(move || core_stream_info(&video_id_for_call)) From cbdba302ce5a5efe95b9006cbaf06e91ec2deeb7 Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 14:29:32 -0700 Subject: [PATCH 27/72] =?UTF-8?q?vc=3D38:=20round-3=20audit-fix=20sprint?= =?UTF-8?q?=20=E2=80=94=209=20HIGH=20+=207=20MED?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Three round-3 Opus audits ran on vc=37. NO new CRITs (round-2 work held) but real new HIGHs — several were vc=37 own-goals. HIGH R3-1 recordAllWatches dropped import on capacity=0. Old: when watches store hit MAX_WATCHES (50), capacity=0, the whole import was discarded silently. New: build fresh import list capped at MAX_WATCHES, then combine + take(MAX_WATCHES) so imports always land (truncating oldest current entries). Also: skip SP write when next === before (no-op import on already-saturated store no longer thrashes disk). New recordAllSearches with same shape — round-3 CVE MED-6: importHistory was per-row recordSearch. R3-2 / CVE-2 SubscriptionsStore.addAll counter race. The vc=36 size-delta fix snapshot `cur = _subs.value` BEFORE updateAndGet, so a concurrent toggle inflated `added`. New: AtomicInteger reset at the start of each lambda re-run, counted by checking each ref against the pre-image inside the CAS. Exactly the additions THIS call made. R3-3 refresh() empty-channels didn't cancel inFlight. Cancel moved to the top of refresh() unconditionally so a refresh on the prior sub set is killed before the empty branch clears + wipes disk. clearInMemoryCache also cancels inFlight — without it, a cache-disable flip during a refresh could see fetchChannelInto re-populate the just-cleared map. R3-4 Non-atomic `_ui.value = it.copy(...)` at init hydrate path and clearInMemoryCache. Replaced with `_ui.update {}` for atomicity vs concurrent refresh writes. init's lastFetchedAt write now uses maxOf so it never regresses past a fresh refresh value. CVE-1 state.error rendered raw UniFFI/Rust error strings to UI — NetworkError::Recaptcha { url } embeds full signed googlevideo URL. User screenshots a "reCAPTCHA at " banner → leak. All four VMs (Channel/Detail/Feed/Search) now scrub via LogDump.scrubLine before storing. CVE-3 pruneCacheToSubs in init can clobber concurrent fetchChannelInto writes. init's putAll → putIfAbsent so a fresh entry from a parallel refresh isn't overwritten with disk-stale data. CVE-4 SIGNED_PARAM_RE over-redacted short tokens (`\bn=` matched `n=42` counters from any wrapped lib). Split into SIGNED_PARAM_LONG_RE (signature/sparams/lsig/cpn/expire/ pot/sig/key — match anywhere) and SIGNED_PARAM_SHORT_RE (n/mn/ms/mo/pl/ip/ei — require `[?&]` immediately before). Func-HIGH-1 refresh() swallowed CancellationException as a user-visible error. Spam-tapping Refresh produced a "refresh failed: StandaloneCoroutineCancelled" banner. Re-throw CancellationException; catch only real errors. MED R3-5 reactiveFilter did N `.lowercase()` allocations per keystroke. Switched to contains(ignoreCase = true) — zero allocations. CVE-MED-5 FileProvider cache-path was "." (whole cacheDir, including SettingsImport workdirs). Narrowed to "logs/"; LogDump.capture now writes to cacheDir/logs/ to match. CVE-MED-7 Downloader.Request.setTitle was the raw title (bidi-override / control chars possible). Switched to safeTitle. CVE-MED-8 Rust hello_from_rust value-log scrubbed to name_len. Func-LOW-4 recordAllWatches skip-write-on-no-change (`next !== before`). Deferred to a follow-up (not user-facing this ship): R3-MED-6 — Settings setMaxResolution/setThemeMode/setCacheEnabled not atomic via updateAndGet. Inconsistent with toggle() but the Switch UI throttles enough that no real race. R3-MED-8 — Minibar play-button reads live controller.isPlaying instead of listener-tracked. One-frame oscillation on super-fast double-tap. R3-LOW — collectAsState vs collectAsStateWithLifecycle drift. Func-LOW-6 — refreshIfStale isActive check is TOCTOU on a non-existent multi-threaded call surface (LaunchedEffect + button are both Main). --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- rust/strawcore/src/lib.rs | 5 +- .../com/sulkta/straw/data/HistoryStore.kt | 64 ++++++++++++++----- .../sulkta/straw/data/SubscriptionsStore.kt | 21 +++--- .../straw/feature/channel/ChannelViewModel.kt | 8 ++- .../feature/dataimport/SettingsImport.kt | 9 ++- .../feature/detail/VideoDetailViewModel.kt | 4 +- .../straw/feature/download/Downloader.kt | 6 +- .../feature/feed/SubscriptionFeedViewModel.kt | 55 ++++++++++++---- .../straw/feature/search/SearchViewModel.kt | 12 ++-- .../kotlin/com/sulkta/straw/util/LogDump.kt | 31 ++++++--- strawApp/src/main/res/xml/file_paths.xml | 9 ++- 12 files changed, 167 insertions(+), 61 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 4e4aea201..7b8d1dc1d 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 37 -const val STRAW_VERSION_NAME = "0.1.0-AW" +const val STRAW_VERSION_CODE = 38 +const val STRAW_VERSION_NAME = "0.1.0-AX" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/rust/strawcore/src/lib.rs b/rust/strawcore/src/lib.rs index 1ca13d06c..2329d55ce 100644 --- a/rust/strawcore/src/lib.rs +++ b/rust/strawcore/src/lib.rs @@ -39,9 +39,12 @@ pub fn init_logging() { } /// Smoke-test entry point — round-trip a string through JNI. +/// Used during the initial UniFFI bring-up; kept for future smoke +/// debugging. Logs shape only — the `name` value never hits logcat +/// because a future caller might pass a real user-supplied string. #[uniffi::export] pub fn hello_from_rust(name: String) -> String { - log::info!("hello_from_rust called with name={}", name); + log::info!("hello_from_rust called name_len={}", name.len()); format!( "hello {} from rust 🦀 (strawcore v{})", name, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt index 8e944d7c6..30aca3d0c 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt @@ -61,36 +61,70 @@ class HistoryStore(context: Context) { * oldest→newest. Single SP write — vc=34 audit flagged the * per-row recordWatch in importHistory as a write-storm vector. * - * O(N) on input size, not O(N²). The vc=35 first cut had an - * `add(0, item)` inside a loop walking up to MAX_HISTORY_IMPORT - * (~50k) entries — ArrayList shift over `merged.size` each step, - * a billion+ shifts in the worst case for a final `take(50)` that - * discards 99.9% of the work. Round-2 audit CRIT-R2. + * Walks input newest-first (input is fed oldest-first), filters + * blanks + already-seen videoIds, prepends to current, then takes + * MAX_WATCHES. Imports WIN over older current entries when the + * store is at the cap — the vc=37 first cut silently discarded + * the whole import in that case (round-3 audit HIGH-1). * - * New shape: walk input newest-first (reversed; SettingsImport - * fed oldest-first), filter blanks + already-seen videoIds, take - * up to MAX_WATCHES, prepend to current. Done in one pass with - * the capped output never exceeding MAX_WATCHES. + * Skips the SP write when the resulting list is identical (by + * reference equality after updateAndGet's no-op return) so a + * spam-import on an already-up-to-date store doesn't thrash disk. */ fun recordAllWatches(items: List) { if (items.isEmpty()) return + val before = _watches.value val next = _watches.updateAndGet { current -> val seen = HashSet(current.size + items.size) current.forEach { seen.add(it.videoId) } - val capacity = (MAX_WATCHES - current.size).coerceAtLeast(0) - if (capacity == 0) return@updateAndGet current - val fresh = ArrayList(capacity) - // Walk newest-first; stop as soon as we have capacity. + // Build the import list newest-first. Capped at + // MAX_WATCHES on its own so we don't over-allocate + // even on a 50k-row hostile export. + val fresh = ArrayList(MAX_WATCHES) val it = items.listIterator(items.size) - while (it.hasPrevious() && fresh.size < capacity) { + while (it.hasPrevious() && fresh.size < MAX_WATCHES) { val item = it.previous() if (item.videoId.isBlank()) continue if (!seen.add(item.videoId)) continue fresh.add(item) } + if (fresh.isEmpty()) return@updateAndGet current + // Combine + cap. take() truncates older `current` entries + // when we'd exceed MAX_WATCHES, so imports always land. (fresh + current).take(MAX_WATCHES) } - sp.edit().putString(KEY_WATCHES, json.encodeToString(next)).apply() + if (next !== before) { + sp.edit().putString(KEY_WATCHES, json.encodeToString(next)).apply() + } + } + + /** + * Bulk import for search history. Same pattern as + * recordAllWatches — single SP write regardless of input size. + * vc=37 round-3 audit CVE-MED-6: SettingsImport.importHistory was + * calling recordSearch per row, producing N SP writes on a + * potentially-100k-row import. + */ + fun recordAllSearches(queries: List) { + if (queries.isEmpty()) return + val before = _searches.value + val next = _searches.updateAndGet { current -> + val seen = HashSet(current.size + queries.size) + current.forEach { seen.add(it.lowercase()) } + val fresh = ArrayList(MAX_SEARCHES) + val it = queries.listIterator(queries.size) + while (it.hasPrevious() && fresh.size < MAX_SEARCHES) { + val q = it.previous().trim() + if (q.isEmpty()) continue + if (!seen.add(q.lowercase())) continue + fresh.add(q) + } + if (fresh.isEmpty()) return@updateAndGet current + (fresh + current).take(MAX_SEARCHES) + } + if (next !== before) { + sp.edit().putString(KEY_SEARCHES, json.encodeToString(next)).apply() + } } fun recordSearch(query: String) { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt index 9675b005e..97a3bf994 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt @@ -73,22 +73,27 @@ class SubscriptionsStore(context: Context) { * caller can report an "added X" stat. */ fun addAll(refs: List): Int { - // Derive `added` from the size delta INSTEAD of incrementing a - // var inside updateAndGet's lambda — that lambda can re-run - // under CAS contention (a concurrent toggle from the channel - // screen during a 500-row import), and a var-outside-lambda - // accumulates across retries. vc=36 audit CVE HIGH-4. - val cur = _subs.value + // Count NEW refs by checking each input URL against the + // current state's pre-image inside the CAS lambda. Captures + // exactly the additions this call made — concurrent + // toggle()s that race the CAS don't inflate the count (vc=37 + // round-3 audit HIGH-2/CVE-2). The counter lives in an + // AtomicInteger so each lambda re-run resets it correctly. + val counter = java.util.concurrent.atomic.AtomicInteger(0) val next = _subs.updateAndGet { state -> + counter.set(0) val byUrl = state.associateBy { it.url }.toMutableMap() for (r in refs) { if (r.url.isBlank()) continue - if (r.url !in byUrl) byUrl[r.url] = r + if (r.url !in byUrl) { + byUrl[r.url] = r + counter.incrementAndGet() + } } byUrl.values.toList() } persist(next) - return next.size - cur.size + return counter.get() } fun clear() { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt index 82a3d4245..9bec03cb2 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt @@ -59,7 +59,13 @@ class ChannelViewModel : ViewModel() { } catch (t: Throwable) { _ui.value = ChannelUiState( loading = false, - error = t.message ?: t.javaClass.simpleName, + // Scrub before storing — UniFFI/Rust exceptions + // can embed full signed googlevideo URLs in the + // message (NetworkError::Recaptcha { url }). vc=37 + // round-3 audit CVE-1. + error = com.sulkta.straw.util.LogDump.scrubLine( + t.message ?: t.javaClass.simpleName, + ), ) } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/dataimport/SettingsImport.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/dataimport/SettingsImport.kt index b35185009..8ff1c3aea 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/dataimport/SettingsImport.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/dataimport/SettingsImport.kt @@ -378,16 +378,21 @@ object SettingsImport { openDb(dbFile).use { db -> // Search history — feed oldest first so the store ends up with // the most-recent on top after its own dedup + take(MAX). + // Stage + bulk-write — vc=37 round-3 audit CVE MED-6: + // per-row recordSearch was N SP writes on potentially + // 100k+ rows. The SELECT also lacked a LIMIT; added now. + val stagedSearches = mutableListOf() db.rawQuery( - "SELECT search FROM search_history WHERE service_id=? ORDER BY creation_date ASC", + "SELECT search FROM search_history WHERE service_id=? ORDER BY creation_date ASC LIMIT 50000", arrayOf(YT_SERVICE_ID.toString()), ).use { c -> while (c.moveToNext()) { val q = c.getString(0) ?: continue - historyStore.recordSearch(q) + stagedSearches += q searchesSeen++ } } + historyStore.recordAllSearches(stagedSearches) // Watch history — newest first via stream_history.access_date, // joined to streams for the metadata we need. diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt index 61e8744b8..602a3fab4 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt @@ -189,7 +189,9 @@ class VideoDetailViewModel : ViewModel() { } catch (t: Throwable) { _ui.value = VideoDetailUiState( loading = false, - error = t.message ?: t.javaClass.simpleName, + error = com.sulkta.straw.util.LogDump.scrubLine( + t.message ?: t.javaClass.simpleName, + ), ) } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/Downloader.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/Downloader.kt index 6ce34060e..b7ac792c2 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/Downloader.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/Downloader.kt @@ -65,7 +65,11 @@ object Downloader { // returned below, so user-facing UX is unaffected. val req = runCatching { DownloadManager.Request(Uri.parse(url)) - .setTitle(title) + // Sanitized title — bidi-overrides and control chars + // in extractor output would otherwise render in + // DownloadsScreen's row title. vc=37 round-3 audit + // CVE MED-7. + .setTitle(safeTitle) .setDescription("Straw — ${kind.name.lowercase()}") .setNotificationVisibility(DownloadManager.Request.VISIBILITY_HIDDEN) .setVisibleInDownloadsUi(false) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt index 2dffb22e9..5a87e73dd 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt @@ -25,6 +25,7 @@ import com.sulkta.straw.data.Settings import com.sulkta.straw.data.Subscriptions import com.sulkta.straw.feature.search.StreamItem import com.sulkta.straw.util.strawLogW +import kotlinx.coroutines.CancellationException import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.Job import kotlinx.coroutines.async @@ -78,14 +79,24 @@ class SubscriptionFeedViewModel : ViewModel() { if (!Settings.get().cacheEnabled.value) return@launch val saved = withContext(Dispatchers.IO) { FeedCache.get().load() } if (saved.isEmpty()) return@launch - channelCache.putAll(saved) + // putIfAbsent (not putAll) — refresh() may have started + // populating fresh entries during our IO suspension; we + // must not overwrite those with disk-stale values. + // vc=37 round-3 audit CVE-3. + saved.forEach { (url, entry) -> channelCache.putIfAbsent(url, entry) } val channels = Subscriptions.get().subs.value if (channels.isNotEmpty()) { pruneCacheToSubs(channels) - _ui.value = _ui.value.copy( - items = mergeFromCache(channels), - lastFetchedAt = saved.values.maxOfOrNull { it.fetchedAt } ?: 0L, - ) + val savedTs = saved.values.maxOfOrNull { it.fetchedAt } ?: 0L + // _ui.update so a concurrent refresh()'s state write + // doesn't race with this copy. vc=37 round-3 audit + // HIGH-4. Only advance lastFetchedAt — never regress. + _ui.update { + it.copy( + items = mergeFromCache(channels), + lastFetchedAt = maxOf(it.lastFetchedAt, savedTs), + ) + } } } } @@ -134,21 +145,23 @@ class SubscriptionFeedViewModel : ViewModel() { } fun refresh() { + // Cancel any in-flight refresh at the TOP — including before + // the empty-channels branch. Without this, a refresh that + // ran on a non-empty sub set could still be writing to + // channelCache when the user unsubscribes from the last + // channel; we'd clear() then immediately repopulate with + // phantom entries when the prior fetchChannelInto resolved. + // vc=37 round-3 audit HIGH-3. + inFlight?.cancel() val channels = Subscriptions.get().subs.value if (channels.isEmpty()) { - _ui.update { SubscriptionFeedUiState(loading = false, items = emptyList()) } + _ui.update { it.copy(loading = false, items = emptyList(), error = null) } channelCache.clear() - // Wipe disk too. vc=36 audit B1: previously the disk - // cache kept stale entries indefinitely after the user - // unsubscribed from everything. mergeFromCache eventually - // prunes them on the next merge, but they sat as orphans - // through cold starts in the meantime. viewModelScope.launch(Dispatchers.IO) { runCatching { FeedCache.get().clear() } } return } - inFlight?.cancel() _ui.update { it.copy(loading = true, error = null) } inFlight = viewModelScope.launch { try { @@ -181,10 +194,18 @@ class SubscriptionFeedViewModel : ViewModel() { } } } catch (t: Throwable) { + // Re-throw cancellation so spam-tapping Refresh (or + // toggling cache OFF→ON during a refresh) doesn't + // surface a "refresh failed: StandaloneCoroutineCancelled" + // banner above the cached items. vc=37 round-3 audit + // function-correctness HIGH-1. + if (t is CancellationException) throw t _ui.update { it.copy( loading = false, - error = t.message ?: t.javaClass.simpleName, + error = com.sulkta.straw.util.LogDump.scrubLine( + t.message ?: t.javaClass.simpleName, + ), ) } } @@ -264,8 +285,14 @@ class SubscriptionFeedViewModel : ViewModel() { * stayed visible until process death. vc=35 audit MED-C13. */ fun clearInMemoryCache() { + // Cancel any in-flight refresh — without this, fetchChannelInto + // coroutines mid-execution would re-populate the cache after + // the clear. Round-3 audit function MED-3. + inFlight?.cancel() channelCache.clear() - _ui.value = _ui.value.copy(items = emptyList(), lastFetchedAt = 0L) + // Use _ui.update for atomicity vs concurrent refresh writes + // (round-3 audit HIGH-4). + _ui.update { it.copy(items = emptyList(), lastFetchedAt = 0L) } } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt index 082d61fdb..bcef3a3a4 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchViewModel.kt @@ -180,7 +180,9 @@ class SearchViewModel : ViewModel() { // the user still has something to look at while offline. _ui.value = _ui.value.copy( loading = false, - error = t.message ?: t.javaClass.simpleName, + error = com.sulkta.straw.util.LogDump.scrubLine( + t.message ?: t.javaClass.simpleName, + ), ) } } @@ -193,11 +195,13 @@ class SearchViewModel : ViewModel() { * after each successful submit and at VM construction. */ private fun reactiveFilter(q: String): List { - val needle = q.lowercase() + // contains(ignoreCase=true) on the raw fields avoids the + // 3N+ String allocations per keystroke that `.lowercase()` + // copy-and-compare produced. Round-3 audit MED-5. return pool.asSequence() .filter { item -> - item.title.lowercase().contains(needle) - || item.uploader.lowercase().contains(needle) + item.title.contains(q, ignoreCase = true) + || item.uploader.contains(q, ignoreCase = true) } .take(60) .toList() diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/util/LogDump.kt b/strawApp/src/main/kotlin/com/sulkta/straw/util/LogDump.kt index d5279a144..af728aae2 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/util/LogDump.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/util/LogDump.kt @@ -43,12 +43,16 @@ object LogDump { runCatching { val pid = Process.myPid() val timestamp = SimpleDateFormat("yyyyMMdd-HHmmss", Locale.US).format(Date()) - val outFile = File(context.cacheDir, "straw-logs-$timestamp.txt") - val tmpFile = File(context.cacheDir, "straw-logs-$timestamp.txt.tmp") + // Write to cacheDir/logs/ — vc=37 round-3 audit CVE MED-5 + // narrowed the FileProvider scope from the whole cacheDir + // to just this subdir, so dumps must land here. + val logsDir = File(context.cacheDir, "logs").apply { mkdirs() } + val outFile = File(logsDir, "straw-logs-$timestamp.txt") + val tmpFile = File(logsDir, "straw-logs-$timestamp.txt.tmp") // Sweep old dumps before writing the new one so cacheDir // doesn't grow per export. - context.cacheDir.listFiles { _, name -> + logsDir.listFiles { _, name -> name.startsWith("straw-logs-") && (name.endsWith(".txt") || name.endsWith(".tmp")) }?.forEach { it.delete() } @@ -107,18 +111,27 @@ object LogDump { var s = line // Pre-signed googlevideo URLs: keep host visible, drop path+query. s = GOOGLEVIDEO_URL_RE.replace(s, "https://.googlevideo.com/") - // Any remaining signed-param shapes that snuck through other URLs. - // Expanded set vc=36 audit CVE MED-2: + n (JS-deobfuscated n-sig), - // lsig (link signature), ei (encrypted event-id), key, sparams. - s = SIGNED_PARAM_RE.replace(s, "$1=") + // Long, distinctive token names — match anywhere. + s = SIGNED_PARAM_LONG_RE.replace(s, "$1=") + // Short single-letter / two-letter tokens — require `[?&]` + // immediately before to avoid eating innocent counters. + s = SIGNED_PARAM_SHORT_RE.replace(s, "$1$2=") return s } private val GOOGLEVIDEO_URL_RE = Regex( """https?://[a-zA-Z0-9.-]*googlevideo\.com/\S+""", ) - private val SIGNED_PARAM_RE = Regex( - """\b(signature|sig|pot|cpn|expire|ip|mn|ms|mo|pl|n|lsig|ei|key|sparams)=([^&\s"']+)""", + // Long tokens are unique enough to match anywhere. Short tokens + // (n, mn, ms, mo, pl, ip, ei) require `[?&]` immediately before + // so we don't redact innocuous `n=42` counters from other libs. + // vc=37 round-3 audit CVE-4. + private val SIGNED_PARAM_LONG_RE = Regex( + """\b(signature|sparams|lsig|cpn|expire|pot|sig|key)=([^&\s"']+)""", + RegexOption.IGNORE_CASE, + ) + private val SIGNED_PARAM_SHORT_RE = Regex( + """([?&])(n|mn|ms|mo|pl|ip|ei)=([^&\s"']+)""", RegexOption.IGNORE_CASE, ) } diff --git a/strawApp/src/main/res/xml/file_paths.xml b/strawApp/src/main/res/xml/file_paths.xml index 2cd9f5c6f..57446c2ce 100644 --- a/strawApp/src/main/res/xml/file_paths.xml +++ b/strawApp/src/main/res/xml/file_paths.xml @@ -1,8 +1,11 @@ - - + + + with ALLOWED_YT_HOSTS in util/YtUrl.kt (canonical home as + of vc=42 — was previously inlined in StrawActivity.kt + under YT_HOSTS; drift was caught in the vc=34 function + audit, music.youtube.com etc. were accepted by code but + never offered by the launcher disambig). --> From 5d9cf3e370d4723a8e68364f1ff5f3c852de7d51 Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 16:33:50 -0700 Subject: [PATCH 33/72] vc=44: fix back-from-fullscreen showing thumbnail placeholder MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Reported: press fullscreen → press system back → VideoDetail re-renders as a "freshly loaded page" — thumbnail with Play button overlay visible, audio continuing from the persistent MediaController. Root cause: `var inlinePlaying by remember(streamUrl) { mutableStateOf(false) }` at VideoDetailScreen.kt:125 keys on streamUrl, so popping back from Player remounts the composable with a fresh false. The thumbnail placeholder Box renders instead of InlinePlayer; audio keeps going on the shared controller because nothing was stopped. Fix: default inlinePlaying to true when the shared controller is already playing this exact stream — almost always the back-from- fullscreen case. Fresh navigation to a video that isn't currently playing still gets the thumbnail+Play placeholder as before. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 ++-- .../sulkta/straw/feature/detail/VideoDetailScreen.kt | 12 +++++++++++- 2 files changed, 13 insertions(+), 3 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 033ec3f95..839b5c708 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 43 -const val STRAW_VERSION_NAME = "0.1.0-BC" +const val STRAW_VERSION_CODE = 44 +const val STRAW_VERSION_NAME = "0.1.0-BD" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index d28b26527..ea3800279 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -122,7 +122,17 @@ fun VideoDetailScreen( var showDownloadDialog by remember { mutableStateOf(false) } var showSaveToPlaylistDialog by remember { mutableStateOf(false) } // Inline-play state resets when navigating to a different video. - var inlinePlaying by remember(streamUrl) { mutableStateOf(false) } + // BUT: if the shared MediaController is already playing this exact + // stream — most commonly because the user popped back from + // fullscreen Player — default to true so the inline surface picks + // up the running playback instead of dropping back to the + // thumbnail+Play placeholder. Without this, system back from + // fullscreen looked like "the video went to background" — audio + // continued via the persistent controller but the video page + // re-rendered as a freshly-loaded detail. + var inlinePlaying by remember(streamUrl) { + mutableStateOf(NowPlaying.current.value?.streamUrl == streamUrl) + } LaunchedEffect(streamUrl) { vm.load(streamUrl) } // The Background button (and the fullscreen audio-only toggle) From c515fabf71473c24f1e5c0444c15328dc9a2c0bd Mon Sep 17 00:00:00 2001 From: Kayos Date: Mon, 25 May 2026 22:11:12 -0700 Subject: [PATCH 34/72] vc=45: tappable channel name in search + channel row on VideoDetail MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Search results: - Uploader name split onto its own line at bodyMedium (was bodySmall). - Clickable when uploaderUrl present — taps land on the channel page. - Tinted primary when clickable, neutral when not. - Views/duration moved to a separate line so they don't fight the larger uploader tap target. VideoDetail: - New channel row below the title: avatar (40dp circle, clickable), name (titleSmall semibold, clickable), subscriber count, Subscribe/Subscribed button on the right. - Avatar + subscriber count pulled from the same strawcore.channelInfo call that already runs for moreFromChannel — no extra round-trip. - Opportunistically pushes a fresh avatar back to SubscriptionsStore on resolution so the subs feed picks it up too (mirrors the existing backfill in SubscriptionFeedViewModel.fetchChannelInto). --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- .../kotlin/com/sulkta/straw/StrawActivity.kt | 1 + .../straw/feature/detail/VideoDetailScreen.kt | 74 ++++++++++++++++--- .../feature/detail/VideoDetailViewModel.kt | 69 ++++++++++++----- .../straw/feature/search/SearchScreen.kt | 57 ++++++++++---- 5 files changed, 160 insertions(+), 45 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 839b5c708..07476195c 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 44 -const val STRAW_VERSION_NAME = "0.1.0-BD" +const val STRAW_VERSION_CODE = 45 +const val STRAW_VERSION_NAME = "0.1.0-BE" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt index 9bcb0664e..7d5f00e18 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawActivity.kt @@ -166,6 +166,7 @@ class StrawActivity : ComponentActivity() { is Screen.Settings -> SettingsScreen() is Screen.Search -> SearchScreen( onOpenVideo = { url, title -> nav.push(Screen.VideoDetail(url, title)) }, + onOpenChannel = { url, name -> nav.push(Screen.Channel(url, name)) }, ) is Screen.VideoDetail -> VideoDetailScreen( streamUrl = s.streamUrl, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index ea3800279..b2209bcc0 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -100,6 +100,8 @@ import com.sulkta.straw.feature.player.NowPlaying import com.sulkta.straw.feature.player.setPlayingFrom import com.sulkta.straw.feature.search.StreamItem import com.sulkta.straw.util.LogDump +import com.sulkta.straw.data.ChannelRef +import com.sulkta.straw.data.Subscriptions import com.sulkta.straw.util.formatCount import com.sulkta.straw.util.formatViews import com.sulkta.straw.util.stripHtml @@ -296,17 +298,69 @@ fun VideoDetailScreen( style = MaterialTheme.typography.titleLarge, fontWeight = FontWeight.SemiBold, ) - Spacer(modifier = Modifier.height(4.dp)) + Spacer(modifier = Modifier.height(8.dp)) val uploaderUrl = d.uploaderUrl - Text( - text = d.uploader, - style = MaterialTheme.typography.bodyMedium, - color = if (uploaderUrl != null) MaterialTheme.colorScheme.primary - else MaterialTheme.colorScheme.onSurfaceVariant, - modifier = if (uploaderUrl != null) Modifier.clickable { - onOpenChannel(uploaderUrl, d.uploader) - } else Modifier, - ) + // Channel row: avatar + name (larger, clickable when we + // have a uploaderUrl) + Subscribe / Subscribed toggle. + // Matches the YouTube/NewPipe layout below the title. + val subs by Subscriptions.get().subs.collectAsStateWithLifecycle() + val isSubscribed = uploaderUrl != null && subs.any { it.url == uploaderUrl } + Row( + verticalAlignment = Alignment.CenterVertically, + modifier = Modifier.fillMaxWidth(), + ) { + if (!d.uploaderAvatar.isNullOrBlank()) { + AsyncImage( + model = d.uploaderAvatar, + contentDescription = null, + modifier = Modifier + .size(40.dp) + .clip(CircleShape) + .then( + if (uploaderUrl != null) + Modifier.clickable { onOpenChannel(uploaderUrl, d.uploader) } + else Modifier + ), + ) + Spacer(modifier = Modifier.width(10.dp)) + } + Column(modifier = Modifier.weight(1f)) { + Text( + text = d.uploader, + style = MaterialTheme.typography.titleSmall, + fontWeight = FontWeight.SemiBold, + color = if (uploaderUrl != null) MaterialTheme.colorScheme.primary + else MaterialTheme.colorScheme.onSurface, + modifier = if (uploaderUrl != null) Modifier + .clickable { onOpenChannel(uploaderUrl, d.uploader) } + .padding(vertical = 4.dp) + else Modifier.padding(vertical = 4.dp), + ) + if (d.uploaderSubscriberCount > 0) { + Text( + text = "${formatCount(d.uploaderSubscriberCount)} subscribers", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } + if (uploaderUrl != null) { + val onSubClick = { + Subscriptions.get().toggle( + ChannelRef( + url = uploaderUrl, + name = d.uploader, + avatar = d.uploaderAvatar, + ), + ) + } + if (isSubscribed) { + OutlinedButton(onClick = onSubClick) { Text("Subscribed") } + } else { + Button(onClick = onSubClick) { Text("Subscribe") } + } + } + } Spacer(modifier = Modifier.height(12.dp)) Row( diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt index 33b81c305..7c11976f9 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt @@ -41,6 +41,15 @@ data class VideoDetail( val title: String, val uploader: String, val uploaderUrl: String?, + /** + * Uploader's channel avatar (square-ish thumbnail). Populated + * from the same strawcore.channelInfo call that fills + * `moreFromChannel`; null until that call resolves, or when the + * uploaderUrl is missing / fails the allowlist. Renders as a + * small circle next to the channel name on VideoDetail. + */ + val uploaderAvatar: String? = null, + val uploaderSubscriberCount: Long = -1, val viewCount: Long, val description: String, val thumbnail: String?, @@ -180,26 +189,48 @@ class VideoDetailViewModel : ViewModel() { // extractor would otherwise trigger an arbitrary-host // network call. Round-4 audit HIGH-4. val uploaderUrl = info.uploaderUrl - val moreFromChannel: List = - if (uploaderUrl.isNullOrBlank() || !isAllowedYtUrl(uploaderUrl)) emptyList() - else runCatchingCancellable { + data class ChannelExtras( + val avatar: String?, + val subscriberCount: Long, + val videos: List, + ) + val channelExtras: ChannelExtras = + if (uploaderUrl.isNullOrBlank() || !isAllowedYtUrl(uploaderUrl)) { + ChannelExtras(null, -1, emptyList()) + } else runCatchingCancellable { val ch = uniffi.strawcore.channelInfo(uploaderUrl) - ch.videos - .filter { it.url != streamUrl } - .take(20) - .map { v -> - StreamItem( - url = v.url, - title = v.title.ifBlank { "(no title)" }, - uploader = v.uploader.ifBlank { uploader }, - uploaderUrl = v.uploaderUrl ?: uploaderUrl, - thumbnail = v.thumbnail, - durationSeconds = v.durationSeconds, - viewCount = v.viewCount, - uploadDateRelative = v.uploadDateRelative, - ) + // Opportunistic avatar refresh: if the user is + // subscribed and our stored avatar is stale or + // missing, push the fresh one back to the store + // so the subs feed picks it up too. + val fresh = ch.avatar + if (!fresh.isNullOrBlank()) { + runCatchingCancellable { + com.sulkta.straw.data.Subscriptions + .get().updateAvatar(uploaderUrl, fresh) } - }.getOrDefault(emptyList()) + } + ChannelExtras( + avatar = fresh, + subscriberCount = ch.subscriberCount, + videos = ch.videos + .filter { it.url != streamUrl } + .take(20) + .map { v -> + StreamItem( + url = v.url, + title = v.title.ifBlank { "(no title)" }, + uploader = v.uploader.ifBlank { uploader }, + uploaderUrl = v.uploaderUrl ?: uploaderUrl, + thumbnail = v.thumbnail, + durationSeconds = v.durationSeconds, + viewCount = v.viewCount, + uploadDateRelative = v.uploadDateRelative, + ) + }, + ) + }.getOrDefault(ChannelExtras(null, -1, emptyList())) + val moreFromChannel = channelExtras.videos val resolved = resolvePlayback(info, segments) @@ -217,6 +248,8 @@ class VideoDetailViewModel : ViewModel() { title = title, uploader = uploader, uploaderUrl = info.uploaderUrl, + uploaderAvatar = channelExtras.avatar, + uploaderSubscriberCount = channelExtras.subscriberCount, viewCount = info.viewCount, description = info.description, thumbnail = thumb, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt index c0c7a3434..3a8b94ea2 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt @@ -50,6 +50,7 @@ import com.sulkta.straw.util.formatViews @Composable fun SearchScreen( onOpenVideo: (url: String, title: String) -> Unit, + onOpenChannel: (url: String, name: String) -> Unit, vm: SearchViewModel = viewModel(), ) { val state by vm.ui.collectAsStateWithLifecycle() @@ -149,7 +150,11 @@ fun SearchScreen( } LazyColumn(modifier = Modifier.fillMaxSize()) { items(state.results) { item -> - ResultRow(item = item) { onOpenVideo(item.url, item.title) } + ResultRow( + item = item, + onClick = { onOpenVideo(item.url, item.title) }, + onChannelClick = { url -> onOpenChannel(url, item.uploader) }, + ) HorizontalDivider() } } @@ -159,7 +164,11 @@ fun SearchScreen( } @Composable -private fun ResultRow(item: StreamItem, onClick: () -> Unit) { +private fun ResultRow( + item: StreamItem, + onClick: () -> Unit, + onChannelClick: (url: String) -> Unit, +) { Row( modifier = Modifier .fillMaxWidth() @@ -185,23 +194,41 @@ private fun ResultRow(item: StreamItem, onClick: () -> Unit) { overflow = TextOverflow.Ellipsis, ) Spacer(modifier = Modifier.height(4.dp)) + // Uploader on its own line — larger + tinted + clickable + // when we have a uploaderUrl to route to. Tapping the + // name jumps to the Channel screen; tapping anywhere else + // on the row still opens the video. Child clickable + // consumes the press before the row's clickable hears it. + val uploaderUrl = item.uploaderUrl Text( - text = buildString { - append(item.uploader) - if (item.viewCount > 0) { - append(" · ") - append(formatViews(item.viewCount)) - } - if (item.durationSeconds > 0) { - append(" · ") - append(formatDuration(item.durationSeconds)) - } - }, - style = MaterialTheme.typography.bodySmall, - color = MaterialTheme.colorScheme.onSurfaceVariant, + text = item.uploader, + style = MaterialTheme.typography.bodyMedium, + color = if (!uploaderUrl.isNullOrBlank()) + MaterialTheme.colorScheme.primary + else + MaterialTheme.colorScheme.onSurfaceVariant, maxLines = 1, overflow = TextOverflow.Ellipsis, + modifier = if (!uploaderUrl.isNullOrBlank()) + Modifier + .clickable { onChannelClick(uploaderUrl) } + .padding(vertical = 4.dp) + else + Modifier.padding(vertical = 4.dp), ) + if (item.viewCount > 0 || item.durationSeconds > 0) { + Text( + text = buildString { + if (item.viewCount > 0) append(formatViews(item.viewCount)) + if (item.viewCount > 0 && item.durationSeconds > 0) append(" · ") + if (item.durationSeconds > 0) append(formatDuration(item.durationSeconds)) + }, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + } } } } From c3583457fb85934dedfe071af1d956b73f9c7925 Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 04:28:14 -0700 Subject: [PATCH 35/72] =?UTF-8?q?vc=3D46:=20long-press=20video=20actions?= =?UTF-8?q?=20=E2=80=94=20save=20to=20playlist=20+=20share?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Build offline playlists from any list, not just one-at-a-time from VideoDetail. * Long-press any video row → ModalBottomSheet with title/uploader header + actions: Save to playlist, Share. * Save reuses the existing playlist dialog (extracted out of VideoDetailScreen into feature/playlist/VideoActions.kt and promoted to public). * Share fires a system ACTION_SEND with the YT URL. * Wired across all 5 video-row sites: Search results, Subs feed, History, Channel videos, Related/More-from-channel on VideoDetail. Deferred to next ship: * "Play next" / "Add to queue" — needs Media3 queue substrate + per-item streamInfo resolution path. Separate ticket; non-blocking for the offline-playlist build flow Cobb asked for tonight. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- .../main/kotlin/com/sulkta/straw/StrawHome.kt | 56 +++- .../straw/feature/channel/ChannelScreen.kt | 33 ++- .../straw/feature/detail/VideoDetailScreen.kt | 125 +++------ .../straw/feature/playlist/VideoActions.kt | 256 ++++++++++++++++++ .../straw/feature/search/SearchScreen.kt | 22 +- 6 files changed, 396 insertions(+), 100 deletions(-) create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/feature/playlist/VideoActions.kt diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 07476195c..cd111e2a1 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 45 -const val STRAW_VERSION_NAME = "0.1.0-BE" +const val STRAW_VERSION_CODE = 46 +const val STRAW_VERSION_NAME = "0.1.0-BF" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt index 2461a8182..2170bb823 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt @@ -8,8 +8,10 @@ package com.sulkta.straw +import androidx.compose.foundation.ExperimentalFoundationApi import androidx.compose.foundation.background import androidx.compose.foundation.clickable +import androidx.compose.foundation.combinedClickable import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Column @@ -78,6 +80,8 @@ import com.sulkta.straw.data.History import com.sulkta.straw.data.Subscriptions import com.sulkta.straw.data.WatchHistoryItem import com.sulkta.straw.feature.feed.SubscriptionFeedViewModel +import com.sulkta.straw.feature.playlist.VideoActionTarget +import com.sulkta.straw.feature.playlist.VideoActionsSheet import com.sulkta.straw.feature.search.StreamItem import com.sulkta.straw.OverlayDimColor import com.sulkta.straw.util.formatDuration @@ -234,6 +238,10 @@ fun StrawHome( @Composable private fun HistoryPane(onOpenVideo: (url: String, title: String) -> Unit) { val watches by History.get().watches.collectAsState() + var actionTarget by remember { mutableStateOf(null) } + actionTarget?.let { t -> + VideoActionsSheet(target = t, onDismiss = { actionTarget = null }) + } Column { Text( @@ -252,7 +260,18 @@ private fun HistoryPane(onOpenVideo: (url: String, title: String) -> Unit) { } else { LazyColumn { items(watches) { w -> - RecentRow(w) { onOpenVideo(w.url, w.title) } + RecentRow( + item = w, + onClick = { onOpenVideo(w.url, w.title) }, + onLongClick = { + actionTarget = VideoActionTarget( + streamUrl = w.url, + title = w.title, + uploader = w.uploader, + thumbnail = w.thumbnail, + ) + }, + ) HorizontalDivider() } } @@ -269,6 +288,10 @@ private fun SubsPane( val subs by Subscriptions.get().subs.collectAsState() val feed by feedVm.ui.collectAsState() val watches by History.get().watches.collectAsState() + var actionTarget by remember { mutableStateOf(null) } + actionTarget?.let { t -> + VideoActionsSheet(target = t, onDismiss = { actionTarget = null }) + } LaunchedEffect(subs) { feedVm.refreshIfStale() } // Filter + pagination state. hideWatched is sticky for the session @@ -415,7 +438,18 @@ private fun SubsPane( } LazyColumn(state = listState) { items(displayed) { item -> - FeedRow(item) { onOpenVideo(item.url, item.title) } + FeedRow( + item = item, + onClick = { onOpenVideo(item.url, item.title) }, + onLongClick = { + actionTarget = VideoActionTarget( + streamUrl = item.url, + title = item.title, + uploader = item.uploader, + thumbnail = item.thumbnail, + ) + }, + ) HorizontalDivider() } if (hasMore) { @@ -456,12 +490,17 @@ private val VIDEO_ID_RE = Regex("(?:v=|/)([A-Za-z0-9_-]{11})(?:[?&#].*)?$") private fun extractVideoId(url: String): String = VIDEO_ID_RE.find(url)?.groupValues?.getOrNull(1).orEmpty() +@OptIn(ExperimentalFoundationApi::class) @Composable -private fun FeedRow(item: StreamItem, onClick: () -> Unit) { +private fun FeedRow( + item: StreamItem, + onClick: () -> Unit, + onLongClick: () -> Unit, +) { Row( modifier = Modifier .fillMaxWidth() - .clickable(onClick = onClick) + .combinedClickable(onClick = onClick, onLongClick = onLongClick) .padding(vertical = 8.dp), verticalAlignment = Alignment.Top, ) { @@ -586,12 +625,17 @@ private fun SubChip( } } +@OptIn(ExperimentalFoundationApi::class) @Composable -private fun RecentRow(item: WatchHistoryItem, onClick: () -> Unit) { +private fun RecentRow( + item: WatchHistoryItem, + onClick: () -> Unit, + onLongClick: () -> Unit, +) { Row( modifier = Modifier .fillMaxWidth() - .clickable(onClick = onClick) + .combinedClickable(onClick = onClick, onLongClick = onLongClick) .padding(vertical = 8.dp), verticalAlignment = Alignment.CenterVertically, ) { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt index 9d3e57143..54e41dd0f 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt @@ -5,7 +5,9 @@ package com.sulkta.straw.feature.channel +import androidx.compose.foundation.ExperimentalFoundationApi import androidx.compose.foundation.clickable +import androidx.compose.foundation.combinedClickable import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Column @@ -41,11 +43,16 @@ import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.text.style.TextOverflow import androidx.compose.ui.unit.dp import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.lifecycle.viewmodel.compose.viewModel import coil3.compose.AsyncImage import com.sulkta.straw.data.ChannelRef import com.sulkta.straw.data.Subscriptions +import com.sulkta.straw.feature.playlist.VideoActionTarget +import com.sulkta.straw.feature.playlist.VideoActionsSheet import com.sulkta.straw.feature.search.StreamItem import com.sulkta.straw.util.formatCount import com.sulkta.straw.util.formatDuration @@ -61,6 +68,10 @@ fun ChannelScreen( LaunchedEffect(channelUrl) { vm.load(channelUrl) } val subs by Subscriptions.get().subs.collectAsState() val subscribed = subs.any { it.url == channelUrl } + var actionTarget by remember { mutableStateOf(null) } + actionTarget?.let { t -> + VideoActionsSheet(target = t, onDismiss = { actionTarget = null }) + } when { state.loading -> Box( @@ -130,19 +141,35 @@ fun ChannelScreen( HorizontalDivider() } items(state.videos) { item -> - ChannelVideoRow(item) { onOpenVideo(item.url, item.title) } + ChannelVideoRow( + item = item, + onClick = { onOpenVideo(item.url, item.title) }, + onLongClick = { + actionTarget = VideoActionTarget( + streamUrl = item.url, + title = item.title, + uploader = item.uploader, + thumbnail = item.thumbnail, + ) + }, + ) HorizontalDivider() } } } } +@OptIn(ExperimentalFoundationApi::class) @Composable -private fun ChannelVideoRow(item: StreamItem, onClick: () -> Unit) { +private fun ChannelVideoRow( + item: StreamItem, + onClick: () -> Unit, + onLongClick: () -> Unit, +) { Row( modifier = Modifier .fillMaxWidth() - .clickable(onClick = onClick) + .combinedClickable(onClick = onClick, onLongClick = onLongClick) .padding(horizontal = 16.dp, vertical = 10.dp), verticalAlignment = Alignment.Top, ) { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index b2209bcc0..8cb277a6c 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -17,8 +17,10 @@ import androidx.compose.animation.core.FastOutLinearInEasing import androidx.compose.animation.core.Spring import androidx.compose.animation.core.spring import androidx.compose.animation.core.tween +import androidx.compose.foundation.ExperimentalFoundationApi import androidx.compose.foundation.background import androidx.compose.foundation.clickable +import androidx.compose.foundation.combinedClickable import androidx.compose.foundation.gestures.Orientation import androidx.compose.foundation.gestures.draggable import androidx.compose.foundation.gestures.rememberDraggableState @@ -92,7 +94,7 @@ import coil3.compose.AsyncImage import com.sulkta.straw.OverlayChromeColor import com.sulkta.straw.OverlayDimColor import com.sulkta.straw.data.PlaylistItem -import com.sulkta.straw.data.Playlists +import com.sulkta.straw.feature.playlist.SaveToPlaylistDialog import com.sulkta.straw.feature.download.DownloadKind import com.sulkta.straw.feature.download.Downloader import com.sulkta.straw.feature.player.LocalStrawController @@ -123,6 +125,13 @@ fun VideoDetailScreen( val activity = context as? Activity var showDownloadDialog by remember { mutableStateOf(false) } var showSaveToPlaylistDialog by remember { mutableStateOf(false) } + var actionTarget by remember { mutableStateOf(null) } + actionTarget?.let { t -> + com.sulkta.straw.feature.playlist.VideoActionsSheet( + target = t, + onDismiss = { actionTarget = null }, + ) + } // Inline-play state resets when navigating to a different video. // BUT: if the shared MediaController is already playing this exact // stream — most commonly because the user popped back from @@ -536,7 +545,18 @@ fun VideoDetailScreen( ) Spacer(modifier = Modifier.height(8.dp)) d.related.take(20).forEach { rel -> - RelatedRow(rel) { onOpenVideo(rel.url, rel.title) } + RelatedRow( + item = rel, + onClick = { onOpenVideo(rel.url, rel.title) }, + onLongClick = { + actionTarget = com.sulkta.straw.feature.playlist.VideoActionTarget( + streamUrl = rel.url, + title = rel.title, + uploader = rel.uploader, + thumbnail = rel.thumbnail, + ) + }, + ) HorizontalDivider() } } @@ -551,7 +571,18 @@ fun VideoDetailScreen( ) Spacer(modifier = Modifier.height(8.dp)) d.moreFromChannel.take(20).forEach { item -> - RelatedRow(item) { onOpenVideo(item.url, item.title) } + RelatedRow( + item = item, + onClick = { onOpenVideo(item.url, item.title) }, + onLongClick = { + actionTarget = com.sulkta.straw.feature.playlist.VideoActionTarget( + streamUrl = item.url, + title = item.title, + uploader = item.uploader, + thumbnail = item.thumbnail, + ) + }, + ) HorizontalDivider() } } @@ -629,15 +660,17 @@ fun VideoDetailScreen( } } +@OptIn(ExperimentalFoundationApi::class) @Composable private fun RelatedRow( item: StreamItem, onClick: () -> Unit, + onLongClick: () -> Unit, ) { Row( modifier = Modifier .fillMaxWidth() - .clickable(onClick = onClick) + .combinedClickable(onClick = onClick, onLongClick = onLongClick) .padding(vertical = 8.dp), verticalAlignment = Alignment.Top, ) { @@ -676,90 +709,6 @@ private fun RelatedRow( } } -@Composable -private fun SaveToPlaylistDialog( - item: PlaylistItem, - onDismiss: () -> Unit, -) { - val context = LocalContext.current - val store = Playlists.get() - val playlists by store.playlists.collectAsState() - var creatingNew by remember { mutableStateOf(false) } - var newName by remember { mutableStateOf("") } - - AlertDialog( - onDismissRequest = onDismiss, - title = { Text("Save to playlist") }, - text = { - Column { - if (playlists.isEmpty() && !creatingNew) { - Text( - "No playlists yet. Create one to save this video.", - style = MaterialTheme.typography.bodySmall, - color = MaterialTheme.colorScheme.onSurfaceVariant, - ) - Spacer(modifier = Modifier.height(8.dp)) - } - playlists.forEach { pl -> - val already = pl.items.any { it.streamUrl == item.streamUrl } - Row( - modifier = Modifier - .fillMaxWidth() - .clickable(enabled = !already) { - store.addItem(pl.id, item) - Toast.makeText(context, "saved to ${pl.name}", Toast.LENGTH_SHORT).show() - onDismiss() - } - .padding(vertical = 12.dp), - verticalAlignment = Alignment.CenterVertically, - ) { - Text(if (already) "✓" else "○", modifier = Modifier.width(28.dp)) - Column(modifier = Modifier.weight(1f)) { - Text(pl.name, style = MaterialTheme.typography.bodyLarge) - Text( - "${pl.items.size} video${if (pl.items.size == 1) "" else "s"}", - style = MaterialTheme.typography.bodySmall, - color = MaterialTheme.colorScheme.onSurfaceVariant, - ) - } - } - HorizontalDivider() - } - if (creatingNew) { - Spacer(modifier = Modifier.height(8.dp)) - OutlinedTextField( - value = newName, - onValueChange = { newName = it }, - label = { Text("New playlist name") }, - modifier = Modifier.fillMaxWidth(), - singleLine = true, - ) - Spacer(modifier = Modifier.height(8.dp)) - Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) { - Button(onClick = { - val pl = store.create(newName) - store.addItem(pl.id, item) - Toast.makeText(context, "created ${pl.name} + saved", Toast.LENGTH_SHORT).show() - onDismiss() - }) { Text("Create + save") } - OutlinedButton(onClick = { creatingNew = false; newName = "" }) { - Text("Cancel") - } - } - } else { - Spacer(modifier = Modifier.height(12.dp)) - OutlinedButton(onClick = { creatingNew = true }) { - Text("+ New playlist") - } - } - } - }, - confirmButton = { - TextButton(onClick = onDismiss) { Text("Close") } - }, - ) -} - /** * Inline player surface inside VideoDetail's 16:9 thumbnail box. Renders * a PlayerView bound to the shared LocalStrawController — the same diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/playlist/VideoActions.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/playlist/VideoActions.kt new file mode 100644 index 000000000..e57433666 --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/playlist/VideoActions.kt @@ -0,0 +1,256 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Shared long-press actions surface for video rows. The menu shows + * "Save to playlist" + "Share" (and Add-to-Queue later when the queue + * substrate lands). Every video row in the app — Search results, + * Subs feed, Channel videos, History, Related — calls + * `showVideoActions(...)` from a `combinedClickable.onLongClick`. + * + * Pure-Compose surface — no ViewModel needed; PlaylistsStore is a + * process-wide singleton and the share Intent is a fire-and-forget + * Android system action. + */ + +package com.sulkta.straw.feature.playlist + +import android.content.Intent +import android.widget.Toast +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.width +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.PlaylistAdd +import androidx.compose.material.icons.filled.Share +import androidx.compose.material3.AlertDialog +import androidx.compose.material3.Button +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.HorizontalDivider +import androidx.compose.material3.Icon +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.ModalBottomSheet +import androidx.compose.material3.OutlinedButton +import androidx.compose.material3.OutlinedTextField +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.material3.rememberModalBottomSheetState +import androidx.compose.runtime.Composable +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.unit.dp +import com.sulkta.straw.data.PlaylistItem +import com.sulkta.straw.data.Playlists + +/** + * Minimal video descriptor for the actions sheet. Avoids dragging + * the full search.StreamItem (which has extractor fields the + * actions don't need) so the same surface can be invoked from + * history rows where we only have a WatchHistoryItem. + */ +data class VideoActionTarget( + val streamUrl: String, + val title: String, + val uploader: String, + val thumbnail: String?, +) + +@OptIn(ExperimentalMaterial3Api::class) +@Composable +fun VideoActionsSheet( + target: VideoActionTarget, + onDismiss: () -> Unit, +) { + val context = LocalContext.current + val sheetState = rememberModalBottomSheetState() + var showSaveDialog by remember { mutableStateOf(false) } + + if (showSaveDialog) { + SaveToPlaylistDialog( + item = PlaylistItem( + streamUrl = target.streamUrl, + title = target.title, + thumbnail = target.thumbnail, + uploader = target.uploader, + ), + onDismiss = { + showSaveDialog = false + onDismiss() + }, + ) + return + } + + ModalBottomSheet( + onDismissRequest = onDismiss, + sheetState = sheetState, + ) { + Column(modifier = Modifier.fillMaxWidth().padding(bottom = 16.dp)) { + // Title row — truncated to one line, gives context for the + // actions below. + Text( + text = target.title, + style = MaterialTheme.typography.titleSmall, + maxLines = 2, + modifier = Modifier.padding(horizontal = 20.dp, vertical = 8.dp), + ) + if (target.uploader.isNotBlank()) { + Text( + text = target.uploader, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + modifier = Modifier.padding(horizontal = 20.dp, vertical = 0.dp), + ) + } + Spacer(modifier = Modifier.height(8.dp)) + HorizontalDivider() + ActionRow( + icon = Icons.Filled.PlaylistAdd, + label = "Save to playlist", + onClick = { showSaveDialog = true }, + ) + ActionRow( + icon = Icons.Filled.Share, + label = "Share", + onClick = { + val send = Intent(Intent.ACTION_SEND).apply { + type = "text/plain" + putExtra(Intent.EXTRA_TEXT, target.streamUrl) + putExtra(Intent.EXTRA_SUBJECT, target.title) + } + context.startActivity( + Intent.createChooser(send, "Share video").addFlags( + Intent.FLAG_ACTIVITY_NEW_TASK, + ), + ) + onDismiss() + }, + ) + } + } +} + +@Composable +private fun ActionRow( + icon: androidx.compose.ui.graphics.vector.ImageVector, + label: String, + onClick: () -> Unit, +) { + Row( + modifier = Modifier + .fillMaxWidth() + .clickable(onClick = onClick) + .padding(horizontal = 20.dp, vertical = 14.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Icon( + imageVector = icon, + contentDescription = null, + tint = MaterialTheme.colorScheme.onSurface, + ) + Spacer(modifier = Modifier.width(16.dp)) + Text(text = label, style = MaterialTheme.typography.bodyLarge) + } +} + +/** + * Shared "Save to playlist" dialog — was previously inline in + * VideoDetailScreen; promoted to its own file so the long-press + * menu on any row can reuse it. + */ +@Composable +fun SaveToPlaylistDialog( + item: PlaylistItem, + onDismiss: () -> Unit, +) { + val context = LocalContext.current + val store = Playlists.get() + val playlists by store.playlists.collectAsState() + var creatingNew by remember { mutableStateOf(false) } + var newName by remember { mutableStateOf("") } + + AlertDialog( + onDismissRequest = onDismiss, + title = { Text("Save to playlist") }, + text = { + Column { + if (playlists.isEmpty() && !creatingNew) { + Text( + "No playlists yet. Create one to save this video.", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + Spacer(modifier = Modifier.height(8.dp)) + } + playlists.forEach { pl -> + val already = pl.items.any { it.streamUrl == item.streamUrl } + Row( + modifier = Modifier + .fillMaxWidth() + .clickable(enabled = !already) { + store.addItem(pl.id, item) + Toast.makeText(context, "saved to ${pl.name}", Toast.LENGTH_SHORT).show() + onDismiss() + } + .padding(vertical = 12.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Text(if (already) "✓" else "○", modifier = Modifier.width(28.dp)) + Column(modifier = Modifier.weight(1f)) { + Text(pl.name, style = MaterialTheme.typography.bodyLarge) + Text( + "${pl.items.size} video${if (pl.items.size == 1) "" else "s"}", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } + HorizontalDivider() + } + if (creatingNew) { + Spacer(modifier = Modifier.height(8.dp)) + OutlinedTextField( + value = newName, + onValueChange = { newName = it }, + label = { Text("New playlist name") }, + modifier = Modifier.fillMaxWidth(), + singleLine = true, + ) + Spacer(modifier = Modifier.height(8.dp)) + Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) { + Button(onClick = { + val pl = store.create(newName) + store.addItem(pl.id, item) + Toast.makeText(context, "created ${pl.name} + saved", Toast.LENGTH_SHORT).show() + onDismiss() + }) { Text("Create + save") } + OutlinedButton(onClick = { creatingNew = false; newName = "" }) { + Text("Cancel") + } + } + } else { + Spacer(modifier = Modifier.height(12.dp)) + OutlinedButton(onClick = { creatingNew = true }) { + Text("+ New playlist") + } + } + } + }, + confirmButton = { + TextButton(onClick = onDismiss) { Text("Close") } + }, + ) +} + diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt index 3a8b94ea2..3c9336fdd 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt @@ -5,7 +5,9 @@ package com.sulkta.straw.feature.search +import androidx.compose.foundation.ExperimentalFoundationApi import androidx.compose.foundation.clickable +import androidx.compose.foundation.combinedClickable import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Column @@ -44,6 +46,10 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.lifecycle.viewmodel.compose.viewModel import coil3.compose.AsyncImage import com.sulkta.straw.data.History +import com.sulkta.straw.feature.playlist.VideoActionTarget +import com.sulkta.straw.feature.playlist.VideoActionsSheet +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue import com.sulkta.straw.util.formatDuration import com.sulkta.straw.util.formatViews @@ -55,6 +61,10 @@ fun SearchScreen( ) { val state by vm.ui.collectAsStateWithLifecycle() val recentSearches by History.get().searches.collectAsState() + var actionTarget by remember { mutableStateOf(null) } + actionTarget?.let { target -> + VideoActionsSheet(target = target, onDismiss = { actionTarget = null }) + } Column(modifier = Modifier.fillMaxSize().statusBarsPadding().padding(16.dp)) { OutlinedTextField( @@ -153,6 +163,14 @@ fun SearchScreen( ResultRow( item = item, onClick = { onOpenVideo(item.url, item.title) }, + onLongClick = { + actionTarget = VideoActionTarget( + streamUrl = item.url, + title = item.title, + uploader = item.uploader, + thumbnail = item.thumbnail, + ) + }, onChannelClick = { url -> onOpenChannel(url, item.uploader) }, ) HorizontalDivider() @@ -163,16 +181,18 @@ fun SearchScreen( } } +@OptIn(ExperimentalFoundationApi::class) @Composable private fun ResultRow( item: StreamItem, onClick: () -> Unit, + onLongClick: () -> Unit, onChannelClick: (url: String) -> Unit, ) { Row( modifier = Modifier .fillMaxWidth() - .clickable(onClick = onClick) + .combinedClickable(onClick = onClick, onLongClick = onLongClick) .padding(vertical = 10.dp), verticalAlignment = Alignment.Top, ) { From 406fd8924a247f4715739ca9031f9ec59223bd8d Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 04:33:16 -0700 Subject: [PATCH 36/72] fixup vc=46: missing remember/getValue imports in SearchScreen --- .../main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt | 2 ++ 1 file changed, 2 insertions(+) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt index 3c9336fdd..9dfed4063 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt @@ -48,7 +48,9 @@ import coil3.compose.AsyncImage import com.sulkta.straw.data.History import com.sulkta.straw.feature.playlist.VideoActionTarget import com.sulkta.straw.feature.playlist.VideoActionsSheet +import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember import androidx.compose.runtime.setValue import com.sulkta.straw.util.formatDuration import com.sulkta.straw.util.formatViews From 02381edf0394f343212f645723892e9b8e146bac Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 05:39:19 -0700 Subject: [PATCH 37/72] =?UTF-8?q?vc=3D47:=20queue=20=E2=80=94=20Play=20nex?= =?UTF-8?q?t=20+=20Add=20to=20queue=20from=20long-press=20menu?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Now you can line up videos. Long-press → "Play next" inserts right after the current playing item; "Add to queue" appends to the back. Media3 auto-advances through the queue when each item ends. Implementation: * feature/player/Queue.kt — process-wide MutableStateFlow> that mirrors the controller's MediaItem list 1:1 by index. Append, insertAt, setAll mutators match how the controller's media items get mutated. * StrawMediaController.enqueueNext / enqueueLast — build the MediaItem (same shape as setPlayingFrom), insert into Queue at the corresponding index, then controller.addMediaItem. Empty- queue fallback: route through setPlayingFrom (starts playback immediately) so the user doesn't get a silent no-op. * PlaybackService Player.Listener.onMediaItemTransition — on auto- advance, look up the new index in Queue, push the matching NowPlayingItem into NowPlaying via claim(). Minibar + the SB skip-loop (both reactive to NowPlaying.current) reflect the new track without any extra wiring. * feature/detail/StreamResolution.kt — extracted the resolveStreamPlayback function out of VideoDetailViewModel so the queue path can call it for each new item. * VideoActionsSheet wires Play next / Add to queue rows that launch into StrawApp.globalScope (process-scoped) — sheet dismisses immediately for snappy UX, but the strawcore network resolve lives in a scope that outlives the sheet. Toast on completion. * StrawApp exposes appScope via a companion `globalScope` for fire-and-forget work that needs to outlive Composition. Known limitation: * SponsorBlock segments are not fetched for queued items — they play through without skips. The originally-played item (added via setPlayingFrom) still gets SB. Folding in lazy per-item SB fetch on transition is a follow-up. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- .../main/kotlin/com/sulkta/straw/StrawApp.kt | 16 ++++ .../straw/feature/detail/StreamResolution.kt | 47 +++++++++++ .../feature/detail/VideoDetailViewModel.kt | 30 +------ .../straw/feature/player/PlaybackService.kt | 15 ++++ .../com/sulkta/straw/feature/player/Queue.kt | 61 ++++++++++++++ .../feature/player/StrawMediaController.kt | 79 ++++++++++++++++--- .../straw/feature/playlist/VideoActions.kt | 67 +++++++++++++++- 8 files changed, 278 insertions(+), 41 deletions(-) create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/StreamResolution.kt create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/feature/player/Queue.kt diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index cd111e2a1..d0bd6a3da 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 46 -const val STRAW_VERSION_NAME = "0.1.0-BF" +const val STRAW_VERSION_CODE = 47 +const val STRAW_VERSION_NAME = "0.1.0-BG" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt index 6634cee17..2868d58ac 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt @@ -35,6 +35,22 @@ class StrawApp : Application() { }, ) + companion object { + /** Process-scoped coroutine scope — survives Composition + ViewModel + * teardown. Use for fire-and-forget work like long-press + * "Add to queue" that needs to outlive the UI surface that + * triggered it. */ + lateinit var globalScope: CoroutineScope + private set + } + + init { + // The companion lateinit guarantees the same StrawApp instance + // is the only one that sets globalScope — Application is a + // process-singleton on Android. + globalScope = appScope + } + override fun onCreate() { super.onCreate() // Path C-7: route Rust `log::*` calls into Android logcat under tag diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/StreamResolution.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/StreamResolution.kt new file mode 100644 index 000000000..05325bffd --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/StreamResolution.kt @@ -0,0 +1,47 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Pick the playable URLs from a strawcore StreamInfo. Lives outside + * VideoDetailViewModel so the queue path can call it too. + */ + +package com.sulkta.straw.feature.detail + +import com.sulkta.straw.data.Settings +import com.sulkta.straw.net.SbSegment + +/** + * Convert a raw strawcore.StreamInfo into the picked-URL DTO the + * MediaController wants. Honors Settings.maxResolution — cap-fit if + * possible, otherwise the closest-to-cap fallback (lowest height) so + * we don't blow a user's data plan when only above-cap streams exist. + * + * `segments` is the SponsorBlock list to bake into the resulting + * ResolvedPlayback; pass emptyList() when no SB is desired (the queue + * path doesn't pre-fetch SB for queued items). + */ +fun resolveStreamPlayback( + info: uniffi.strawcore.StreamInfo, + segments: List = emptyList(), +): ResolvedPlayback { + val maxRes = Settings.get().maxResolution.value.ceiling + fun pickVideo(streams: List): String? { + if (streams.isEmpty()) return null + val capped = streams.filter { it.height <= maxRes } + return if (capped.isNotEmpty()) { + capped.maxByOrNull { it.bitrate }?.url + } else { + streams.minByOrNull { it.height }?.url + } + } + return ResolvedPlayback( + title = info.title, + videoUrl = pickVideo(info.videoOnly), + audioUrl = info.audioOnly.maxByOrNull { it.bitrate }?.url, + combinedUrl = pickVideo(info.combined), + dashMpdUrl = info.dashMpdUrl?.takeIf { it.isNotBlank() }, + hlsUrl = info.hlsUrl?.takeIf { it.isNotBlank() }, + segments = segments, + ) +} diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt index 7c11976f9..45336a6bc 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt @@ -280,33 +280,5 @@ class VideoDetailViewModel : ViewModel() { private fun resolvePlayback( info: uniffi.strawcore.StreamInfo, segments: List, - ): ResolvedPlayback { - val maxRes = Settings.get().maxResolution.value.ceiling - // Pick the highest-bitrate stream that still fits the user's - // cap. Fallback: when every available stream EXCEEDS the cap - // (e.g. a 1080p-only upload with the user on a 480p cap), pick - // the LOWEST-height one — that's the closest-to-cap option and - // honors the user's intent ("don't blow my data plan") even - // when their exact target isn't available. vc=34 audit Q-8 — - // previously this fell back to max-bitrate, which was the - // worst possible choice for someone on a 480p cap. - fun pickVideo(streams: List): String? { - if (streams.isEmpty()) return null - val capped = streams.filter { it.height <= maxRes } - return if (capped.isNotEmpty()) { - capped.maxByOrNull { it.bitrate }?.url - } else { - streams.minByOrNull { it.height }?.url - } - } - return ResolvedPlayback( - title = info.title, - videoUrl = pickVideo(info.videoOnly), - audioUrl = info.audioOnly.maxByOrNull { it.bitrate }?.url, - combinedUrl = pickVideo(info.combined), - dashMpdUrl = info.dashMpdUrl?.takeIf { it.isNotBlank() }, - hlsUrl = info.hlsUrl?.takeIf { it.isNotBlank() }, - segments = segments, - ) - } + ): ResolvedPlayback = resolveStreamPlayback(info, segments) } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt index 95902fa6d..7af5a161f 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt @@ -98,6 +98,21 @@ class PlaybackService : MediaSessionService() { .setId(MEDIA_SESSION_ID) .setSessionActivity(sessionActivityIntent) .build() + + // Queue auto-advance bridge: when Media3 transitions to the + // next item in the queue, look up the matching NowPlayingItem + // (with original streamUrl, uploader, thumbnail, SB segments) + // and push it into NowPlaying so the minibar + SponsorBlock + // skip-loop reflect the new track. claim() handles concurrent + // setPlayingFrom races — see vc=35 audit HIGH-C6. + player.addListener(object : Player.Listener { + override fun onMediaItemTransition(item: MediaItem?, reason: Int) { + if (item == null) return + val idx = player.currentMediaItemIndex + val queued = Queue.at(idx) ?: return + NowPlaying.claim(queued) + } + }) } override fun onGetSession( diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/Queue.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/Queue.kt new file mode 100644 index 000000000..eb6a68618 --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/Queue.kt @@ -0,0 +1,61 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Process-wide upcoming-videos queue. Mirrors the MediaController's + * MediaItem list 1:1 by index — Position 0 is "currently playing", + * Position 1+ is "up next". Decoupled from the controller because: + * + * - The controller stores MediaItem (URL + Media3 metadata only). + * We need the original streamUrl, uploader, thumbnail, and + * SponsorBlock segments. NowPlayingItem carries all of that. + * - Media3's onMediaItemTransition fires when the engine auto- + * advances. PlaybackService listens, looks up the new index here, + * and pushes the resolved NowPlayingItem into NowPlaying so the + * minibar + SponsorBlock skip-loop reflect the new track. + * + * Append-only + setAll: no remove/reorder for v1. Mirrors how + * `addMediaItem` / `setMediaItem` mutate the controller. If we ever + * add a queue UI with drag-reorder, that'll need a sync layer. + */ + +package com.sulkta.straw.feature.player + +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.update + +object Queue { + private val _items = MutableStateFlow>(emptyList()) + val items: StateFlow> = _items.asStateFlow() + + /** Replace the queue — used by setPlayingFrom when starting fresh. */ + fun setAll(item: NowPlayingItem) { + _items.value = listOf(item) + } + + fun append(item: NowPlayingItem) { + _items.update { it + item } + } + + /** + * Insert at the given position (relative to the controller's + * indices). Used by "Play next" — inserts right after the + * currently-playing item. + */ + fun insertAt(index: Int, item: NowPlayingItem) { + _items.update { current -> + val mut = current.toMutableList() + mut.add(index.coerceIn(0, mut.size), item) + mut.toList() + } + } + + /** Read the item at the given controller index, or null on OOB. */ + fun at(index: Int): NowPlayingItem? = _items.value.getOrNull(index) + + fun clear() { + _items.value = emptyList() + } +} diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt index 5c3013c5a..127488aa8 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt @@ -83,25 +83,86 @@ fun MediaController.setPlayingFrom( startPositionMs: Long = 0L, ) { val mediaItem = buildMediaItem(title, uploader, thumbnail, resolved) ?: return + val nowPlayingItem = NowPlayingItem( + streamUrl = streamUrl, + title = title, + uploader = uploader, + thumbnail = thumbnail, + segments = resolved.segments, + ) // Atomic claim BEFORE any controller mutation. If a concurrent // caller already set this URL (inline player + fullscreen Player // racing each other on the same transition), we bail before // double-priming the player. vc=35 audit HIGH-C6. - val claimed = NowPlaying.claim( - NowPlayingItem( - streamUrl = streamUrl, - title = title, - uploader = uploader, - thumbnail = thumbnail, - segments = resolved.segments, - ), - ) + val claimed = NowPlaying.claim(nowPlayingItem) if (!claimed) return + // Replace the queue when starting fresh — Queue mirrors the + // controller's MediaItem list 1:1 by index. If the user later + // long-press-enqueues more items, append/insertAt keep them + // synced. + Queue.setAll(nowPlayingItem) setMediaItem(mediaItem, startPositionMs) prepare() playWhenReady = true } +/** + * Add a video to the playback queue right after the currently-playing + * item. If the player is idle (no current item), fall through to a + * setPlayingFrom that starts playback immediately. The caller already + * resolved playback (strawcore.streamInfo → ResolvedPlayback). + * + * Returns true if the item was enqueued or started; false on a build + * failure (no playable stream in `resolved`). + */ +@UnstableApi +fun MediaController.enqueueNext( + streamUrl: String, + title: String, + uploader: String, + thumbnail: String?, + resolved: ResolvedPlayback, +): Boolean = enqueueInternal(streamUrl, title, uploader, thumbnail, resolved, asNext = true) + +/** Append to the back of the queue. Same idle-fallback as enqueueNext. */ +@UnstableApi +fun MediaController.enqueueLast( + streamUrl: String, + title: String, + uploader: String, + thumbnail: String?, + resolved: ResolvedPlayback, +): Boolean = enqueueInternal(streamUrl, title, uploader, thumbnail, resolved, asNext = false) + +@UnstableApi +private fun MediaController.enqueueInternal( + streamUrl: String, + title: String, + uploader: String, + thumbnail: String?, + resolved: ResolvedPlayback, + asNext: Boolean, +): Boolean { + val mediaItem = buildMediaItem(title, uploader, thumbnail, resolved) ?: return false + val item = NowPlayingItem( + streamUrl = streamUrl, + title = title, + uploader = uploader, + thumbnail = thumbnail, + segments = resolved.segments, + ) + // Empty queue — there's nothing to "enqueue" onto. Treat as a + // start-playing-now and route through the normal claim path. + if (mediaItemCount == 0) { + setPlayingFrom(streamUrl, title, uploader, thumbnail, resolved) + return true + } + val insertIndex = if (asNext) currentMediaItemIndex + 1 else mediaItemCount + Queue.insertAt(insertIndex, item) + addMediaItem(insertIndex, mediaItem) + return true +} + @UnstableApi private fun buildMediaItem( title: String, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/playlist/VideoActions.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/playlist/VideoActions.kt index e57433666..51138d738 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/playlist/VideoActions.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/playlist/VideoActions.kt @@ -28,6 +28,8 @@ import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.width import androidx.compose.material.icons.Icons import androidx.compose.material.icons.filled.PlaylistAdd +import androidx.compose.material.icons.filled.PlaylistPlay +import androidx.compose.material.icons.filled.QueueMusic import androidx.compose.material.icons.filled.Share import androidx.compose.material3.AlertDialog import androidx.compose.material3.Button @@ -51,8 +53,18 @@ import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.platform.LocalContext import androidx.compose.ui.unit.dp +import androidx.media3.common.util.UnstableApi +import com.sulkta.straw.StrawApp import com.sulkta.straw.data.PlaylistItem import com.sulkta.straw.data.Playlists +import com.sulkta.straw.feature.detail.resolveStreamPlayback +import com.sulkta.straw.feature.player.LocalStrawController +import com.sulkta.straw.feature.player.enqueueLast +import com.sulkta.straw.feature.player.enqueueNext +import com.sulkta.straw.util.runCatchingCancellable +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext /** * Minimal video descriptor for the actions sheet. Avoids dragging @@ -67,16 +79,59 @@ data class VideoActionTarget( val thumbnail: String?, ) -@OptIn(ExperimentalMaterial3Api::class) +@OptIn(ExperimentalMaterial3Api::class, UnstableApi::class) @Composable fun VideoActionsSheet( target: VideoActionTarget, onDismiss: () -> Unit, ) { val context = LocalContext.current + val controller = LocalStrawController.current + // Use the process scope — rememberCoroutineScope dies when the + // sheet dismisses, and we dismiss the sheet BEFORE the strawcore + // network round-trip completes (so the user gets immediate + // feedback). Process scope keeps the in-flight resolve alive. val sheetState = rememberModalBottomSheetState() var showSaveDialog by remember { mutableStateOf(false) } + /** Resolve a streamUrl → ResolvedPlayback + call the supplied + * enqueue method. Network resolution is the slow part; wrap it + * in runCatchingCancellable so the rememberCoroutineScope dying + * on sheet-dismiss propagates cleanly. */ + fun enqueue(asNext: Boolean) { + val c = controller + if (c == null) { + Toast.makeText(context, "player not ready yet", Toast.LENGTH_SHORT).show() + return + } + Toast.makeText(context, "Resolving…", Toast.LENGTH_SHORT).show() + val appContext = context.applicationContext + onDismiss() + StrawApp.globalScope.launch { + runCatchingCancellable { + val info = uniffi.strawcore.streamInfo(target.streamUrl) + val resolved = resolveStreamPlayback(info) + withContext(Dispatchers.Main) { + val ok = if (asNext) { + c.enqueueNext(target.streamUrl, target.title, target.uploader, target.thumbnail, resolved) + } else { + c.enqueueLast(target.streamUrl, target.title, target.uploader, target.thumbnail, resolved) + } + val msg = if (ok) { + if (asNext) "Will play next" else "Added to queue" + } else { + "no playable stream" + } + Toast.makeText(appContext, msg, Toast.LENGTH_SHORT).show() + } + }.onFailure { + withContext(Dispatchers.Main) { + Toast.makeText(appContext, "queue failed", Toast.LENGTH_SHORT).show() + } + } + } + } + if (showSaveDialog) { SaveToPlaylistDialog( item = PlaylistItem( @@ -116,6 +171,16 @@ fun VideoActionsSheet( } Spacer(modifier = Modifier.height(8.dp)) HorizontalDivider() + ActionRow( + icon = Icons.Filled.PlaylistPlay, + label = "Play next", + onClick = { enqueue(asNext = true) }, + ) + ActionRow( + icon = Icons.Filled.QueueMusic, + label = "Add to queue", + onClick = { enqueue(asNext = false) }, + ) ActionRow( icon = Icons.Filled.PlaylistAdd, label = "Save to playlist", From 964bcddb3a1cb909bdff0a366b329418c4b28262 Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 07:04:35 -0700 Subject: [PATCH 38/72] vc=48: autoplay (off / same-channel / yt-related) + SB for queued items MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two requested features in one ship. Autoplay: * Settings → Autoplay section. Three modes: Off, Same channel, YouTube related. Default Same channel — per Cobb 2026-05-26, "plays next account's video". * Skip-already-watched toggle, default on. Autoplay picks the first un-watched candidate (filters History.watches by videoId). * When STATE_ENDED fires and the queue has no next item, PlaybackService's autoplay handler picks a candidate per mode, resolves it via strawcore, and enqueues — which auto-starts because the queue is empty (enqueueLast routes through setPlayingFrom in that case). * SameChannel calls strawcore.channelInfo(uploaderUrl).take(1). Plumbed NowPlayingItem.uploaderUrl + setPlayingFrom/enqueueLast sig to carry it forward so the autoplay handler has what it needs without re-resolving. * YtRelated re-resolves the current streamInfo and picks info.related[0]. strawcore returns empty for related today, so YtRelated falls open to no-op until that extractor work lands — documented in the AutoplayMode enum help text. SponsorBlock for queued items: * The vc=47 known-limitation. Now: when onMediaItemTransition surfaces a queued item with empty SB segments, fire a background fetch of SB for that video, then NowPlaying.claim() again with the freshened segments. The skip-loop (reactive on NowPlaying.current.segments) picks them up. * Fetch lives in StrawApp.globalScope — outlives the controller transition + sheet UI. Refactor: * StrawMediaController extensions retyped from MediaController → Player so PlaybackService can call them on the ExoPlayer directly. MediaController IS a Player so all existing UI call sites continue to work. * Shared extractYtVideoId util in feature/detail/StreamResolution.kt. The duplicate VIDEO_ID_RE in StrawHome.kt will fold into it next time that file is touched. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- .../com/sulkta/straw/data/SettingsStore.kt | 47 ++++++ .../straw/feature/detail/StreamResolution.kt | 15 ++ .../straw/feature/detail/VideoDetailScreen.kt | 3 + .../sulkta/straw/feature/player/NowPlaying.kt | 8 + .../straw/feature/player/PlaybackService.kt | 138 ++++++++++++++++++ .../straw/feature/player/PlayerScreen.kt | 1 + .../feature/player/StrawMediaController.kt | 21 ++- .../straw/feature/settings/SettingsScreen.kt | 67 +++++++++ 9 files changed, 295 insertions(+), 9 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index d0bd6a3da..a155f1f75 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 47 -const val STRAW_VERSION_NAME = "0.1.0-BG" +const val STRAW_VERSION_CODE = 48 +const val STRAW_VERSION_NAME = "0.1.0-BH" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt index 6f01965ac..2580f8128 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt @@ -43,11 +43,28 @@ enum class ThemeMode(val label: String) { Dark("Dark"), } +/** + * When a video ends with nothing left in the queue, what should the + * player do? `Off` stops at the end (matches NewPipe's default). + * `SameChannel` chains to the next video from the same uploader — + * fits Straw's user-curated ethos (you opted into this channel). + * `YtRelated` pulls from `info.related` (YouTube's algorithmic + * suggestion); deferred until strawcore populates `related` from + * the /next response — for now it's identical to `Off`. + */ +enum class AutoplayMode(val label: String, val help: String) { + Off("Off", "Stop at the end."), + SameChannel("Same channel", "Play the next video from the same uploader."), + YtRelated("YouTube related", "Pull from YT's related suggestions. (not yet wired — extractor returns empty)"), +} + private const val PREFS = "straw_settings" private const val KEY_SB_CATS = "sb_categories_v1" private const val KEY_MAX_RES = "max_resolution_v1" private const val KEY_THEME = "theme_mode_v1" private const val KEY_CACHE_ENABLED = "cache_enabled_v1" +private const val KEY_AUTOPLAY_MODE = "autoplay_mode_v1" +private const val KEY_AUTOPLAY_SKIP_WATCHED = "autoplay_skip_watched_v1" class SettingsStore(context: Context) { private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) @@ -64,6 +81,14 @@ class SettingsStore(context: Context) { private val _cacheEnabled = MutableStateFlow(sp.getBoolean(KEY_CACHE_ENABLED, true)) val cacheEnabled: StateFlow = _cacheEnabled.asStateFlow() + private val _autoplayMode = MutableStateFlow(loadAutoplayMode()) + val autoplayMode: StateFlow = _autoplayMode.asStateFlow() + + private val _autoplaySkipWatched = MutableStateFlow( + sp.getBoolean(KEY_AUTOPLAY_SKIP_WATCHED, true), + ) + val autoplaySkipWatched: StateFlow = _autoplaySkipWatched.asStateFlow() + fun toggle(cat: SbCategory) { // Atomic toggle via updateAndGet — see AUD-HIGH note in HistoryStore. val next = _sbCategories.updateAndGet { cur -> @@ -98,6 +123,20 @@ class SettingsStore(context: Context) { sp.edit().putBoolean(KEY_CACHE_ENABLED, enabled).apply() } + fun setAutoplayMode(mode: AutoplayMode) { + val before = _autoplayMode.value + if (before == mode) return + _autoplayMode.value = mode + sp.edit().putString(KEY_AUTOPLAY_MODE, mode.name).apply() + } + + fun setAutoplaySkipWatched(skip: Boolean) { + val before = _autoplaySkipWatched.value + if (before == skip) return + _autoplaySkipWatched.value = skip + sp.edit().putBoolean(KEY_AUTOPLAY_SKIP_WATCHED, skip).apply() + } + private fun loadCategories(): Set { val raw = sp.getStringSet(KEY_SB_CATS, null) return if (raw == null) { @@ -117,6 +156,14 @@ class SettingsStore(context: Context) { val name = sp.getString(KEY_THEME, null) ?: return ThemeMode.System return ThemeMode.entries.firstOrNull { it.name == name } ?: ThemeMode.System } + + private fun loadAutoplayMode(): AutoplayMode { + // Default to SameChannel — user explicitly chose "on by default, + // plays next account's video" 2026-05-26. Off-by-default doesn't + // fit the workflow (queue empties → silence). + val name = sp.getString(KEY_AUTOPLAY_MODE, null) ?: return AutoplayMode.SameChannel + return AutoplayMode.entries.firstOrNull { it.name == name } ?: AutoplayMode.SameChannel + } } object Settings { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/StreamResolution.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/StreamResolution.kt index 05325bffd..d3daaac3e 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/StreamResolution.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/StreamResolution.kt @@ -11,6 +11,21 @@ package com.sulkta.straw.feature.detail import com.sulkta.straw.data.Settings import com.sulkta.straw.net.SbSegment +/** + * Extract the YouTube video ID from a watch URL. Handles the common + * forms: `youtube.com/watch?v=XXXXXXXXXXX`, `youtu.be/X...`, and + * `youtube.com/shorts/X...`. Returns null when nothing matches. + * + * Centralized here so the autoplay + history + import paths all + * resolve videoIds the same way. Duplicates an earlier per-file regex + * (`StrawHome.kt:VIDEO_ID_RE`) — that one can fold into this when next + * touched. + */ +private val VIDEO_ID_RE = Regex("(?:v=|/)([A-Za-z0-9_-]{11})(?:[?&#].*)?$") + +fun extractYtVideoId(url: String): String? = + VIDEO_ID_RE.find(url)?.groupValues?.getOrNull(1)?.takeIf { it.isNotBlank() } + /** * Convert a raw strawcore.StreamInfo into the picked-URL DTO the * MediaController wants. Honors Settings.maxResolution — cap-fit if diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index 8cb277a6c..fb2f9aaef 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -437,6 +437,7 @@ fun VideoDetailScreen( uploader = d.uploader, thumbnail = d.thumbnail, resolved = r, + uploaderUrl = d.uploaderUrl, ) } // Audio-only: drop video track. Foreground @@ -488,6 +489,7 @@ fun VideoDetailScreen( uploader = d.uploader, thumbnail = d.thumbnail, resolved = r, + uploaderUrl = d.uploaderUrl, ) } val params = PictureInPictureParams.Builder() @@ -746,6 +748,7 @@ private fun InlinePlayer( uploader = uploader, thumbnail = thumbnail, resolved = r, + uploaderUrl = state.detail?.uploaderUrl, ) } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/NowPlaying.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/NowPlaying.kt index 446729753..3732b9212 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/NowPlaying.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/NowPlaying.kt @@ -24,6 +24,14 @@ data class NowPlayingItem( val streamUrl: String, val title: String, val uploader: String, + /** + * Uploader's channel URL — needed by the autoplay path so the + * end-of-video handler can call channelInfo() to find the next + * same-channel candidate. Optional because some items come from + * paths where we don't have it (deep links, history rows on a + * cold start before strawcore has resolved metadata). + */ + val uploaderUrl: String? = null, val thumbnail: String?, val segments: List = emptyList(), ) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt index 7af5a161f..7ddd1a85b 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt @@ -45,8 +45,18 @@ import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy import androidx.media3.session.MediaSession import androidx.media3.session.MediaSessionService import com.sulkta.straw.StrawActivity +import com.sulkta.straw.StrawApp +import com.sulkta.straw.data.AutoplayMode +import com.sulkta.straw.data.History +import com.sulkta.straw.data.Settings +import com.sulkta.straw.feature.detail.resolveStreamPlayback import com.sulkta.straw.net.IosSafeHttpDataSource import com.sulkta.straw.net.STRAW_USER_AGENT +import com.sulkta.straw.net.SponsorBlockClient +import com.sulkta.straw.util.runCatchingCancellable +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext @UnstableApi class PlaybackService : MediaSessionService() { @@ -105,16 +115,144 @@ class PlaybackService : MediaSessionService() { // and push it into NowPlaying so the minibar + SponsorBlock // skip-loop reflect the new track. claim() handles concurrent // setPlayingFrom races — see vc=35 audit HIGH-C6. + // + // SponsorBlock for queued items: when a queued item's segments + // are empty (which they always are — enqueueNext/Last doesn't + // pre-fetch SB to avoid the network round-trip on every long- + // press), kick off a background fetch and re-claim with the + // freshened segments. NowPlaying.claim handles the + // "same-streamUrl with fresher metadata" case via its CAS. + // + // Autoplay at end-of-queue: when STATE_ENDED fires and there's + // no next item in the queue, consult Settings.autoplayMode and + // pick a candidate. SameChannel → call channelInfo on the + // current uploader, take the first un-watched (gated on + // autoplaySkipWatched). YtRelated → would re-call streamInfo + // and pick info.related[0] but strawcore returns empty for + // related today, so it's a no-op until that lands. player.addListener(object : Player.Listener { override fun onMediaItemTransition(item: MediaItem?, reason: Int) { if (item == null) return val idx = player.currentMediaItemIndex val queued = Queue.at(idx) ?: return NowPlaying.claim(queued) + if (queued.segments.isEmpty()) { + val videoId = com.sulkta.straw.feature.detail.extractYtVideoId(queued.streamUrl) + if (!videoId.isNullOrBlank()) fetchSbForQueued(queued, videoId) + } + } + + override fun onPlaybackStateChanged(state: Int) { + if (state != Player.STATE_ENDED) return + val mode = Settings.get().autoplayMode.value + if (mode == AutoplayMode.Off) return + // Media3 auto-advances inside the queue; we only kick + // in when the queue has truly run out. mediaItemCount + // hits 0 after the engine reports STATE_ENDED in some + // edge cases — handle both. + val atEnd = player.mediaItemCount <= 1 || + player.currentMediaItemIndex >= player.mediaItemCount - 1 + if (!atEnd) return + tryAutoplay(mode) } }) } + private fun fetchSbForQueued(item: NowPlayingItem, videoId: String) { + StrawApp.globalScope.launch { + runCatchingCancellable { + val cats = Settings.get().sbCategories.value.map { it.key } + if (cats.isEmpty()) return@runCatchingCancellable + val segments = withContext(Dispatchers.IO) { + SponsorBlockClient.fetch(videoId, cats) + } + if (segments.isNotEmpty()) { + NowPlaying.claim(item.copy(segments = segments)) + } + } + } + } + + private fun tryAutoplay(mode: AutoplayMode) { + val current = NowPlaying.current.value ?: return + val uploaderUrl = current.uploaderUrl + // We need the channel URL for the SameChannel path; YtRelated + // re-resolves the current video's info. If we don't have what + // we need, silently bail — better than a half-baked surprise. + val controller = (mediaSession?.player as? Player) ?: return + StrawApp.globalScope.launch { + runCatchingCancellable { + val candidateUrl = withContext(Dispatchers.IO) { + pickAutoplayCandidate(mode, current.streamUrl, uploaderUrl) + } ?: return@runCatchingCancellable + // Resolve + enqueue + auto-play. Because the queue is + // currently empty (we just ended), enqueueLast routes + // through setPlayingFrom (auto-starts). + val info = withContext(Dispatchers.IO) { + uniffi.strawcore.streamInfo(candidateUrl) + } + val resolved = resolveStreamPlayback(info) + withContext(Dispatchers.Main) { + controller.enqueueLast( + streamUrl = candidateUrl, + title = info.title, + uploader = info.uploader, + thumbnail = info.thumbnail, + resolved = resolved, + uploaderUrl = info.uploaderUrl, + ) + } + } + } + } + + private fun pickAutoplayCandidate( + mode: AutoplayMode, + currentStreamUrl: String, + uploaderUrl: String?, + ): String? = when (mode) { + AutoplayMode.Off -> null + AutoplayMode.SameChannel -> { + if (uploaderUrl.isNullOrBlank()) null + else runCatching { + val ch = uniffi.strawcore.channelInfo(uploaderUrl) + val watched = if (Settings.get().autoplaySkipWatched.value) { + History.get().watches.value.map { it.videoId }.toSet() + } else emptySet() + ch.videos + .asSequence() + .filter { it.url != currentStreamUrl } + .filter { + if (watched.isEmpty()) true + else { + val id = com.sulkta.straw.feature.detail.extractYtVideoId(it.url) + id == null || id !in watched + } + } + .firstOrNull()?.url + }.getOrNull() + } + AutoplayMode.YtRelated -> { + runCatching { + val info = uniffi.strawcore.streamInfo(currentStreamUrl) + val watched = if (Settings.get().autoplaySkipWatched.value) { + History.get().watches.value.map { it.videoId }.toSet() + } else emptySet() + info.related + .asSequence() + .filter { it.url != currentStreamUrl } + .filter { + if (watched.isEmpty()) true + else { + val id = com.sulkta.straw.feature.detail.extractYtVideoId(it.url) + id == null || id !in watched + } + } + .firstOrNull()?.url + }.getOrNull() + } + } + override fun onGetSession( controllerInfo: MediaSession.ControllerInfo, ): MediaSession? = mediaSession diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt index 4d455a47a..fb466eebc 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt @@ -117,6 +117,7 @@ fun PlayerScreen( uploader = uploader, thumbnail = thumbnail, resolved = r, + uploaderUrl = detail?.uploaderUrl, ) } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt index 127488aa8..1932f1726 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt @@ -37,6 +37,7 @@ import androidx.compose.ui.platform.LocalContext import androidx.media3.common.MediaItem import androidx.media3.common.MediaMetadata import androidx.media3.common.MimeTypes +import androidx.media3.common.Player import androidx.media3.common.util.UnstableApi import androidx.media3.session.MediaController import androidx.media3.session.SessionToken @@ -74,19 +75,21 @@ fun rememberStrawController(): MediaController? { * MediaSource based on MIME + the EXTRA_AUDIO_URL bundle. */ @UnstableApi -fun MediaController.setPlayingFrom( +fun Player.setPlayingFrom( streamUrl: String, title: String, uploader: String, thumbnail: String?, resolved: ResolvedPlayback, startPositionMs: Long = 0L, + uploaderUrl: String? = null, ) { val mediaItem = buildMediaItem(title, uploader, thumbnail, resolved) ?: return val nowPlayingItem = NowPlayingItem( streamUrl = streamUrl, title = title, uploader = uploader, + uploaderUrl = uploaderUrl, thumbnail = thumbnail, segments = resolved.segments, ) @@ -116,31 +119,34 @@ fun MediaController.setPlayingFrom( * failure (no playable stream in `resolved`). */ @UnstableApi -fun MediaController.enqueueNext( +fun Player.enqueueNext( streamUrl: String, title: String, uploader: String, thumbnail: String?, resolved: ResolvedPlayback, -): Boolean = enqueueInternal(streamUrl, title, uploader, thumbnail, resolved, asNext = true) + uploaderUrl: String? = null, +): Boolean = enqueueInternal(streamUrl, title, uploader, thumbnail, resolved, uploaderUrl, asNext = true) /** Append to the back of the queue. Same idle-fallback as enqueueNext. */ @UnstableApi -fun MediaController.enqueueLast( +fun Player.enqueueLast( streamUrl: String, title: String, uploader: String, thumbnail: String?, resolved: ResolvedPlayback, -): Boolean = enqueueInternal(streamUrl, title, uploader, thumbnail, resolved, asNext = false) + uploaderUrl: String? = null, +): Boolean = enqueueInternal(streamUrl, title, uploader, thumbnail, resolved, uploaderUrl, asNext = false) @UnstableApi -private fun MediaController.enqueueInternal( +private fun Player.enqueueInternal( streamUrl: String, title: String, uploader: String, thumbnail: String?, resolved: ResolvedPlayback, + uploaderUrl: String?, asNext: Boolean, ): Boolean { val mediaItem = buildMediaItem(title, uploader, thumbnail, resolved) ?: return false @@ -148,13 +154,14 @@ private fun MediaController.enqueueInternal( streamUrl = streamUrl, title = title, uploader = uploader, + uploaderUrl = uploaderUrl, thumbnail = thumbnail, segments = resolved.segments, ) // Empty queue — there's nothing to "enqueue" onto. Treat as a // start-playing-now and route through the normal claim path. if (mediaItemCount == 0) { - setPlayingFrom(streamUrl, title, uploader, thumbnail, resolved) + setPlayingFrom(streamUrl, title, uploader, thumbnail, resolved, uploaderUrl = uploaderUrl) return true } val insertIndex = if (asNext) currentMediaItemIndex + 1 else mediaItemCount diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt index 332e5b2f3..8d6a75551 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt @@ -44,6 +44,7 @@ import android.widget.Toast import androidx.lifecycle.viewmodel.compose.viewModel import com.sulkta.straw.data.FeedCache import com.sulkta.straw.data.History +import com.sulkta.straw.data.AutoplayMode import com.sulkta.straw.data.MaxResolution import com.sulkta.straw.data.SbCategory import com.sulkta.straw.data.SearchCache @@ -176,6 +177,72 @@ fun SettingsScreen() { HorizontalDivider() } + Spacer(modifier = Modifier.height(32.dp)) + Text( + "Autoplay", + style = MaterialTheme.typography.titleMedium, + fontWeight = FontWeight.SemiBold, + ) + Spacer(modifier = Modifier.height(4.dp)) + Text( + "When a video ends with nothing left in the queue, what should " + + "play next? Queue auto-advance always works regardless of " + + "this setting — autoplay only kicks in at the end.", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + Spacer(modifier = Modifier.height(8.dp)) + val autoplayMode by store.autoplayMode.collectAsState() + AutoplayMode.entries.forEach { m -> + Row( + modifier = Modifier + .fillMaxWidth() + .clickable { store.setAutoplayMode(m) } + .padding(vertical = 8.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Text( + text = if (m == autoplayMode) "• ${m.label}" else " ${m.label}", + style = MaterialTheme.typography.bodyLarge, + color = if (m == autoplayMode) MaterialTheme.colorScheme.primary + else MaterialTheme.colorScheme.onSurface, + ) + } + Text( + m.help, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + modifier = Modifier.padding(start = 24.dp, bottom = 4.dp), + ) + HorizontalDivider() + } + Spacer(modifier = Modifier.height(12.dp)) + val skipWatched by store.autoplaySkipWatched.collectAsState() + Row( + modifier = Modifier + .fillMaxWidth() + .padding(vertical = 6.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.SpaceBetween, + ) { + Column(modifier = Modifier.weight(1f)) { + Text( + "Skip already-watched videos", + style = MaterialTheme.typography.bodyLarge, + fontWeight = FontWeight.SemiBold, + ) + Text( + "Autoplay picks the next un-watched video.", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + Switch( + checked = skipWatched, + onCheckedChange = { store.setAutoplaySkipWatched(it) }, + ) + } + Spacer(modifier = Modifier.height(32.dp)) Text( "Local cache", From 62cc18c940c659f66fa4723579fe11874e0a807f Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 07:08:39 -0700 Subject: [PATCH 39/72] fixup vc=48: pickAutoplayCandidate uses try/catch (runCatching not suspend-aware) --- .../straw/feature/player/PlaybackService.kt | 74 +++++++++---------- 1 file changed, 34 insertions(+), 40 deletions(-) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt index 7ddd1a85b..e39194ee0 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt @@ -206,50 +206,44 @@ class PlaybackService : MediaSessionService() { } } - private fun pickAutoplayCandidate( + private suspend fun pickAutoplayCandidate( mode: AutoplayMode, currentStreamUrl: String, uploaderUrl: String?, - ): String? = when (mode) { - AutoplayMode.Off -> null - AutoplayMode.SameChannel -> { - if (uploaderUrl.isNullOrBlank()) null - else runCatching { - val ch = uniffi.strawcore.channelInfo(uploaderUrl) - val watched = if (Settings.get().autoplaySkipWatched.value) { - History.get().watches.value.map { it.videoId }.toSet() - } else emptySet() - ch.videos - .asSequence() - .filter { it.url != currentStreamUrl } - .filter { - if (watched.isEmpty()) true - else { - val id = com.sulkta.straw.feature.detail.extractYtVideoId(it.url) - id == null || id !in watched - } - } - .firstOrNull()?.url - }.getOrNull() + ): String? { + val watched = if (Settings.get().autoplaySkipWatched.value) { + History.get().watches.value.map { it.videoId }.toSet() + } else emptySet() + fun unwatched(url: String): Boolean { + if (watched.isEmpty()) return true + val id = com.sulkta.straw.feature.detail.extractYtVideoId(url) + return id == null || id !in watched } - AutoplayMode.YtRelated -> { - runCatching { - val info = uniffi.strawcore.streamInfo(currentStreamUrl) - val watched = if (Settings.get().autoplaySkipWatched.value) { - History.get().watches.value.map { it.videoId }.toSet() - } else emptySet() - info.related - .asSequence() - .filter { it.url != currentStreamUrl } - .filter { - if (watched.isEmpty()) true - else { - val id = com.sulkta.straw.feature.detail.extractYtVideoId(it.url) - id == null || id !in watched - } - } - .firstOrNull()?.url - }.getOrNull() + return try { + when (mode) { + AutoplayMode.Off -> null + AutoplayMode.SameChannel -> { + if (uploaderUrl.isNullOrBlank()) return null + val ch = uniffi.strawcore.channelInfo(uploaderUrl) + ch.videos + .asSequence() + .filter { it.url != currentStreamUrl } + .filter { unwatched(it.url) } + .firstOrNull()?.url + } + AutoplayMode.YtRelated -> { + val info = uniffi.strawcore.streamInfo(currentStreamUrl) + info.related + .asSequence() + .filter { it.url != currentStreamUrl } + .filter { unwatched(it.url) } + .firstOrNull()?.url + } + } + } catch (c: kotlinx.coroutines.CancellationException) { + throw c + } catch (_: Throwable) { + null } } From 0f946d8b4ecf4bcda4d3869f86a9d3261ddc47da Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 07:17:29 -0700 Subject: [PATCH 40/72] vc=49: Auto-start playback setting (cold-open autoplay) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Settings → Autoplay section now has a third toggle: Auto-start playback (default on). When on, opening a fresh video starts playing immediately on the detail page. When off, the page renders with the thumbnail + Play overlay and you tap to start. Independent of the end-of-queue autoplay mode and the back-from- fullscreen behavior (that already auto-resumes because the controller is mid-stream — preserved). Implementation: a single OR into the initial inlinePlaying state in VideoDetailScreen. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +-- .../com/sulkta/straw/data/SettingsStore.kt | 21 +++++++++++++++ .../straw/feature/detail/VideoDetailScreen.kt | 21 ++++++++------- .../straw/feature/settings/SettingsScreen.kt | 26 +++++++++++++++++++ 4 files changed, 61 insertions(+), 11 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index a155f1f75..937c3b1c7 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 48 -const val STRAW_VERSION_NAME = "0.1.0-BH" +const val STRAW_VERSION_CODE = 49 +const val STRAW_VERSION_NAME = "0.1.0-BI" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt index 2580f8128..4a1c79780 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt @@ -65,6 +65,7 @@ private const val KEY_THEME = "theme_mode_v1" private const val KEY_CACHE_ENABLED = "cache_enabled_v1" private const val KEY_AUTOPLAY_MODE = "autoplay_mode_v1" private const val KEY_AUTOPLAY_SKIP_WATCHED = "autoplay_skip_watched_v1" +private const val KEY_AUTOSTART_PLAYBACK = "autostart_playback_v1" class SettingsStore(context: Context) { private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) @@ -89,6 +90,19 @@ class SettingsStore(context: Context) { ) val autoplaySkipWatched: StateFlow = _autoplaySkipWatched.asStateFlow() + /** + * "Open a video → it starts playing immediately." Default on — + * matches YT/NewPipe. When off, opening a fresh video lands you + * on the detail page with the thumbnail + Play overlay; you tap + * to start. Doesn't affect back-from-fullscreen (that's a + * separate path in VideoDetailScreen that defaults to true when + * the shared controller is already streaming the URL). + */ + private val _autoStartPlayback = MutableStateFlow( + sp.getBoolean(KEY_AUTOSTART_PLAYBACK, true), + ) + val autoStartPlayback: StateFlow = _autoStartPlayback.asStateFlow() + fun toggle(cat: SbCategory) { // Atomic toggle via updateAndGet — see AUD-HIGH note in HistoryStore. val next = _sbCategories.updateAndGet { cur -> @@ -137,6 +151,13 @@ class SettingsStore(context: Context) { sp.edit().putBoolean(KEY_AUTOPLAY_SKIP_WATCHED, skip).apply() } + fun setAutoStartPlayback(autoStart: Boolean) { + val before = _autoStartPlayback.value + if (before == autoStart) return + _autoStartPlayback.value = autoStart + sp.edit().putBoolean(KEY_AUTOSTART_PLAYBACK, autoStart).apply() + } + private fun loadCategories(): Set { val raw = sp.getStringSet(KEY_SB_CATS, null) return if (raw == null) { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index fb2f9aaef..cdcd0bbfe 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -133,16 +133,19 @@ fun VideoDetailScreen( ) } // Inline-play state resets when navigating to a different video. - // BUT: if the shared MediaController is already playing this exact - // stream — most commonly because the user popped back from - // fullscreen Player — default to true so the inline surface picks - // up the running playback instead of dropping back to the - // thumbnail+Play placeholder. Without this, system back from - // fullscreen looked like "the video went to background" — audio - // continued via the persistent controller but the video page - // re-rendered as a freshly-loaded detail. + // Defaults to TRUE when: + // * the shared MediaController is already streaming this URL + // (back-from-fullscreen — without this the page renders as + // "freshly loaded" while audio keeps playing in the + // background), or + // * the user has Settings → Auto-start playback enabled (cold + // open from search / subs / wherever immediately plays). + // Off + fresh URL → thumbnail + Play overlay, user taps to start. + val autoStart by Settings.get().autoStartPlayback.collectAsState() var inlinePlaying by remember(streamUrl) { - mutableStateOf(NowPlaying.current.value?.streamUrl == streamUrl) + mutableStateOf( + NowPlaying.current.value?.streamUrl == streamUrl || autoStart, + ) } LaunchedEffect(streamUrl) { vm.load(streamUrl) } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt index 8d6a75551..a97af48b4 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt @@ -242,6 +242,32 @@ fun SettingsScreen() { onCheckedChange = { store.setAutoplaySkipWatched(it) }, ) } + val autoStartPlayback by store.autoStartPlayback.collectAsState() + Row( + modifier = Modifier + .fillMaxWidth() + .padding(vertical = 6.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.SpaceBetween, + ) { + Column(modifier = Modifier.weight(1f)) { + Text( + "Auto-start playback", + style = MaterialTheme.typography.bodyLarge, + fontWeight = FontWeight.SemiBold, + ) + Text( + "Open a video → it starts immediately. Off: tap " + + "the thumbnail to start.", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + Switch( + checked = autoStartPlayback, + onCheckedChange = { store.setAutoStartPlayback(it) }, + ) + } Spacer(modifier = Modifier.height(32.dp)) Text( From 714a2f8a929f3ccf95401e74a9d150d2e6d01847 Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 07:21:09 -0700 Subject: [PATCH 41/72] fixup vc=49: missing Settings import in VideoDetailScreen --- .../kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt | 1 + 1 file changed, 1 insertion(+) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index cdcd0bbfe..3dd48fb88 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -103,6 +103,7 @@ import com.sulkta.straw.feature.player.setPlayingFrom import com.sulkta.straw.feature.search.StreamItem import com.sulkta.straw.util.LogDump import com.sulkta.straw.data.ChannelRef +import com.sulkta.straw.data.Settings import com.sulkta.straw.data.Subscriptions import com.sulkta.straw.util.formatCount import com.sulkta.straw.util.formatViews From 208cdf63260139edd67b87b294eeb771b0681afa Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 07:36:33 -0700 Subject: [PATCH 42/72] vc=50: Settings respects nav-bar inset + minibar overlay MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Last rows of Settings were rendering under the 3-button nav and under the floating minibar. Now: * Column gets .navigationBarsPadding() so it clears the system nav bar / gesture bar at the bottom. * Reactive minibarReserve (72dp when NowPlaying.current != null, else 0dp) added as a tail Spacer to clear the 64dp BottomCenter minibar chip. Only consumed when something's actually playing — no wasted space otherwise. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 ++-- .../straw/feature/settings/SettingsScreen.kt | 15 +++++++++++++++ 2 files changed, 17 insertions(+), 2 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 937c3b1c7..038626994 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 49 -const val STRAW_VERSION_NAME = "0.1.0-BI" +const val STRAW_VERSION_CODE = 50 +const val STRAW_VERSION_NAME = "0.1.0-BJ" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt index a97af48b4..b79b2dd5d 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt @@ -16,7 +16,9 @@ import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.height import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.navigationBarsPadding import androidx.compose.foundation.layout.statusBarsPadding +import com.sulkta.straw.feature.player.NowPlaying import androidx.compose.foundation.rememberScrollState import androidx.compose.foundation.verticalScroll import androidx.compose.material3.AlertDialog @@ -77,10 +79,18 @@ fun SettingsScreen() { } } + // Clear the gesture-bar / 3-button nav bar at the bottom and add + // extra room for the minibar overlay when something's playing — + // otherwise the bottom rows of Settings render UNDER both. The + // minibar is a process-wide BottomCenter overlay (StrawActivity + // ScreenContent) so each scrolling screen has to leave its own gap. + val showingMinibar by NowPlaying.current.collectAsState() + val minibarReserve = if (showingMinibar != null) 72.dp else 0.dp Column( modifier = Modifier .fillMaxSize() .statusBarsPadding() + .navigationBarsPadding() .verticalScroll(rememberScrollState()) .padding(horizontal = 20.dp, vertical = 16.dp), ) { @@ -415,6 +425,11 @@ fun SettingsScreen() { Text("Pick export file…") } } + + // Tail spacer to clear the minibar overlay when something's + // playing. Without this the last Settings row gets eaten by + // the 64dp BottomCenter chip. + Spacer(modifier = Modifier.height(minibarReserve)) } importResult?.let { res -> From dc1fff00db0ccfd0375b91159abfd652a81cac68 Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 08:14:16 -0700 Subject: [PATCH 43/72] vc=51: bottom-clear sweep + DASH res cap + headphone pause MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Three landing together. Bottom-clear sweep: Channel + Search + Subs feed + History + Playlists + Downloads all had content rendering under the system nav bar and the minibar overlay. Added a shared `util/BottomInsets.kt` `rememberBottomContentPadding()` that combines nav-bar inset + reactive 72dp minibar reserve (zero when nothing's playing). Plumbed into every LazyColumn's contentPadding. Same pattern Settings vc=50 used, lifted into a reusable helper. DASH/HLS max-resolution cap: Round-7 audit MED-3 — the user's max-resolution preference only affected the videoOnly/combined picker. DASH manifests bypassed the cap because Media3's ABR picked variants freely. New Player.applyMaxResolutionCap() pushes TrackSelectionParameters .setMaxVideoSize(MAX, ceiling) into the controller before prepare(). Auto = MAX_VALUE = unconstrained. Mid-stream setting changes take effect on next video. Pause on headphone disconnect: User-reported bug — wired headphones died, player switched to phone speaker instead of pausing. ExoPlayer's setHandleAudioBecomingNoisy honors Android's AUDIO_BECOMING_NOISY broadcast and pauses on the standard "headphones pulled" event. Wired into PlaybackService at construction + StrawApp.globalScope collector so flipping the setting mid-session takes effect on the already-built ExoPlayer. New Settings → Pause on headphone disconnect toggle, default on (matches every other Android media app's UX). --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- .../main/kotlin/com/sulkta/straw/StrawHome.kt | 8 +++- .../com/sulkta/straw/data/SettingsStore.kt | 20 +++++++++ .../straw/feature/channel/ChannelScreen.kt | 6 ++- .../straw/feature/download/DownloadsScreen.kt | 3 +- .../straw/feature/player/PlaybackService.kt | 22 +++++++++ .../feature/player/StrawMediaController.kt | 25 +++++++++++ .../straw/feature/playlist/PlaylistsScreen.kt | 5 ++- .../straw/feature/search/SearchScreen.kt | 6 ++- .../straw/feature/settings/SettingsScreen.kt | 26 +++++++++++ .../com/sulkta/straw/util/BottomInsets.kt | 45 +++++++++++++++++++ 11 files changed, 161 insertions(+), 9 deletions(-) create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/util/BottomInsets.kt diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 038626994..73ed00783 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 50 -const val STRAW_VERSION_NAME = "0.1.0-BJ" +const val STRAW_VERSION_CODE = 51 +const val STRAW_VERSION_NAME = "0.1.0-BK" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt index 2170bb823..251fcceda 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt @@ -83,6 +83,7 @@ import com.sulkta.straw.feature.feed.SubscriptionFeedViewModel import com.sulkta.straw.feature.playlist.VideoActionTarget import com.sulkta.straw.feature.playlist.VideoActionsSheet import com.sulkta.straw.feature.search.StreamItem +import com.sulkta.straw.util.rememberBottomContentPadding import com.sulkta.straw.OverlayDimColor import com.sulkta.straw.util.formatDuration import com.sulkta.straw.util.formatViews @@ -258,7 +259,7 @@ private fun HistoryPane(onOpenVideo: (url: String, title: String) -> Unit) { color = MaterialTheme.colorScheme.onSurfaceVariant, ) } else { - LazyColumn { + LazyColumn(contentPadding = rememberBottomContentPadding()) { items(watches) { w -> RecentRow( item = w, @@ -436,7 +437,10 @@ private fun SubsPane( } } } - LazyColumn(state = listState) { + LazyColumn( + state = listState, + contentPadding = rememberBottomContentPadding(), + ) { items(displayed) { item -> FeedRow( item = item, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt index 4a1c79780..05dbafae9 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt @@ -66,6 +66,7 @@ private const val KEY_CACHE_ENABLED = "cache_enabled_v1" private const val KEY_AUTOPLAY_MODE = "autoplay_mode_v1" private const val KEY_AUTOPLAY_SKIP_WATCHED = "autoplay_skip_watched_v1" private const val KEY_AUTOSTART_PLAYBACK = "autostart_playback_v1" +private const val KEY_PAUSE_ON_HEADPHONE_DISCONNECT = "pause_on_headphone_disconnect_v1" class SettingsStore(context: Context) { private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) @@ -103,6 +104,18 @@ class SettingsStore(context: Context) { ) val autoStartPlayback: StateFlow = _autoStartPlayback.asStateFlow() + /** + * Honor Android's AUDIO_BECOMING_NOISY broadcast — wired headphones + * yanked / Bluetooth disconnect → pause instead of switching to the + * phone speaker. Default on; matches every other Android media app. + * Off lets playback follow the audio focus default (phone speaker + * takes over). + */ + private val _pauseOnHeadphoneDisconnect = MutableStateFlow( + sp.getBoolean(KEY_PAUSE_ON_HEADPHONE_DISCONNECT, true), + ) + val pauseOnHeadphoneDisconnect: StateFlow = _pauseOnHeadphoneDisconnect.asStateFlow() + fun toggle(cat: SbCategory) { // Atomic toggle via updateAndGet — see AUD-HIGH note in HistoryStore. val next = _sbCategories.updateAndGet { cur -> @@ -158,6 +171,13 @@ class SettingsStore(context: Context) { sp.edit().putBoolean(KEY_AUTOSTART_PLAYBACK, autoStart).apply() } + fun setPauseOnHeadphoneDisconnect(pause: Boolean) { + val before = _pauseOnHeadphoneDisconnect.value + if (before == pause) return + _pauseOnHeadphoneDisconnect.value = pause + sp.edit().putBoolean(KEY_PAUSE_ON_HEADPHONE_DISCONNECT, pause).apply() + } + private fun loadCategories(): Set { val raw = sp.getStringSet(KEY_SB_CATS, null) return if (raw == null) { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt index 54e41dd0f..6333612d4 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt @@ -55,6 +55,7 @@ import com.sulkta.straw.feature.playlist.VideoActionTarget import com.sulkta.straw.feature.playlist.VideoActionsSheet import com.sulkta.straw.feature.search.StreamItem import com.sulkta.straw.util.formatCount +import com.sulkta.straw.util.rememberBottomContentPadding import com.sulkta.straw.util.formatDuration @Composable @@ -86,7 +87,10 @@ fun ChannelScreen( Text("error: ${state.error}", color = MaterialTheme.colorScheme.error) } - else -> LazyColumn(modifier = Modifier.fillMaxSize().statusBarsPadding()) { + else -> LazyColumn( + modifier = Modifier.fillMaxSize().statusBarsPadding(), + contentPadding = rememberBottomContentPadding(), + ) { item { state.banner?.let { b -> AsyncImage( diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/DownloadsScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/DownloadsScreen.kt index 6689b0508..5a2f6d2f3 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/DownloadsScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/download/DownloadsScreen.kt @@ -55,6 +55,7 @@ import androidx.compose.ui.platform.LocalContext import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.text.style.TextOverflow import androidx.compose.ui.unit.dp +import com.sulkta.straw.util.rememberBottomContentPadding import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.delay import kotlinx.coroutines.withContext @@ -134,7 +135,7 @@ fun DownloadsScreen() { color = MaterialTheme.colorScheme.onSurfaceVariant, ) } else { - LazyColumn { + LazyColumn(contentPadding = rememberBottomContentPadding()) { items(rows, key = { it.id }) { row -> DownloadRowView(row, context, onRemove = { runCatching { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt index e39194ee0..3cae0426a 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt @@ -55,6 +55,8 @@ import com.sulkta.straw.net.STRAW_USER_AGENT import com.sulkta.straw.net.SponsorBlockClient import com.sulkta.straw.util.runCatchingCancellable import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.Job +import kotlinx.coroutines.flow.collect import kotlinx.coroutines.launch import kotlinx.coroutines.withContext @@ -62,6 +64,7 @@ import kotlinx.coroutines.withContext class PlaybackService : MediaSessionService() { private var mediaSession: MediaSession? = null + private var settingsWatcherJob: Job? = null override fun onCreate() { super.onCreate() @@ -87,6 +90,12 @@ class PlaybackService : MediaSessionService() { .build(), /* handleAudioFocus = */ true, ) + // Honor the user's pause-on-headphone-disconnect preference + // at construction time. The Settings flow is also watched + // below so flipping it mid-session takes effect immediately. + .setHandleAudioBecomingNoisy( + Settings.get().pauseOnHeadphoneDisconnect.value, + ) .build() // Service shutdown is driven by onTaskRemoved (user swiped app away) @@ -109,6 +118,17 @@ class PlaybackService : MediaSessionService() { .setSessionActivity(sessionActivityIntent) .build() + // Watch the pause-on-headphone-disconnect setting so flipping + // it in Settings takes effect on this already-built ExoPlayer + // without requiring a service restart. The initial value was + // baked in via the builder above — this picks up subsequent + // flips. + settingsWatcherJob = StrawApp.globalScope.launch { + Settings.get().pauseOnHeadphoneDisconnect.collect { handle -> + player.setHandleAudioBecomingNoisy(handle) + } + } + // Queue auto-advance bridge: when Media3 transitions to the // next item in the queue, look up the matching NowPlayingItem // (with original streamUrl, uploader, thumbnail, SB segments) @@ -267,6 +287,8 @@ class PlaybackService : MediaSessionService() { } override fun onDestroy() { + settingsWatcherJob?.cancel() + settingsWatcherJob = null // Null the field first so a late onGetSession during teardown gets // null rather than a released session. val s = mediaSession diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt index 1932f1726..9edb2a3ab 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt @@ -38,10 +38,12 @@ import androidx.media3.common.MediaItem import androidx.media3.common.MediaMetadata import androidx.media3.common.MimeTypes import androidx.media3.common.Player +import androidx.media3.common.TrackSelectionParameters import androidx.media3.common.util.UnstableApi import androidx.media3.session.MediaController import androidx.media3.session.SessionToken import com.google.common.util.concurrent.MoreExecutors +import com.sulkta.straw.data.Settings import com.sulkta.straw.feature.detail.ResolvedPlayback val LocalStrawController = compositionLocalOf { null } @@ -104,11 +106,34 @@ fun Player.setPlayingFrom( // long-press-enqueues more items, append/insertAt keep them // synced. Queue.setAll(nowPlayingItem) + // Apply the user's max-resolution cap to DASH/HLS adaptive + // streams. Round-7 audit MED-3 — the cap previously only + // affected the videoOnly/combined picker; DASH manifests + // bypassed it because Media3 picked variants freely. setMaxVideoSize + // tells the ABR algorithm to never pick anything taller than + // ceiling. Auto = Int.MAX_VALUE = no constraint. + applyMaxResolutionCap() setMediaItem(mediaItem, startPositionMs) prepare() playWhenReady = true } +/** + * Push the current Settings.maxResolution into the controller's + * TrackSelectionParameters as a height cap. Idempotent — safe to + * call repeatedly. Called inside setPlayingFrom so every new + * playback respects the live preference; setting changes mid-stream + * apply on next video. + */ +@UnstableApi +fun Player.applyMaxResolutionCap() { + val ceiling = Settings.get().maxResolution.value.ceiling + val maxHeight = if (ceiling >= Int.MAX_VALUE) Int.MAX_VALUE else ceiling + trackSelectionParameters = trackSelectionParameters.buildUpon() + .setMaxVideoSize(Int.MAX_VALUE, maxHeight) + .build() +} + /** * Add a video to the playback queue right after the currently-playing * item. If the player is idle (no current item), fall through to a diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/playlist/PlaylistsScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/playlist/PlaylistsScreen.kt index 44c1ad36f..a512c6565 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/playlist/PlaylistsScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/playlist/PlaylistsScreen.kt @@ -46,6 +46,7 @@ import androidx.compose.ui.text.style.TextOverflow import androidx.compose.ui.unit.dp import coil3.compose.AsyncImage import com.sulkta.straw.data.Playlists +import com.sulkta.straw.util.rememberBottomContentPadding @Composable fun PlaylistsScreen( @@ -87,7 +88,7 @@ fun PlaylistsScreen( color = MaterialTheme.colorScheme.onSurfaceVariant, ) } else { - LazyColumn { + LazyColumn(contentPadding = rememberBottomContentPadding()) { items(playlists, key = { it.id }) { pl -> Row( modifier = Modifier @@ -221,7 +222,7 @@ fun PlaylistViewScreen( color = MaterialTheme.colorScheme.onSurfaceVariant, ) } else { - LazyColumn { + LazyColumn(contentPadding = rememberBottomContentPadding()) { items(playlist.items, key = { it.streamUrl }) { item -> Row( modifier = Modifier diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt index 9dfed4063..c4e23d6a1 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt @@ -54,6 +54,7 @@ import androidx.compose.runtime.remember import androidx.compose.runtime.setValue import com.sulkta.straw.util.formatDuration import com.sulkta.straw.util.formatViews +import com.sulkta.straw.util.rememberBottomContentPadding @Composable fun SearchScreen( @@ -160,7 +161,10 @@ fun SearchScreen( modifier = Modifier.padding(bottom = 4.dp), ) } - LazyColumn(modifier = Modifier.fillMaxSize()) { + LazyColumn( + modifier = Modifier.fillMaxSize(), + contentPadding = rememberBottomContentPadding(), + ) { items(state.results) { item -> ResultRow( item = item, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt index b79b2dd5d..784baa887 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt @@ -278,6 +278,32 @@ fun SettingsScreen() { onCheckedChange = { store.setAutoStartPlayback(it) }, ) } + val pauseOnHeadphones by store.pauseOnHeadphoneDisconnect.collectAsState() + Row( + modifier = Modifier + .fillMaxWidth() + .padding(vertical = 6.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.SpaceBetween, + ) { + Column(modifier = Modifier.weight(1f)) { + Text( + "Pause on headphone disconnect", + style = MaterialTheme.typography.bodyLarge, + fontWeight = FontWeight.SemiBold, + ) + Text( + "Wired pull / Bluetooth drop → pause instead of " + + "switching to the phone speaker.", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + Switch( + checked = pauseOnHeadphones, + onCheckedChange = { store.setPauseOnHeadphoneDisconnect(it) }, + ) + } Spacer(modifier = Modifier.height(32.dp)) Text( diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/util/BottomInsets.kt b/strawApp/src/main/kotlin/com/sulkta/straw/util/BottomInsets.kt new file mode 100644 index 000000000..b814a98a2 --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/util/BottomInsets.kt @@ -0,0 +1,45 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Shared bottom-padding helper for every scrolling screen. + * + * Two things float over the bottom of the activity-level layout and + * need to be cleared: + * 1. The system navigation bar (3-button or gesture). Insets via + * WindowInsets.navigationBars. + * 2. The Straw minibar overlay. Reactive — only present when + * NowPlaying.current is non-null. ~64dp tall + a small gap → + * 72dp reserve. + * + * LazyColumn-based screens plumb this into `contentPadding` so items + * scroll PAST the bottom without being eaten. verticalScroll columns + * append a tail Spacer of the same height. + */ + +package com.sulkta.straw.util + +import androidx.compose.foundation.layout.PaddingValues +import androidx.compose.foundation.layout.WindowInsets +import androidx.compose.foundation.layout.asPaddingValues +import androidx.compose.foundation.layout.navigationBars +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import androidx.compose.ui.unit.Dp +import androidx.compose.ui.unit.dp +import com.sulkta.straw.feature.player.NowPlaying + +/** Combined bottom Dp: nav-bar inset + 72dp when minibar's visible. */ +@Composable +fun rememberBottomBarReserveDp(): Dp { + val navBottom = WindowInsets.navigationBars.asPaddingValues().calculateBottomPadding() + val item by NowPlaying.current.collectAsStateWithLifecycle() + val minibar = if (item != null) 72.dp else 0.dp + return navBottom + minibar +} + +/** Convenience for LazyColumn.contentPadding — adds nothing on the top/start/end. */ +@Composable +fun rememberBottomContentPadding(): PaddingValues = + PaddingValues(bottom = rememberBottomBarReserveDp()) From ebe1fc846472e9ce35b59bcdc4096bc3973ea307 Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 08:43:06 -0700 Subject: [PATCH 44/72] vc=52: R8 enabled + surface-handoff polish MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit R8 (minify + resource-shrink) flipped on for BOTH debug AND release variants — we publish the debug APK to fdroid (per existing pipeline), and the audit-flagged Log.d strip discipline required R8 to actually run on the variant we ship. New strawApp/proguard-rules.pro covers: * UniFFI bindings (uniffi.strawcore.*) — reflective FFI dispatch from Rust side, must survive minification * JNA — Library subclasses reflectively loaded by name * kotlinx-serialization @Serializable — generated $$serializer companions, kept via both the package-anchored rule and the annotation-wildcard rule for belt + suspenders * Media3 session Parcelables (cross-process via Binder) * Compose runtime + Strawcore exception hierarchy Surface-handoff polish on inline ↔ fullscreen transitions: setKeepContentOnPlayerReset(true) on both PlayerViews (inline in VideoDetail + fullscreen Player). When the detaching view's player is nulled on dispose, it holds the last rendered frame instead of flashing black. The receiving view's surface takeover then renders the next frame without the ~1-frame black gap. Round-4 audit HIGH-5 was the closest writeup. Expected APK-size win from R8: ~30-40%. Need real-device verification post-install — the keep rules are best-effort and a missing rule manifests as runtime ClassNotFoundException or silently-broken kotlinx-serialization decoding. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- strawApp/build.gradle.kts | 19 ++++- strawApp/proguard-rules.pro | 81 +++++++++++++++++++ .../straw/feature/detail/VideoDetailScreen.kt | 6 ++ .../straw/feature/player/PlayerScreen.kt | 8 ++ 5 files changed, 115 insertions(+), 3 deletions(-) create mode 100644 strawApp/proguard-rules.pro diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 73ed00783..9eff49449 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 51 -const val STRAW_VERSION_NAME = "0.1.0-BK" +const val STRAW_VERSION_CODE = 52 +const val STRAW_VERSION_NAME = "0.1.0-BL" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/build.gradle.kts b/strawApp/build.gradle.kts index bb98352e7..b62f16540 100644 --- a/strawApp/build.gradle.kts +++ b/strawApp/build.gradle.kts @@ -39,13 +39,30 @@ configure { } buildTypes { + // R8 enabled on BOTH variants — we publish the debug APK to + // fdroid (com.sulkta.straw.debug) per the existing pipeline, + // and audit-flagged Log.d strips depended on R8 actually + // running on the variant we ship. Keep rules in + // strawApp/proguard-rules.pro cover UniFFI + JNA + + // kotlinx-serialization companions. debug { isDebuggable = true applicationIdSuffix = ".debug" resValue("string", "app_name", "Straw debug") + isMinifyEnabled = true + isShrinkResources = true + proguardFiles( + getDefaultProguardFile("proguard-android-optimize.txt"), + "proguard-rules.pro", + ) } release { - isMinifyEnabled = false + isMinifyEnabled = true + isShrinkResources = true + proguardFiles( + getDefaultProguardFile("proguard-android-optimize.txt"), + "proguard-rules.pro", + ) } } diff --git a/strawApp/proguard-rules.pro b/strawApp/proguard-rules.pro new file mode 100644 index 000000000..2a81fe15c --- /dev/null +++ b/strawApp/proguard-rules.pro @@ -0,0 +1,81 @@ +# SPDX-FileCopyrightText: 2026 Sulkta-Coop +# SPDX-License-Identifier: GPL-3.0-or-later +# +# R8 keep rules for the Straw app module. The legacy `app/proguard-rules.pro` +# is for the upstream NewPipe module — different namespaces, different +# rules. This file is OURS. +# +# AGP's getDefaultProguardFile("proguard-android-optimize.txt") handles +# the Android framework + AndroidX + Compose runtime defaults via +# consumer rules shipped with each library. We only need to spell out +# what those defaults can't see: +# +# * UniFFI bindings — reflective FFI dispatch from generated code. +# * JNA — reflects on every class extending com.sun.jna.Library +# (that's how the loadLibrary glue works). +# * Our kotlinx-serialization @Serializable types — their generated +# $$serializer companions get tree-shaken without explicit keeps. +# * Media3 session metadata Parcelables. + +# -- UniFFI ------------------------------------------------------------- +# Generated bindings live under uniffi.strawcore.*. The Rust side calls +# them via JNI symbol name; if R8 renames the class or methods, every +# extractor call NPEs. +-keep class uniffi.strawcore.** { *; } +-keep class uniffi.** { *; } + +# -- JNA --------------------------------------------------------------- +# JNA looks up Library subclasses by Class.forName + reflection at +# load time. Anything that extends Library or has @FieldOrder must +# survive. +-keep class * extends com.sun.jna.Library { *; } +-keep class com.sun.jna.** { *; } +-dontwarn com.sun.jna.** + +# -- kotlinx-serialization --------------------------------------------- +# Every @Serializable type gets a synthetic Companion + $$serializer +# class. R8 will strip the $$serializer if nothing visibly calls it +# (the lookup goes through reflection on the Companion). +-keepattributes *Annotation*, InnerClasses +-dontwarn kotlinx.serialization.** + +-keep,includedescriptorclasses class com.sulkta.straw.**$$serializer { *; } +-keepclassmembers class com.sulkta.straw.** { + *** Companion; +} +-keepclasseswithmembers class com.sulkta.straw.** { + kotlinx.serialization.KSerializer serializer(...); +} + +# Same dance for our top-level @Serializable types defined outside +# `com.sulkta.straw.**` (Rust DTOs, etc.). Belt + suspenders. +-keepclassmembers @kotlinx.serialization.Serializable class * { + static **$Companion Companion; + public static <1>$Companion Companion; +} +-keepclasseswithmembers @kotlinx.serialization.Serializable class * { + kotlinx.serialization.KSerializer serializer(...); +} +-keep class **$$serializer { *; } + +# -- Media3 / ExoPlayer ------------------------------------------------ +# Most of Media3 ships consumer rules but session-related Parcelables +# are reflectively reconstructed across process boundaries (the +# MediaController talks to PlaybackService via Binder). Keep their +# field names. +-keep class androidx.media3.session.** { *; } +-keep class androidx.media3.common.MediaItem { *; } +-keep class androidx.media3.common.MediaItem$* { *; } +-keep class androidx.media3.common.MediaMetadata { *; } + +# -- Strawcore exceptions / DTOs reflected by UniFFI -------------------- +# StrawcoreError is a sealed Throwable hierarchy exposed via UniFFI. +# Keep all subclasses + their fields so the Kotlin pattern-match works +# after minification. +-keep class com.sulkta.straw.feature.player.** { *; } + +# -- Reflection-via-Class.forName paths from Compose -------------------- +# Compose's runtime does some Class.forName for its own bootstrap; the +# AGP consumer rules cover this, but documenting the dependency here +# so a future bump doesn't surprise us. +-keep class androidx.compose.runtime.** { *; } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index 3dd48fb88..04d79017d 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -799,6 +799,12 @@ private fun InlinePlayer( PlayerView(ctx).apply { player = controller useController = true + // Same surface-handoff polish as the + // fullscreen PlayerView — hold the last + // frame on dispose so the inline ↔ + // fullscreen transition doesn't flash + // black between detach + reattach. + setKeepContentOnPlayerReset(true) } }, update = { it.player = controller }, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt index fb466eebc..02479cf99 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt @@ -178,6 +178,14 @@ fun PlayerScreen( PlayerView(ctx).apply { player = controller useController = true + // Keep the last frame on screen when this + // view's player is reset (fullscreen → + // inline transition). Without this, the + // detaching PlayerView flashes black for + // ~1 frame before the receiving view takes + // over the surface. + controllerHideOnTouch = true + setKeepContentOnPlayerReset(true) } }, update = { it.player = controller }, From e26a3eca19273f972539f2ad8e3ed6c30c4ddaae Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 09:04:50 -0700 Subject: [PATCH 45/72] vc=53: scrub-point store + auto-resume on video open MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ResumePositionsStore — SharedPreferences-lite, JSON-blob keyed by videoId. Caps at 500 entries, prunes oldest on add. Skips trivial positions (< 5s) and clears near-end (within 5s of duration) so a finished video doesn't auto-resume to its credits. PlaybackService — 5s polling job + onIsPlayingChanged(false) + onDestroy capture write player position via NowPlaying.streamUrl → videoId. Runs on Main so the player read is thread-safe; store write is SP.apply() async. setPlayingFrom — when caller passes startPositionMs=0L AND Settings.autoResume is on, lookup the saved position and use it. Surface-handoff path (inline ↔ fullscreen) is untouched — MediaController already holds its own position across surfaces. This only fires on fresh opens (cold start, app update, video re-tap from history). --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- .../main/kotlin/com/sulkta/straw/StrawApp.kt | 2 + .../sulkta/straw/data/ResumePositionsStore.kt | 146 ++++++++++++++++++ .../com/sulkta/straw/data/SettingsStore.kt | 20 +++ .../straw/feature/player/PlaybackService.kt | 48 ++++++ .../feature/player/StrawMediaController.kt | 16 +- .../straw/feature/settings/SettingsScreen.kt | 26 ++++ 7 files changed, 259 insertions(+), 3 deletions(-) create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/data/ResumePositionsStore.kt diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 9eff49449..3bd5dd502 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 52 -const val STRAW_VERSION_NAME = "0.1.0-BL" +const val STRAW_VERSION_CODE = 53 +const val STRAW_VERSION_NAME = "0.1.0-BM" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt index 2868d58ac..58d75fa9f 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt @@ -9,6 +9,7 @@ import android.app.Application import com.sulkta.straw.data.FeedCache import com.sulkta.straw.data.History import com.sulkta.straw.data.Playlists +import com.sulkta.straw.data.Resume import com.sulkta.straw.data.SearchCache import com.sulkta.straw.data.Settings import com.sulkta.straw.data.Subscriptions @@ -67,6 +68,7 @@ class StrawApp : Application() { History.init(this) Subscriptions.init(this) Playlists.init(this) + Resume.init(this) // vc=36 audit HIGH-R3: FeedCache (~225 KB) + SearchCache // (~150 KB) JSON-decode at construction. Stash the // applicationContext eagerly (cheap) so `get()` is callable diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/ResumePositionsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/ResumePositionsStore.kt new file mode 100644 index 000000000..3b4fa5f57 --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/ResumePositionsStore.kt @@ -0,0 +1,146 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Per-video scrub-point store. App update / process death / device + * reboot — all three would otherwise lose the user's place in a long + * video. We write position every ~5s while playing + on every pause + + * on player teardown, keyed by videoId so resume works across stream + * URL rotations (googlevideo URLs rotate per session). + * + * SharedPreferences-lite, single JSON blob, capped at MAX_RESUMES with + * oldest-eviction. Same shape as HistoryStore — graduates to Room if a + * real query pattern shows up. + */ + +package com.sulkta.straw.data + +import android.content.Context +import android.content.SharedPreferences +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.updateAndGet +import kotlinx.serialization.Serializable +import kotlinx.serialization.json.Json + +@Serializable +data class ResumePosition( + val positionMs: Long, + val durationMs: Long, + val lastWatchedAt: Long, +) + +private const val PREFS = "straw_resume_positions" +private const val KEY_POSITIONS = "positions_v1" + +/** Cap on retained per-video resume entries — prune oldest on overflow. */ +private const val MAX_RESUMES = 500 + +/** + * Skip writes for trivial positions — auto-resuming from 0:03 is more + * annoying than starting fresh. Mirrors YouTube's "near the start" + * threshold. + */ +private const val MIN_POSITION_MS = 5_000L + +/** + * When position is within END_THRESHOLD of duration, treat the video as + * "done" and clear the entry instead of recording. Otherwise a finished + * watch would auto-resume to the credits next time. + */ +private const val END_THRESHOLD_MS = 5_000L + +class ResumePositionsStore(context: Context) { + private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) + private val json = Json { ignoreUnknownKeys = true } + + private val _positions = MutableStateFlow(load()) + val positions: StateFlow> = _positions.asStateFlow() + + /** + * Record (or update) the scrub-point for a video. Skipped silently + * when: + * - videoId is blank + * - durationMs <= 0 (live stream / unknown) + * - positionMs is below MIN_POSITION_MS (just started) + * + * When positionMs is within END_THRESHOLD_MS of the end the entry is + * REMOVED so a finished video doesn't auto-resume to its credits. + */ + fun record(videoId: String, positionMs: Long, durationMs: Long) { + if (videoId.isBlank()) return + if (durationMs <= 0L) return + if (positionMs < MIN_POSITION_MS) return + if (positionMs >= durationMs - END_THRESHOLD_MS) { + clearOne(videoId) + return + } + val entry = ResumePosition( + positionMs = positionMs, + durationMs = durationMs, + lastWatchedAt = System.currentTimeMillis(), + ) + val before = _positions.value + val next = _positions.updateAndGet { current -> + val withEntry = current + (videoId to entry) + if (withEntry.size > MAX_RESUMES) { + // Drop oldest by lastWatchedAt — newcomers always land + // because the entry we just added is by definition the + // freshest. take(MAX_RESUMES) of the sorted-desc list. + withEntry.entries + .sortedByDescending { it.value.lastWatchedAt } + .take(MAX_RESUMES) + .associate { it.key to it.value } + } else { + withEntry + } + } + if (next !== before) { + sp.edit().putString(KEY_POSITIONS, json.encodeToString(next)).apply() + } + } + + /** Returns null when the video has no recorded position. */ + fun get(videoId: String): ResumePosition? { + if (videoId.isBlank()) return null + return _positions.value[videoId] + } + + fun clearOne(videoId: String) { + if (videoId.isBlank()) return + val before = _positions.value + val next = _positions.updateAndGet { current -> + if (videoId !in current) current else current - videoId + } + if (next !== before) { + sp.edit().putString(KEY_POSITIONS, json.encodeToString(next)).apply() + } + } + + fun clearAll() { + _positions.updateAndGet { emptyMap() } + sp.edit().putString(KEY_POSITIONS, json.encodeToString(emptyMap())).apply() + } + + private fun load(): Map = runCatching { + val s = sp.getString(KEY_POSITIONS, null) ?: return emptyMap() + json.decodeFromString>(s) + }.getOrDefault(emptyMap()) +} + +/** App-wide singleton; created in StrawApp.onCreate. */ +object Resume { + @Volatile private var instance: ResumePositionsStore? = null + + fun init(context: Context) { + if (instance == null) { + synchronized(this) { + if (instance == null) instance = ResumePositionsStore(context.applicationContext) + } + } + } + + fun get(): ResumePositionsStore = instance + ?: error("ResumePositionsStore not initialized — call Resume.init(context)") +} diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt index 05dbafae9..7ccab0543 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt @@ -67,6 +67,7 @@ private const val KEY_AUTOPLAY_MODE = "autoplay_mode_v1" private const val KEY_AUTOPLAY_SKIP_WATCHED = "autoplay_skip_watched_v1" private const val KEY_AUTOSTART_PLAYBACK = "autostart_playback_v1" private const val KEY_PAUSE_ON_HEADPHONE_DISCONNECT = "pause_on_headphone_disconnect_v1" +private const val KEY_AUTO_RESUME = "auto_resume_v1" class SettingsStore(context: Context) { private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) @@ -116,6 +117,18 @@ class SettingsStore(context: Context) { ) val pauseOnHeadphoneDisconnect: StateFlow = _pauseOnHeadphoneDisconnect.asStateFlow() + /** + * Auto-resume scrub-point on video open. When on (default), opening + * a video that has a saved position picks up where the user left + * off. When off, every open starts at 0:00. Doesn't affect inline- + * ↔ fullscreen hand-off (the shared MediaController keeps its own + * position across surfaces; this only matters on fresh opens). + */ + private val _autoResume = MutableStateFlow( + sp.getBoolean(KEY_AUTO_RESUME, true), + ) + val autoResume: StateFlow = _autoResume.asStateFlow() + fun toggle(cat: SbCategory) { // Atomic toggle via updateAndGet — see AUD-HIGH note in HistoryStore. val next = _sbCategories.updateAndGet { cur -> @@ -178,6 +191,13 @@ class SettingsStore(context: Context) { sp.edit().putBoolean(KEY_PAUSE_ON_HEADPHONE_DISCONNECT, pause).apply() } + fun setAutoResume(enabled: Boolean) { + val before = _autoResume.value + if (before == enabled) return + _autoResume.value = enabled + sp.edit().putBoolean(KEY_AUTO_RESUME, enabled).apply() + } + private fun loadCategories(): Set { val raw = sp.getStringSet(KEY_SB_CATS, null) return if (raw == null) { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt index 3cae0426a..692aebd04 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt @@ -48,6 +48,7 @@ import com.sulkta.straw.StrawActivity import com.sulkta.straw.StrawApp import com.sulkta.straw.data.AutoplayMode import com.sulkta.straw.data.History +import com.sulkta.straw.data.Resume import com.sulkta.straw.data.Settings import com.sulkta.straw.feature.detail.resolveStreamPlayback import com.sulkta.straw.net.IosSafeHttpDataSource @@ -56,7 +57,9 @@ import com.sulkta.straw.net.SponsorBlockClient import com.sulkta.straw.util.runCatchingCancellable import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.Job +import kotlinx.coroutines.delay import kotlinx.coroutines.flow.collect +import kotlinx.coroutines.isActive import kotlinx.coroutines.launch import kotlinx.coroutines.withContext @@ -65,6 +68,7 @@ class PlaybackService : MediaSessionService() { private var mediaSession: MediaSession? = null private var settingsWatcherJob: Job? = null + private var resumePollJob: Job? = null override fun onCreate() { super.onCreate() @@ -162,6 +166,13 @@ class PlaybackService : MediaSessionService() { } } + override fun onIsPlayingChanged(isPlaying: Boolean) { + // Capture on every play→pause edge. Covers user taps, + // audio focus loss, headphone-noisy pause. The 5s poll + // covers the play-through case. + if (!isPlaying) captureResumePosition(player) + } + override fun onPlaybackStateChanged(state: Int) { if (state != Player.STATE_ENDED) return val mode = Settings.get().autoplayMode.value @@ -176,6 +187,34 @@ class PlaybackService : MediaSessionService() { tryAutoplay(mode) } }) + + // Periodic scrub-point write. Stays on Main so player reads are + // thread-safe; the SP write inside record() is async (apply()). + // 5s cadence is the sweet spot — finer is wasted disk churn, + // coarser loses too much on a sudden process death. + resumePollJob = StrawApp.globalScope.launch(Dispatchers.Main) { + while (isActive) { + delay(RESUME_POLL_INTERVAL_MS) + captureResumePosition(player) + } + } + } + + /** + * Read the current player position and persist it to the + * ResumePositionsStore. Bails on idle/ended states and unknown + * durations (live streams). The store itself enforces minimum- + * position + near-end-clear thresholds. + */ + private fun captureResumePosition(player: Player) { + val state = player.playbackState + if (state == Player.STATE_IDLE || state == Player.STATE_ENDED) return + val item = NowPlaying.current.value ?: return + val videoId = com.sulkta.straw.feature.detail.extractYtVideoId(item.streamUrl) ?: return + val pos = player.currentPosition + val dur = player.duration + if (dur <= 0L) return + Resume.get().record(videoId, pos, dur) } private fun fetchSbForQueued(item: NowPlayingItem, videoId: String) { @@ -287,6 +326,12 @@ class PlaybackService : MediaSessionService() { } override fun onDestroy() { + // Final scrub-point snapshot before teardown — covers swipe- + // away-without-pause case. Read before cancelling the poll + // job (the job's last tick may not have landed yet). + mediaSession?.player?.let { captureResumePosition(it) } + resumePollJob?.cancel() + resumePollJob = null settingsWatcherJob?.cancel() settingsWatcherJob = null // Null the field first so a late onGetSession during teardown gets @@ -307,6 +352,9 @@ class PlaybackService : MediaSessionService() { * MediaItem's video URI to produce a combined video+audio source. */ const val EXTRA_AUDIO_URL = "straw.audio_url" + + /** Scrub-point write cadence while the player is alive. */ + private const val RESUME_POLL_INTERVAL_MS = 5_000L } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt index 9edb2a3ab..923dcd095 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt @@ -43,8 +43,10 @@ import androidx.media3.common.util.UnstableApi import androidx.media3.session.MediaController import androidx.media3.session.SessionToken import com.google.common.util.concurrent.MoreExecutors +import com.sulkta.straw.data.Resume import com.sulkta.straw.data.Settings import com.sulkta.straw.feature.detail.ResolvedPlayback +import com.sulkta.straw.feature.detail.extractYtVideoId val LocalStrawController = compositionLocalOf { null } @@ -113,7 +115,19 @@ fun Player.setPlayingFrom( // tells the ABR algorithm to never pick anything taller than // ceiling. Auto = Int.MAX_VALUE = no constraint. applyMaxResolutionCap() - setMediaItem(mediaItem, startPositionMs) + // Auto-resume: when the caller passed the default 0L and + // Settings.autoResume is on, look up the saved scrub-point for + // this videoId. Lets the user pick up where they left off after + // an app update / process death. The store skips trivial + // positions and clears near-end so we don't auto-resume to 0:03 + // or to the credits. + val effectiveStart = if (startPositionMs == 0L && Settings.get().autoResume.value) { + val videoId = extractYtVideoId(streamUrl) + videoId?.let { Resume.get().get(it)?.positionMs } ?: 0L + } else { + startPositionMs + } + setMediaItem(mediaItem, effectiveStart) prepare() playWhenReady = true } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt index 784baa887..c8a11962a 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt @@ -304,6 +304,32 @@ fun SettingsScreen() { onCheckedChange = { store.setPauseOnHeadphoneDisconnect(it) }, ) } + val autoResume by store.autoResume.collectAsState() + Row( + modifier = Modifier + .fillMaxWidth() + .padding(vertical = 6.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.SpaceBetween, + ) { + Column(modifier = Modifier.weight(1f)) { + Text( + "Resume where you left off", + style = MaterialTheme.typography.bodyLarge, + fontWeight = FontWeight.SemiBold, + ) + Text( + "Reopen a video → pick up at the saved scrub-point. " + + "Off: every open starts at 0:00.", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + Switch( + checked = autoResume, + onCheckedChange = { store.setAutoResume(it) }, + ) + } Spacer(modifier = Modifier.height(32.dp)) Text( From 080346716b736df5a0434d7fd1a621b0797290ed Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 09:09:07 -0700 Subject: [PATCH 46/72] fixup vc=53: keep screen on while fullscreen + inline player attached MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Cobb hit screen-timeout-while-watching mid-build. View-level keepScreenOn=true on both PlayerViews — propagates to the window while the view is attached, releases the wake-lock automatically when the user backs out. Same pattern Media3 recommends for video apps. --- .../com/sulkta/straw/feature/detail/VideoDetailScreen.kt | 5 +++++ .../com/sulkta/straw/feature/player/PlayerScreen.kt | 8 ++++++++ 2 files changed, 13 insertions(+) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index 04d79017d..6ae432336 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -805,6 +805,11 @@ private fun InlinePlayer( // fullscreen transition doesn't flash // black between detach + reattach. setKeepContentOnPlayerReset(true) + // Don't let the device timeout while the + // inline player is on-screen with the + // user reading the description. Detaches + // automatically when this view goes away. + keepScreenOn = true } }, update = { it.player = controller }, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt index 02479cf99..e7b763148 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlayerScreen.kt @@ -186,6 +186,14 @@ fun PlayerScreen( // over the surface. controllerHideOnTouch = true setKeepContentOnPlayerReset(true) + // Don't let the device timeout/lock while + // a fullscreen video is on-screen. View- + // level flag — propagates to the window + // while attached, clears on detach so + // backing out of fullscreen releases the + // wake-lock automatically. Mirror on the + // inline PlayerView for consistency. + keepScreenOn = true } }, update = { it.player = controller }, From fbccdce65a11f8b33079a6148302ea5670a20919 Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 09:28:04 -0700 Subject: [PATCH 47/72] vc=54: red progress-bar overlay on video thumbnails MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit YT/NewPipe-style — when ResumePositionsStore has an entry for a video, paint a 3dp red bar across the bottom of the thumbnail showing position/duration. Reads instantly as "you started this." Consolidated the duplicate thumbnail render logic across 6 row sites (FeedRow, RecentRow, ResultRow, ChannelVideoRow, RelatedRow, PlaylistsScreen) into a single feature/player/VideoThumbnail composable. Includes the existing duration-pill overlay + the new progress bar. ThumbnailProgressOverlay is a BoxScope extension so custom thumbnail compositions can drop it in without going through the full helper. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- .../main/kotlin/com/sulkta/straw/StrawHome.kt | 51 ++------ .../kotlin/com/sulkta/straw/StrawTheme.kt | 6 + .../straw/feature/channel/ChannelScreen.kt | 11 +- .../straw/feature/detail/VideoDetailScreen.kt | 11 +- .../straw/feature/player/ThumbnailProgress.kt | 113 ++++++++++++++++++ .../straw/feature/playlist/PlaylistsScreen.kt | 11 +- .../straw/feature/search/SearchScreen.kt | 11 +- 8 files changed, 153 insertions(+), 65 deletions(-) create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/feature/player/ThumbnailProgress.kt diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 3bd5dd502..e3e0e57f4 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 53 -const val STRAW_VERSION_NAME = "0.1.0-BM" +const val STRAW_VERSION_CODE = 54 +const val STRAW_VERSION_NAME = "0.1.0-BN" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt index 251fcceda..7510d452b 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt @@ -80,12 +80,11 @@ import com.sulkta.straw.data.History import com.sulkta.straw.data.Subscriptions import com.sulkta.straw.data.WatchHistoryItem import com.sulkta.straw.feature.feed.SubscriptionFeedViewModel +import com.sulkta.straw.feature.player.VideoThumbnail import com.sulkta.straw.feature.playlist.VideoActionTarget import com.sulkta.straw.feature.playlist.VideoActionsSheet import com.sulkta.straw.feature.search.StreamItem import com.sulkta.straw.util.rememberBottomContentPadding -import com.sulkta.straw.OverlayDimColor -import com.sulkta.straw.util.formatDuration import com.sulkta.straw.util.formatViews import kotlinx.coroutines.launch @@ -508,8 +507,9 @@ private fun FeedRow( .padding(vertical = 8.dp), verticalAlignment = Alignment.Top, ) { - ThumbnailWithDuration( + VideoThumbnail( thumbnail = item.thumbnail, + videoUrl = item.url, durationSeconds = item.durationSeconds, modifier = Modifier .width(140.dp) @@ -546,41 +546,6 @@ private fun FeedRow( } } -/** - * 16:9 thumbnail with a NewPipe-style duration pill burned into the - * bottom-right corner. `durationSeconds == 0` skips the badge (live - * streams, mixes that come back without a duration, etc.). - */ -@Composable -private fun ThumbnailWithDuration( - thumbnail: String?, - durationSeconds: Long, - modifier: Modifier = Modifier, -) { - Box(modifier = modifier) { - AsyncImage( - model = thumbnail, - contentDescription = null, - modifier = Modifier - .fillMaxSize() - .clip(RoundedCornerShape(6.dp)), - ) - if (durationSeconds > 0) { - Text( - text = formatDuration(durationSeconds), - style = MaterialTheme.typography.labelSmall, - color = androidx.compose.ui.graphics.Color.White, - modifier = Modifier - .align(Alignment.BottomEnd) - .padding(4.dp) - .clip(RoundedCornerShape(3.dp)) - .background(OverlayDimColor) - .padding(horizontal = 4.dp, vertical = 1.dp), - ) - } - } -} - @Composable private fun SubChip( ch: ChannelRef, @@ -643,13 +608,13 @@ private fun RecentRow( .padding(vertical = 8.dp), verticalAlignment = Alignment.CenterVertically, ) { - AsyncImage( - model = item.thumbnail, - contentDescription = null, + VideoThumbnail( + thumbnail = item.thumbnail, + videoUrl = item.url, + durationSeconds = 0L, modifier = Modifier .width(120.dp) - .height(68.dp) - .clip(RoundedCornerShape(6.dp)), + .height(68.dp), ) Spacer(modifier = Modifier.width(12.dp)) Column(modifier = Modifier.weight(1f)) { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawTheme.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawTheme.kt index ebbacd377..85fa21b09 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawTheme.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawTheme.kt @@ -82,3 +82,9 @@ fun strawDarkColors(): ColorScheme = darkColorScheme( // minibar thumbnail. Kept here so a theme tweak touches one place. val OverlayChromeColor = Color(0xCC222222) val OverlayDimColor = Color(0xCC000000) + +// Watch-progress bar painted across the bottom of a video thumbnail when +// the user has a saved scrub-point. Solid red foreground over a slightly- +// dim track. Matches YT / NewPipe conventions so it reads instantly. +val ProgressBarFillColor = Color(0xFFE53935) +val ProgressBarTrackColor = Color(0x66000000) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt index 6333612d4..6ecd48a08 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt @@ -49,6 +49,7 @@ import androidx.compose.runtime.setValue import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.lifecycle.viewmodel.compose.viewModel import coil3.compose.AsyncImage +import com.sulkta.straw.feature.player.VideoThumbnail import com.sulkta.straw.data.ChannelRef import com.sulkta.straw.data.Subscriptions import com.sulkta.straw.feature.playlist.VideoActionTarget @@ -177,13 +178,13 @@ private fun ChannelVideoRow( .padding(horizontal = 16.dp, vertical = 10.dp), verticalAlignment = Alignment.Top, ) { - AsyncImage( - model = item.thumbnail, - contentDescription = null, + VideoThumbnail( + thumbnail = item.thumbnail, + videoUrl = item.url, + durationSeconds = item.durationSeconds, modifier = Modifier .width(140.dp) - .height(80.dp) - .clip(RoundedCornerShape(6.dp)), + .height(80.dp), ) Spacer(modifier = Modifier.width(12.dp)) Column(modifier = Modifier.weight(1f)) { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index 6ae432336..e10c841f9 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -99,6 +99,7 @@ import com.sulkta.straw.feature.download.DownloadKind import com.sulkta.straw.feature.download.Downloader import com.sulkta.straw.feature.player.LocalStrawController import com.sulkta.straw.feature.player.NowPlaying +import com.sulkta.straw.feature.player.VideoThumbnail import com.sulkta.straw.feature.player.setPlayingFrom import com.sulkta.straw.feature.search.StreamItem import com.sulkta.straw.util.LogDump @@ -680,13 +681,13 @@ private fun RelatedRow( .padding(vertical = 8.dp), verticalAlignment = Alignment.Top, ) { - AsyncImage( - model = item.thumbnail, - contentDescription = null, + VideoThumbnail( + thumbnail = item.thumbnail, + videoUrl = item.url, + durationSeconds = item.durationSeconds, modifier = Modifier .width(140.dp) - .height(80.dp) - .clip(RoundedCornerShape(6.dp)), + .height(80.dp), ) Spacer(modifier = Modifier.width(10.dp)) Column(modifier = Modifier.weight(1f)) { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/ThumbnailProgress.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/ThumbnailProgress.kt new file mode 100644 index 000000000..bc4bd4e4f --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/ThumbnailProgress.kt @@ -0,0 +1,113 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Red progress bar painted across the bottom of a video thumbnail when + * the user has a saved scrub-point in ResumePositionsStore. Same shape + * YouTube + NewPipe use — instantly readable as "you started this." + * + * Drops into any thumbnail-rendering Box; the caller is responsible for + * being inside a Box (so we can align to Bottom). Returns nothing when + * the videoId is blank or has no recorded position. + */ + +package com.sulkta.straw.feature.player + +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.BoxScope +import androidx.compose.foundation.layout.fillMaxHeight +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.height +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.Text +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.unit.dp +import androidx.lifecycle.compose.collectAsStateWithLifecycle +import coil3.compose.AsyncImage +import com.sulkta.straw.OverlayDimColor +import com.sulkta.straw.ProgressBarFillColor +import com.sulkta.straw.ProgressBarTrackColor +import com.sulkta.straw.data.Resume +import com.sulkta.straw.feature.detail.extractYtVideoId +import com.sulkta.straw.util.formatDuration + +/** + * Paint a 3dp watch-progress bar across the bottom of the surrounding + * Box when ResumePositionsStore has an entry for [videoId]. Silent + * no-op when there's no entry — safe to call unconditionally. + * + * Must be used inside a Box (uses BoxScope.align). Caller's Box sets + * the thumbnail size; this composable just overlays the bar. + */ +@Composable +fun BoxScope.ThumbnailProgressOverlay(videoId: String?) { + if (videoId.isNullOrBlank()) return + val positions by Resume.get().positions.collectAsStateWithLifecycle() + val entry = positions[videoId] ?: return + if (entry.durationMs <= 0L) return + val fraction = (entry.positionMs.toFloat() / entry.durationMs.toFloat()) + .coerceIn(0f, 1f) + Box( + modifier = Modifier + .align(Alignment.BottomStart) + .fillMaxWidth() + .height(3.dp) + .background(ProgressBarTrackColor), + ) { + Box( + modifier = Modifier + .fillMaxHeight() + .fillMaxWidth(fraction) + .background(ProgressBarFillColor), + ) + } +} + +/** + * One-stop video thumbnail: 16:9 image with optional NewPipe-style + * duration pill at bottom-right + watch-progress overlay at bottom + * when the user has a saved scrub-point for [videoUrl]. + * + * Pass an outer modifier with the desired width/height; the corner + * radius + clip are applied inside so the progress bar bleeds to the + * exact edge of the rounded thumbnail. durationSeconds <= 0 drops the + * badge (live streams, items that come back without a duration). + */ +@Composable +fun VideoThumbnail( + thumbnail: String?, + videoUrl: String?, + durationSeconds: Long, + modifier: Modifier = Modifier, +) { + Box(modifier = modifier.clip(RoundedCornerShape(6.dp))) { + AsyncImage( + model = thumbnail, + contentDescription = null, + modifier = Modifier.fillMaxSize(), + ) + if (durationSeconds > 0) { + Text( + text = formatDuration(durationSeconds), + style = MaterialTheme.typography.labelSmall, + color = Color.White, + modifier = Modifier + .align(Alignment.BottomEnd) + .padding(4.dp) + .clip(RoundedCornerShape(3.dp)) + .background(OverlayDimColor) + .padding(horizontal = 4.dp, vertical = 1.dp), + ) + } + ThumbnailProgressOverlay(videoUrl?.let { extractYtVideoId(it) }) + } +} diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/playlist/PlaylistsScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/playlist/PlaylistsScreen.kt index a512c6565..2a11d694a 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/playlist/PlaylistsScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/playlist/PlaylistsScreen.kt @@ -45,6 +45,7 @@ import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.text.style.TextOverflow import androidx.compose.ui.unit.dp import coil3.compose.AsyncImage +import com.sulkta.straw.feature.player.VideoThumbnail import com.sulkta.straw.data.Playlists import com.sulkta.straw.util.rememberBottomContentPadding @@ -231,13 +232,13 @@ fun PlaylistViewScreen( .padding(vertical = 8.dp), verticalAlignment = Alignment.Top, ) { - AsyncImage( - model = item.thumbnail, - contentDescription = null, + VideoThumbnail( + thumbnail = item.thumbnail, + videoUrl = item.streamUrl, + durationSeconds = 0L, modifier = Modifier .width(140.dp) - .height(80.dp) - .clip(RoundedCornerShape(6.dp)), + .height(80.dp), ) Spacer(modifier = Modifier.width(10.dp)) Column(modifier = Modifier.weight(1f)) { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt index c4e23d6a1..06075d32d 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt @@ -45,6 +45,7 @@ import androidx.compose.runtime.collectAsState import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.lifecycle.viewmodel.compose.viewModel import coil3.compose.AsyncImage +import com.sulkta.straw.feature.player.VideoThumbnail import com.sulkta.straw.data.History import com.sulkta.straw.feature.playlist.VideoActionTarget import com.sulkta.straw.feature.playlist.VideoActionsSheet @@ -202,13 +203,13 @@ private fun ResultRow( .padding(vertical = 10.dp), verticalAlignment = Alignment.Top, ) { - AsyncImage( - model = item.thumbnail, - contentDescription = null, + VideoThumbnail( + thumbnail = item.thumbnail, + videoUrl = item.url, + durationSeconds = item.durationSeconds, modifier = Modifier .width(160.dp) - .height(90.dp) - .clip(RoundedCornerShape(6.dp)), + .height(90.dp), ) Spacer(modifier = Modifier.width(12.dp)) Column(modifier = Modifier.weight(1f)) { From ccd24c4ed37fb89446c3b627a907d8738e14e803 Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 09:40:07 -0700 Subject: [PATCH 48/72] vc=55: in-app auto-updater polling fdroid.sulkta.com MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit WorkManager periodic worker hits the repo's index-v2.json, parses the highest versionCode for our package, compares with BuildConfig.VERSION_CODE. When newer: posts a notification with ACTION_VIEW on the APK URL — Android's DownloadManager picks it up and the system installer takes over. No INSTALL_PACKAGES perm needed. Settings: - Check for updates toggle (default on — closing NewPipe's silent staleness gap is the explicit motivation) - Interval picker (1h / 6h / 24h, default 6h — WorkManager has a 15-min periodic floor anyway) - Last-checked timestamp + 'update available' tag when caught-up state is dirty - Check now button — runs the same path as the worker so behaviors stay identical Cold start fires one check too so users see pending updates without waiting a full interval. R8 keep-rule for UpdateCheckWorker added — WorkManager instantiates workers by name via reflection. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- strawApp/build.gradle.kts | 5 + strawApp/proguard-rules.pro | 8 ++ .../main/kotlin/com/sulkta/straw/StrawApp.kt | 9 ++ .../com/sulkta/straw/data/SettingsStore.kt | 85 ++++++++++++++ .../straw/feature/settings/SettingsScreen.kt | 111 ++++++++++++++++++ .../straw/feature/update/AppUpdateClient.kt | 86 ++++++++++++++ .../straw/feature/update/UpdateCheckWorker.kt | 108 +++++++++++++++++ .../straw/feature/update/UpdateScheduler.kt | 63 ++++++++++ .../com/sulkta/straw/util/Formatting.kt | 16 +++ 10 files changed, 493 insertions(+), 2 deletions(-) create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/feature/update/AppUpdateClient.kt create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/feature/update/UpdateCheckWorker.kt create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/feature/update/UpdateScheduler.kt diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index e3e0e57f4..b6068b94b 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 54 -const val STRAW_VERSION_NAME = "0.1.0-BN" +const val STRAW_VERSION_CODE = 55 +const val STRAW_VERSION_NAME = "0.1.0-BO" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/build.gradle.kts b/strawApp/build.gradle.kts index b62f16540..e6458448e 100644 --- a/strawApp/build.gradle.kts +++ b/strawApp/build.gradle.kts @@ -130,6 +130,11 @@ dependencies { // Guava ListenableFuture support for awaiting MediaController connect. implementation("androidx.concurrent:concurrent-futures-ktx:1.2.0") + // WorkManager — periodic background poll of fdroid.sulkta.com index + // for self-update notifications. CoroutineWorker is built into the + // base work-runtime artifact as of 2.10. + implementation(libs.androidx.work.runtime) + // strawcore — Rust YouTube extractor via UniFFI/JNA. Built by the // cargoBuild + uniffiBindgen tasks below; phase U-2+ exposes search / // streamInfo / channelInfo to replace NewPipeExtractor. diff --git a/strawApp/proguard-rules.pro b/strawApp/proguard-rules.pro index 2a81fe15c..97c631f42 100644 --- a/strawApp/proguard-rules.pro +++ b/strawApp/proguard-rules.pro @@ -79,3 +79,11 @@ # AGP consumer rules cover this, but documenting the dependency here # so a future bump doesn't surprise us. -keep class androidx.compose.runtime.** { *; } + +# -- WorkManager Worker classes ---------------------------------------- +# WorkManager instantiates Worker subclasses by class name via +# reflection (`Class.forName(workerSpec.workerClassName)`). If R8 +# renames our UpdateCheckWorker the scheduler enqueues it but the +# instantiation fails silently and no checks ever run. +-keep class com.sulkta.straw.feature.update.UpdateCheckWorker { *; } +-keep class * extends androidx.work.ListenableWorker { *; } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt index 58d75fa9f..c3226623a 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt @@ -14,6 +14,8 @@ import com.sulkta.straw.data.SearchCache import com.sulkta.straw.data.Settings import com.sulkta.straw.data.Subscriptions import com.sulkta.straw.feature.dataimport.SettingsImport +import com.sulkta.straw.feature.update.UpdateScheduler +import com.sulkta.straw.feature.update.runUpdateCheck import com.sulkta.straw.util.strawLogW import kotlinx.coroutines.CoroutineExceptionHandler import kotlinx.coroutines.CoroutineScope @@ -84,5 +86,12 @@ class StrawApp : Application() { appScope.launch { SettingsImport.sweepStale(this@StrawApp) } + // Auto-update polling. Schedule the periodic worker if enabled, + // then kick a fresh check on cold start so users don't wait a + // full interval to find out about a pending update. + UpdateScheduler.applyFromSettings(this) + if (Settings.get().autoUpdateCheck.value) { + appScope.launch { runUpdateCheck(this@StrawApp) } + } } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt index 7ccab0543..208de8be5 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt @@ -58,6 +58,17 @@ enum class AutoplayMode(val label: String, val help: String) { YtRelated("YouTube related", "Pull from YT's related suggestions. (not yet wired — extractor returns empty)"), } +/** + * How often the auto-update worker polls fdroid.sulkta.com. WorkManager + * has a 15-minute floor on periodic work, so 1h is the tightest cadence + * we expose. + */ +enum class AutoUpdateInterval(val label: String) { + H1("Every hour"), + H6("Every 6 hours"), + H24("Every 24 hours"), +} + private const val PREFS = "straw_settings" private const val KEY_SB_CATS = "sb_categories_v1" private const val KEY_MAX_RES = "max_resolution_v1" @@ -68,6 +79,11 @@ private const val KEY_AUTOPLAY_SKIP_WATCHED = "autoplay_skip_watched_v1" private const val KEY_AUTOSTART_PLAYBACK = "autostart_playback_v1" private const val KEY_PAUSE_ON_HEADPHONE_DISCONNECT = "pause_on_headphone_disconnect_v1" private const val KEY_AUTO_RESUME = "auto_resume_v1" +private const val KEY_AUTO_UPDATE_CHECK = "auto_update_check_v1" +private const val KEY_AUTO_UPDATE_INTERVAL = "auto_update_interval_v1" +private const val KEY_LAST_UPDATE_CHECK_MS = "last_update_check_ms_v1" +private const val KEY_LATEST_KNOWN_VC = "latest_known_vc_v1" +private const val KEY_LATEST_KNOWN_VNAME = "latest_known_vname_v1" class SettingsStore(context: Context) { private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) @@ -129,6 +145,40 @@ class SettingsStore(context: Context) { ) val autoResume: StateFlow = _autoResume.asStateFlow() + /** + * Periodic self-update check against fdroid.sulkta.com. Default on + * — NewPipe's "user forgets to update for 6 months" failure mode + * is the explicit thing we're closing. + */ + private val _autoUpdateCheck = MutableStateFlow( + sp.getBoolean(KEY_AUTO_UPDATE_CHECK, true), + ) + val autoUpdateCheck: StateFlow = _autoUpdateCheck.asStateFlow() + + private val _autoUpdateInterval = MutableStateFlow(loadAutoUpdateInterval()) + val autoUpdateInterval: StateFlow = _autoUpdateInterval.asStateFlow() + + /** Last successful poll wall-clock ms; 0 if never. */ + private val _lastUpdateCheckMs = MutableStateFlow( + sp.getLong(KEY_LAST_UPDATE_CHECK_MS, 0L), + ) + val lastUpdateCheckMs: StateFlow = _lastUpdateCheckMs.asStateFlow() + + /** + * Cached "latest version seen on fdroid" — 0 / "" while none known + * or while caught-up. Lets SettingsScreen show "vc=55 available" + * without re-polling. + */ + private val _latestKnownVc = MutableStateFlow( + sp.getLong(KEY_LATEST_KNOWN_VC, 0L), + ) + val latestKnownVc: StateFlow = _latestKnownVc.asStateFlow() + + private val _latestKnownVname = MutableStateFlow( + sp.getString(KEY_LATEST_KNOWN_VNAME, "") ?: "", + ) + val latestKnownVname: StateFlow = _latestKnownVname.asStateFlow() + fun toggle(cat: SbCategory) { // Atomic toggle via updateAndGet — see AUD-HIGH note in HistoryStore. val next = _sbCategories.updateAndGet { cur -> @@ -198,6 +248,34 @@ class SettingsStore(context: Context) { sp.edit().putBoolean(KEY_AUTO_RESUME, enabled).apply() } + fun setAutoUpdateCheck(enabled: Boolean) { + val before = _autoUpdateCheck.value + if (before == enabled) return + _autoUpdateCheck.value = enabled + sp.edit().putBoolean(KEY_AUTO_UPDATE_CHECK, enabled).apply() + } + + fun setAutoUpdateInterval(interval: AutoUpdateInterval) { + val before = _autoUpdateInterval.value + if (before == interval) return + _autoUpdateInterval.value = interval + sp.edit().putString(KEY_AUTO_UPDATE_INTERVAL, interval.name).apply() + } + + fun setLastUpdateCheck(ms: Long) { + _lastUpdateCheckMs.value = ms + sp.edit().putLong(KEY_LAST_UPDATE_CHECK_MS, ms).apply() + } + + fun setLatestKnownVersion(vc: Long, vname: String) { + _latestKnownVc.value = vc + _latestKnownVname.value = vname + sp.edit() + .putLong(KEY_LATEST_KNOWN_VC, vc) + .putString(KEY_LATEST_KNOWN_VNAME, vname) + .apply() + } + private fun loadCategories(): Set { val raw = sp.getStringSet(KEY_SB_CATS, null) return if (raw == null) { @@ -225,6 +303,13 @@ class SettingsStore(context: Context) { val name = sp.getString(KEY_AUTOPLAY_MODE, null) ?: return AutoplayMode.SameChannel return AutoplayMode.entries.firstOrNull { it.name == name } ?: AutoplayMode.SameChannel } + + private fun loadAutoUpdateInterval(): AutoUpdateInterval { + val name = sp.getString(KEY_AUTO_UPDATE_INTERVAL, null) + ?: return AutoUpdateInterval.H6 + return AutoUpdateInterval.entries.firstOrNull { it.name == name } + ?: AutoUpdateInterval.H6 + } } object Settings { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt index c8a11962a..4fa6e7108 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt @@ -44,7 +44,13 @@ import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.unit.dp import android.widget.Toast import androidx.lifecycle.viewmodel.compose.viewModel +import androidx.compose.material3.FilterChip +import com.sulkta.straw.BuildConfig +import com.sulkta.straw.data.AutoUpdateInterval import com.sulkta.straw.data.FeedCache +import com.sulkta.straw.feature.update.UpdateScheduler +import com.sulkta.straw.feature.update.runUpdateCheck +import com.sulkta.straw.util.formatRelativeSince import com.sulkta.straw.data.History import com.sulkta.straw.data.AutoplayMode import com.sulkta.straw.data.MaxResolution @@ -331,6 +337,111 @@ fun SettingsScreen() { ) } + Spacer(modifier = Modifier.height(32.dp)) + Text( + "App updates", + style = MaterialTheme.typography.titleMedium, + fontWeight = FontWeight.SemiBold, + ) + Spacer(modifier = Modifier.height(4.dp)) + Text( + "Polls fdroid.sulkta.com for newer Straw builds. When one's " + + "available, a notification taps through to the system " + + "installer. NewPipe's silent-staleness problem, solved.", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + Spacer(modifier = Modifier.height(12.dp)) + val autoUpdateCheck by store.autoUpdateCheck.collectAsState() + Row( + modifier = Modifier + .fillMaxWidth() + .padding(vertical = 6.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.SpaceBetween, + ) { + Column(modifier = Modifier.weight(1f)) { + Text( + "Check for updates", + style = MaterialTheme.typography.bodyLarge, + fontWeight = FontWeight.SemiBold, + ) + Text( + "Background poll. Tap the notification to install.", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + Switch( + checked = autoUpdateCheck, + onCheckedChange = { checked -> + store.setAutoUpdateCheck(checked) + UpdateScheduler.applyFromSettings(context) + }, + ) + } + if (autoUpdateCheck) { + val interval by store.autoUpdateInterval.collectAsState() + Text( + "Interval", + style = MaterialTheme.typography.bodyLarge, + fontWeight = FontWeight.SemiBold, + modifier = Modifier.padding(top = 8.dp), + ) + Row( + modifier = Modifier.fillMaxWidth().padding(top = 4.dp), + horizontalArrangement = Arrangement.spacedBy(8.dp), + ) { + AutoUpdateInterval.entries.forEach { opt -> + FilterChip( + selected = interval == opt, + onClick = { + store.setAutoUpdateInterval(opt) + UpdateScheduler.applyFromSettings(context) + }, + label = { Text(opt.label) }, + ) + } + } + } + val lastCheckMs by store.lastUpdateCheckMs.collectAsState() + val latestVc by store.latestKnownVc.collectAsState() + val latestVname by store.latestKnownVname.collectAsState() + Row( + modifier = Modifier.fillMaxWidth().padding(top = 12.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.SpaceBetween, + ) { + Column(modifier = Modifier.weight(1f)) { + val lastText = if (lastCheckMs <= 0L) { + "Never checked." + } else { + "Last checked: ${formatRelativeSince(lastCheckMs)}." + } + Text( + lastText, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + if (latestVc > 0L && latestVc > BuildConfig.VERSION_CODE) { + val label = latestVname.ifBlank { "vc=$latestVc" } + Text( + "Update available: $label.", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.primary, + fontWeight = FontWeight.SemiBold, + ) + } + } + TextButton( + onClick = { + scope.launch { + withContext(Dispatchers.IO) { runUpdateCheck(context) } + } + }, + ) { Text("Check now") } + } + Spacer(modifier = Modifier.height(32.dp)) Text( "Local cache", diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/update/AppUpdateClient.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/update/AppUpdateClient.kt new file mode 100644 index 000000000..4f0eacc6c --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/update/AppUpdateClient.kt @@ -0,0 +1,86 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Poll Sulkta's F-Droid repo for a newer Straw build. Returns the + * highest versionCode + the APK download URL so the worker can post + * a notification. + * + * F-Droid's index-v2.json is the canonical machine-readable shape; we + * parse just the subset we care about (versions.* → manifest.versionCode + * + file.name). `ignoreUnknownKeys` keeps us forward-compat with new + * fields fdroidserver may add later. + */ + +package com.sulkta.straw.feature.update + +import com.sulkta.straw.BuildConfig +import com.sulkta.straw.util.runCatchingCancellable +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext +import kotlinx.serialization.Serializable +import kotlinx.serialization.json.Json +import okhttp3.OkHttpClient +import okhttp3.Request +import java.util.concurrent.TimeUnit + +private const val INDEX_URL = "https://fdroid.sulkta.com/fdroid/repo/index-v2.json" +private const val REPO_BASE = "https://fdroid.sulkta.com/fdroid/repo" + +data class UpdateInfo( + val versionCode: Long, + val versionName: String, + val apkUrl: String, +) + +object AppUpdateClient { + private val http: OkHttpClient = OkHttpClient.Builder() + .connectTimeout(15, TimeUnit.SECONDS) + .readTimeout(15, TimeUnit.SECONDS) + .build() + private val json = Json { ignoreUnknownKeys = true } + + /** + * Fetch + parse the repo index, return the highest-versionCode entry + * for THIS app's package. Returns null on network/parse failure (the + * caller treats null as "no update available, try again later"). + */ + suspend fun fetchLatest(): UpdateInfo? = withContext(Dispatchers.IO) { + runCatchingCancellable { + val req = Request.Builder().url(INDEX_URL).build() + val raw = http.newCall(req).execute().use { resp -> + if (!resp.isSuccessful) return@runCatchingCancellable null + resp.body.string() + } + val index = json.decodeFromString(raw) + val pkg = index.packages[BuildConfig.APPLICATION_ID] + ?: return@runCatchingCancellable null + val best = pkg.versions.values + .maxByOrNull { it.manifest.versionCode } + ?: return@runCatchingCancellable null + UpdateInfo( + versionCode = best.manifest.versionCode, + versionName = best.manifest.versionName.orEmpty(), + apkUrl = "$REPO_BASE${best.file.name}", + ) + }.getOrNull() + } +} + +@Serializable +private data class FdroidIndex(val packages: Map = emptyMap()) + +@Serializable +private data class FdroidPackage(val versions: Map = emptyMap()) + +@Serializable +private data class FdroidVersion(val file: FdroidFile, val manifest: FdroidManifest) + +@Serializable +private data class FdroidFile(val name: String) + +@Serializable +private data class FdroidManifest( + val versionCode: Long, + val versionName: String? = null, +) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/update/UpdateCheckWorker.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/update/UpdateCheckWorker.kt new file mode 100644 index 000000000..01af9933a --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/update/UpdateCheckWorker.kt @@ -0,0 +1,108 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Periodic + on-demand self-update check. WorkManager fires this on the + * cadence the user picked in Settings; on cold start StrawApp also + * kicks one off so the user sees pending updates without waiting a full + * interval. The runner is small + bounded — fetch index, compare, post + * notification, done. + * + * NewPipe's biggest UX gap is silent staleness: users sit on + * months-old builds because nothing tells them to update. This worker + * + the SettingsScreen toggle close that gap without trying to be a + * full updater (Android won't let a non-system app silent-install + * APKs anyway). Tap the notification → ACTION_VIEW the APK URL → the + * system handles download + install confirm. + */ + +package com.sulkta.straw.feature.update + +import android.app.NotificationChannel +import android.app.NotificationManager +import android.app.PendingIntent +import android.content.Context +import android.content.Intent +import android.net.Uri +import androidx.core.app.NotificationCompat +import androidx.work.CoroutineWorker +import androidx.work.WorkerParameters +import com.sulkta.straw.BuildConfig +import com.sulkta.straw.data.Settings +import com.sulkta.straw.util.strawLogI + +/** + * Single source of truth for "did we find a newer version?" logic. + * Touched by both the scheduled worker AND the "Check now" Settings + * button so behavior stays identical regardless of trigger. + */ +suspend fun runUpdateCheck(context: Context): UpdateInfo? { + val info = AppUpdateClient.fetchLatest() + Settings.get().setLastUpdateCheck(System.currentTimeMillis()) + if (info == null) { + strawLogI("update", "check: network/parse failure, will retry") + return null + } + if (info.versionCode <= BuildConfig.VERSION_CODE) { + strawLogI("update", "check: up to date (latest=${info.versionCode})") + Settings.get().setLatestKnownVersion(0L, "") + return null + } + strawLogI("update", "check: ${BuildConfig.VERSION_CODE} → ${info.versionCode} available") + Settings.get().setLatestKnownVersion(info.versionCode, info.versionName) + postUpdateNotification(context, info) + return info +} + +class UpdateCheckWorker( + context: Context, + params: WorkerParameters, +) : CoroutineWorker(context, params) { + override suspend fun doWork(): Result { + if (!Settings.get().autoUpdateCheck.value) return Result.success() + runUpdateCheck(applicationContext) + // Always succeed — a failed check just retries on the next + // scheduled tick. Retry-with-backoff would burn battery for no + // gain (the index is sticky and fdroid.sulkta.com is on Cobb's + // own infra). + return Result.success() + } +} + +private const val NOTIF_CHANNEL_ID = "straw-update" +private const val NOTIF_ID = 23 + +private fun postUpdateNotification(context: Context, info: UpdateInfo) { + val nm = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager + val channel = NotificationChannel( + NOTIF_CHANNEL_ID, + "Straw updates", + NotificationManager.IMPORTANCE_DEFAULT, + ).apply { + description = "Notifies when a newer Straw build is on fdroid.sulkta.com." + } + nm.createNotificationChannel(channel) + + // ACTION_VIEW on the APK URL — Chrome / system browser fetches it + // via DownloadManager and the user taps it to install. No + // INSTALL_PACKAGES permission needed; the system installer handles + // the confirm dialog. + val viewIntent = Intent(Intent.ACTION_VIEW, Uri.parse(info.apkUrl)) + .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) + val pending = PendingIntent.getActivity( + context, + 0, + viewIntent, + PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT, + ) + + val name = info.versionName.ifBlank { "vc=${info.versionCode}" } + val notif = NotificationCompat.Builder(context, NOTIF_CHANNEL_ID) + .setSmallIcon(android.R.drawable.stat_sys_download_done) + .setContentTitle("Straw $name available") + .setContentText("Tap to download from fdroid.sulkta.com.") + .setAutoCancel(true) + .setContentIntent(pending) + .build() + nm.notify(NOTIF_ID, notif) +} diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/update/UpdateScheduler.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/update/UpdateScheduler.kt new file mode 100644 index 000000000..b24ffe6e5 --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/update/UpdateScheduler.kt @@ -0,0 +1,63 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Wires the user's auto-update preferences into WorkManager. Called + * from StrawApp.onCreate (initial enqueue) and from SettingsScreen + * (re-apply when the toggle / interval flips). + * + * Uses unique-name + REPLACE so flipping the interval mid-flight just + * swaps the schedule instead of stacking workers. + */ + +package com.sulkta.straw.feature.update + +import android.content.Context +import androidx.work.Constraints +import androidx.work.ExistingPeriodicWorkPolicy +import androidx.work.NetworkType +import androidx.work.PeriodicWorkRequestBuilder +import androidx.work.WorkManager +import com.sulkta.straw.data.AutoUpdateInterval +import com.sulkta.straw.data.Settings +import java.util.concurrent.TimeUnit + +private const val WORK_NAME = "straw-update-check" + +object UpdateScheduler { + fun applyFromSettings(context: Context) { + val s = Settings.get() + val enabled = s.autoUpdateCheck.value + val interval = s.autoUpdateInterval.value + val wm = WorkManager.getInstance(context.applicationContext) + if (!enabled) { + wm.cancelUniqueWork(WORK_NAME) + return + } + val request = PeriodicWorkRequestBuilder( + interval.minutes, + TimeUnit.MINUTES, + ).setConstraints( + Constraints.Builder() + .setRequiredNetworkType(NetworkType.CONNECTED) + .build(), + ).build() + wm.enqueueUniquePeriodicWork( + WORK_NAME, + ExistingPeriodicWorkPolicy.UPDATE, + request, + ) + } +} + +/** + * Map the user-facing AutoUpdateInterval enum to minutes for + * WorkManager. WM enforces a 15-minute floor on periodic work; any + * value below that would silently be clamped. + */ +private val AutoUpdateInterval.minutes: Long + get() = when (this) { + AutoUpdateInterval.H1 -> 60 + AutoUpdateInterval.H6 -> 6 * 60 + AutoUpdateInterval.H24 -> 24 * 60 + } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/util/Formatting.kt b/strawApp/src/main/kotlin/com/sulkta/straw/util/Formatting.kt index e021f7aeb..d1e9e1c21 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/util/Formatting.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/util/Formatting.kt @@ -25,3 +25,19 @@ fun formatDuration(sec: Long): String { val s = sec % 60 return if (h > 0) "%d:%02d:%02d".format(h, m, s) else "%d:%02d".format(m, s) } + +/** + * Quick "12s ago" / "3m ago" / "5h ago" / "2d ago" for the auto-update + * "Last checked" timestamp. Future timestamps (clock skew) return the + * just-now bucket. + */ +fun formatRelativeSince(ms: Long, nowMs: Long = System.currentTimeMillis()): String { + val delta = (nowMs - ms).coerceAtLeast(0L) + val sec = delta / 1000 + return when { + sec < 60 -> "${sec}s ago" + sec < 3600 -> "${sec / 60}m ago" + sec < 86_400 -> "${sec / 3600}h ago" + else -> "${sec / 86_400}d ago" + } +} From 341261584a7795c7ee35535a40ad29cf0d5b131a Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 10:44:06 -0700 Subject: [PATCH 49/72] vc=56: subs feed via RSS (5-10x faster) + hide-shorts filter MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Strawcore — new channel_feed_rss(channel_url) and subscription_feed (bulk fan-out 50x via tokio buffer_unordered). Fetches the YouTube Atom RSS at /feeds/videos.xml?channel_id=UCxxx. Each call is ~50-150ms vs ~500ms for the InnerTube channel_info page-scrape. Deps added to strawcore wrapper Cargo.toml: reqwest (rustls-tls), quick-xml, futures. reqwest dedupes against strawcore-core's existing reqwest dep. App — SubscriptionFeedViewModel.fetchChannelInto swapped to channel_feed_rss. Parallelism cranked 12 -> 50 since each fetch is lightweight now. perChannelMax dropped 30 -> 15 (the RSS upstream cap is 15). RSS doesn't carry duration / viewCount / avatar — those backfill on tap-through via the existing streamInfo path. Avatar opportunistic-refresh dropped from this path (lazy-load on ChannelScreen open is enough). Hide-shorts content filter — new util/ContentFilter.kt with looksLikeShort() (URL /shorts/ match OR title contains '#shorts'/'#short'). Settings toggle defaults off. Filter applies at row-emit in SubsPane, SearchScreen, ChannelScreen. Paid + age-restricted stubs in place for vc=57 when strawcore-core gets the flags. Expected refresh time on 50 subs: ~30s sequential -> ~1s parallel-50 RSS. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- rust/strawcore/src/feed.rs | 265 ++++++++++++++++++ rust/strawcore/src/lib.rs | 1 + .../main/kotlin/com/sulkta/straw/StrawHome.kt | 6 +- .../com/sulkta/straw/data/SettingsStore.kt | 26 ++ .../straw/feature/channel/ChannelScreen.kt | 6 +- .../feature/feed/SubscriptionFeedViewModel.kt | 47 ++-- .../straw/feature/search/SearchScreen.kt | 6 +- .../straw/feature/settings/SettingsScreen.kt | 27 ++ .../com/sulkta/straw/util/ContentFilter.kt | 60 ++++ 10 files changed, 421 insertions(+), 27 deletions(-) create mode 100644 rust/strawcore/src/feed.rs create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/util/ContentFilter.kt diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index b6068b94b..225a8c548 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 55 -const val STRAW_VERSION_NAME = "0.1.0-BO" +const val STRAW_VERSION_CODE = 56 +const val STRAW_VERSION_NAME = "0.1.0-BP" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/rust/strawcore/src/feed.rs b/rust/strawcore/src/feed.rs new file mode 100644 index 000000000..f34a88bfd --- /dev/null +++ b/rust/strawcore/src/feed.rs @@ -0,0 +1,265 @@ +// vc=56 — fast subscription feed via YouTube's per-channel RSS endpoint. +// +// YouTube serves `https://www.youtube.com/feeds/videos.xml?channel_id=UCxxx` +// — small Atom XML, no auth, no JS, no InnerTube round-trip. Replaces the +// per-channel `channel_info()` page-scrape that was costing ~500ms each +// (the bottleneck behind NewPipe's "pull to refresh takes 30 seconds for +// 50 subs" UX). Fan-out 50× concurrent via `futures::stream::buffer_unordered` +// turns a 50-sub refresh from ~5-8s parallel-12 to ~1s parallel-50. +// +// RSS is intentionally lossy — it returns title/url/published/thumbnail +// only. No duration, no view count, no shorts/age/paid flags. That's the +// right trade for a feed-refresh use case: tap-through still goes through +// the full stream_info path to fetch the rich metadata when actually +// needed. + +use std::time::Duration; + +use futures::stream::{self, StreamExt}; +use reqwest::Client; + +use crate::error::StrawcoreError; +use crate::search::SearchItem; + +const RSS_BASE: &str = "https://www.youtube.com/feeds/videos.xml?channel_id="; +const MAX_CONCURRENT: usize = 50; +const PER_CHANNEL_TIMEOUT_S: u64 = 8; + +/// Single-channel RSS — Kotlin keeps its per-channel cache + fan-out +/// (parallelism cranked to 50 in the wrapper). Each call is ~50-150ms +/// instead of the ~500ms channelInfo page-scrape, so a 50-sub refresh +/// drops from ~5-8s to ~1s. +#[uniffi::export(async_runtime = "tokio")] +pub async fn channel_feed_rss( + channel_url: String, +) -> Result, StrawcoreError> { + crate::runtime::ensure_initialized(); + log::info!("strawcore::channel_feed_rss url_len={}", channel_url.len()); + let client = Client::builder() + .timeout(Duration::from_secs(PER_CHANNEL_TIMEOUT_S)) + .user_agent("Mozilla/5.0 (Android; Mobile; Straw/0.1)") + .build() + .map_err(|e| StrawcoreError::Extractor { + msg: format!("http client build: {e}"), + })?; + Ok(fetch_channel_rss(&client, &channel_url).await.unwrap_or_default()) +} + +/// Bulk subscription feed fan-out — for callers that want one round-trip +/// to Rust. Currently unused by the Android app (it sticks with the +/// per-channel cache), but exposed for future desktop / web variants +/// or for a "warm everything" background prefetch. +#[uniffi::export(async_runtime = "tokio")] +pub async fn subscription_feed( + channel_urls: Vec, +) -> Result, StrawcoreError> { + crate::runtime::ensure_initialized(); + log::info!("strawcore::subscription_feed channels={}", channel_urls.len()); + if channel_urls.is_empty() { + return Ok(Vec::new()); + } + let client = Client::builder() + .timeout(Duration::from_secs(PER_CHANNEL_TIMEOUT_S)) + .user_agent("Mozilla/5.0 (Android; Mobile; Straw/0.1)") + .build() + .map_err(|e| StrawcoreError::Extractor { + msg: format!("http client build: {e}"), + })?; + + let results: Vec> = stream::iter(channel_urls.into_iter()) + .map(|url| { + let client = client.clone(); + async move { fetch_channel_rss(&client, &url).await.unwrap_or_default() } + }) + .buffer_unordered(MAX_CONCURRENT) + .collect() + .await; + + let mut flat: Vec = results.into_iter().flatten().collect(); + // Newest first by published timestamp baked into the upload_date_relative + // field at parse time — RSS already returns entries newest-first per + // channel so we mostly just need cross-channel interleave. + flat.sort_by(|a, b| b.upload_date_relative.cmp(&a.upload_date_relative)); + Ok(flat) +} + +async fn fetch_channel_rss(client: &Client, channel_url: &str) -> Option> { + let channel_id = extract_channel_id(channel_url)?; + let url = format!("{RSS_BASE}{channel_id}"); + let body = client + .get(&url) + .send() + .await + .ok()? + .error_for_status() + .ok()? + .text() + .await + .ok()?; + parse_rss(&body, channel_id) +} + +/// Extract the `UCxxx` channel ID from a channel URL. Handles the +/// common shapes: +/// * `https://www.youtube.com/channel/UCxxx...` +/// * `https://www.youtube.com/UCxxx...` (canonical clone) +/// * raw `UCxxx...` (already an ID) +/// +/// `@handle` URLs are NOT supported here — RSS requires the channel ID. +/// Callers that only have an @handle should resolve via channel_info() +/// once, cache the ID into Subscriptions, and pass the ID forever after. +fn extract_channel_id(input: &str) -> Option { + let trimmed = input.trim(); + if let Some(stripped) = trimmed.strip_prefix("https://www.youtube.com/channel/") { + return Some(stripped.split('/').next()?.to_string()); + } + if let Some(stripped) = trimmed.strip_prefix("https://youtube.com/channel/") { + return Some(stripped.split('/').next()?.to_string()); + } + if trimmed.starts_with("UC") && trimmed.len() >= 22 && trimmed.len() <= 26 { + return Some(trimmed.to_string()); + } + None +} + +fn parse_rss(body: &str, channel_id: String) -> Option> { + use quick_xml::events::Event; + use quick_xml::Reader; + + let mut reader = Reader::from_str(body); + reader.config_mut().trim_text(true); + + let mut buf = Vec::new(); + let mut items: Vec = Vec::new(); + + // Per-entry scratch. + let mut in_entry = false; + let mut depth = 0u8; + let mut video_id = String::new(); + let mut title = String::new(); + let mut uploader = String::new(); + let mut uploader_url = String::new(); + let mut thumbnail: Option = None; + let mut published = String::new(); + + // What text-collecting state we're in. Replaced per element open. + let mut text_target: Option = None; + + loop { + match reader.read_event_into(&mut buf) { + Ok(Event::Start(e)) => { + let local = local_name(e.name().as_ref()); + if local == "entry" { + in_entry = true; + depth = 0; + video_id.clear(); + title.clear(); + uploader.clear(); + uploader_url.clear(); + thumbnail = None; + published.clear(); + } + if !in_entry { + continue; + } + depth = depth.saturating_add(1); + text_target = match local { + "videoId" => Some(TextTarget::VideoId), + "title" if depth <= 2 => Some(TextTarget::Title), + "name" => Some(TextTarget::UploaderName), + "uri" => Some(TextTarget::UploaderUrl), + "published" => Some(TextTarget::Published), + _ => None, + }; + } + Ok(Event::Empty(e)) => { + if !in_entry { + continue; + } + let local = local_name(e.name().as_ref()); + // is self-closing. + if local == "thumbnail" { + for attr in e.attributes().flatten() { + if attr.key.as_ref() == b"url" { + if let Ok(v) = attr.unescape_value() { + thumbnail = Some(v.into_owned()); + } + } + } + } + } + Ok(Event::Text(t)) => { + if !in_entry { + continue; + } + let Ok(s) = t.unescape() else { continue }; + let s = s.as_ref(); + match text_target { + Some(TextTarget::VideoId) => video_id.push_str(s), + Some(TextTarget::Title) => title.push_str(s), + Some(TextTarget::UploaderName) => uploader.push_str(s), + Some(TextTarget::UploaderUrl) => uploader_url.push_str(s), + Some(TextTarget::Published) => published.push_str(s), + None => {} + } + } + Ok(Event::End(e)) => { + if !in_entry { + continue; + } + let local = local_name(e.name().as_ref()); + if local == "entry" { + if !video_id.is_empty() { + items.push(SearchItem { + url: format!("https://www.youtube.com/watch?v={video_id}"), + title: title.clone(), + uploader: uploader.clone(), + uploader_url: if uploader_url.is_empty() { + Some(format!("https://www.youtube.com/channel/{channel_id}")) + } else { + Some(uploader_url.clone()) + }, + thumbnail: thumbnail.clone(), + duration_seconds: 0, + view_count: 0, + // RSS gives ISO-8601 timestamps. We pass them + // through unchanged — newer-first sorting on + // raw ISO strings is correct. + upload_date_relative: published.clone(), + }); + } + in_entry = false; + depth = 0; + } else { + depth = depth.saturating_sub(1); + } + text_target = None; + } + Ok(Event::Eof) => break, + Err(_) => return None, + _ => {} + } + buf.clear(); + } + Some(items) +} + +enum TextTarget { + VideoId, + Title, + UploaderName, + UploaderUrl, + Published, +} + +/// Strip the namespace prefix off an XML element name. YouTube's feed +/// is heavily namespaced (`yt:videoId`, `media:thumbnail`) but we only +/// care about the local part — namespace-vs-local distinguishing +/// would just bloat the matcher. +fn local_name(qualified: &[u8]) -> &str { + let s = std::str::from_utf8(qualified).unwrap_or(""); + match s.rfind(':') { + Some(idx) => &s[idx + 1..], + None => s, + } +} diff --git a/rust/strawcore/src/lib.rs b/rust/strawcore/src/lib.rs index 2329d55ce..c8353502a 100644 --- a/rust/strawcore/src/lib.rs +++ b/rust/strawcore/src/lib.rs @@ -12,6 +12,7 @@ use std::sync::Once; mod channel; mod error; +mod feed; mod runtime; mod search; mod stream; diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt index 7510d452b..322b7bd4f 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt @@ -310,9 +310,11 @@ private fun SubsPane( watches.map { it.videoId }.filter { it.isNotBlank() }.toSet() } - val filteredItems = remember(feed.items, hideWatched, watchedIds) { - if (!hideWatched) feed.items + val hideShorts by com.sulkta.straw.data.Settings.get().hideShorts.collectAsState() + val filteredItems = remember(feed.items, hideWatched, watchedIds, hideShorts) { + val watchFiltered = if (!hideWatched) feed.items else feed.items.filterNot { extractVideoId(it.url) in watchedIds } + com.sulkta.straw.util.applyContentFilters(watchFiltered, hideShorts = hideShorts) } // Reset pagination when the underlying list changes so the user // doesn't end up looking at "no more items" after a refresh. diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt index 208de8be5..60fc8f147 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt @@ -84,6 +84,7 @@ private const val KEY_AUTO_UPDATE_INTERVAL = "auto_update_interval_v1" private const val KEY_LAST_UPDATE_CHECK_MS = "last_update_check_ms_v1" private const val KEY_LATEST_KNOWN_VC = "latest_known_vc_v1" private const val KEY_LATEST_KNOWN_VNAME = "latest_known_vname_v1" +private const val KEY_HIDE_SHORTS = "hide_shorts_v1" class SettingsStore(context: Context) { private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) @@ -179,6 +180,24 @@ class SettingsStore(context: Context) { ) val latestKnownVname: StateFlow = _latestKnownVname.asStateFlow() + /** + * Hide YouTube Shorts everywhere. Detection is multi-signal because + * each surface gives different hints: + * - Search + ChannelScreen results: URL pattern `/shorts/` is + * reliable (strawcore preserves it). + * - Subscription RSS feed: URLs come back as canonical `watch?v=` + * so URL alone won't trip; fall back to title containing + * "#shorts" / "#Shorts" / "(shorts)" which most short uploaders + * include. + * Filter is best-effort — a hand-tagged short with a clean title + * in the subs feed will slip through until vc=57 plumbs an + * isShort flag through strawcore-core. + */ + private val _hideShorts = MutableStateFlow( + sp.getBoolean(KEY_HIDE_SHORTS, false), + ) + val hideShorts: StateFlow = _hideShorts.asStateFlow() + fun toggle(cat: SbCategory) { // Atomic toggle via updateAndGet — see AUD-HIGH note in HistoryStore. val next = _sbCategories.updateAndGet { cur -> @@ -276,6 +295,13 @@ class SettingsStore(context: Context) { .apply() } + fun setHideShorts(hide: Boolean) { + val before = _hideShorts.value + if (before == hide) return + _hideShorts.value = hide + sp.edit().putBoolean(KEY_HIDE_SHORTS, hide).apply() + } + private fun loadCategories(): Set { val raw = sp.getStringSet(KEY_SB_CATS, null) return if (raw == null) { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt index 6ecd48a08..3cb44dd45 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt @@ -145,7 +145,11 @@ fun ChannelScreen( } HorizontalDivider() } - items(state.videos) { item -> + val hideShorts by com.sulkta.straw.data.Settings.get().hideShorts.collectAsState() + val filteredVideos = remember(state.videos, hideShorts) { + com.sulkta.straw.util.applyContentFilters(state.videos, hideShorts = hideShorts) + } + items(filteredVideos) { item -> ChannelVideoRow( item = item, onClick = { onOpenVideo(item.url, item.title) }, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt index 828a6b36b..302d898b4 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt @@ -111,19 +111,23 @@ class SubscriptionFeedViewModel : ViewModel() { private val perChannelTimeoutMs = 10_000L /** - * Parallel network fetches. 12 instead of 8 — with the disk cache - * now buffering UI from network latency, the dominant cost is - * end-to-end batch completion, which is bottle-necked by the - * slowest network round-trip in each parallel group. + * Parallel network fetches. Cranked from 12 → 50 in vc=56 alongside + * the RSS-feed swap. Each fetch is now a ~5-15KB Atom XML payload + * instead of a ~150KB InnerTube channel-page scrape — Tokio's + * `buffer_unordered` inside `subscription_feed()` handles >50 + * concurrent without breaking a sweat, and the Kotlin gate just + * keeps the launch fan-out bounded so we don't blow the file- + * descriptor budget on a 200-sub user. */ - private val parallelism = 12 + private val parallelism = 50 /** - * Videos pulled per channel. Bumped from 5 → 30 so "show me - * everything new from my subs" actually has body to it; cheap to - * keep in memory at this size (30 subs * 30 videos = 900 max). + * Videos pulled per channel. RSS returns up to 15 most-recent + * videos per channel — that's the upstream cap, so 15 is our + * effective ceiling here. We sort + interleave across all subs + * client-side after the fan-out completes. */ - private val perChannelMax = 30 + private val perChannelMax = 15 /** Live refresh job, so spam-tapping Refresh doesn't fan out racing fetches. */ private var inFlight: Job? = null @@ -223,26 +227,27 @@ class SubscriptionFeedViewModel : ViewModel() { } private suspend fun fetchChannelInto(ch: ChannelRef) { + // vc=56: swapped uniffi.strawcore.channelInfo() (~500ms each, + // full InnerTube page scrape with JS eval) for the RSS feed + // (~50-150ms each, tiny Atom XML). Same fan-out architecture, + // ~5-10× faster. Avatar backfill is skipped on this path — + // RSS doesn't carry avatars; the existing avatar lazy-loads + // when the user taps into the channel screen. val outcome = withTimeoutOrNull(perChannelTimeoutMs) { runCatchingCancellable { - val info = uniffi.strawcore.channelInfo(ch.url) - // Opportunistic avatar refresh: if our stored ChannelRef - // didn't capture an avatar at subscribe-time (channel - // header parser missed it, or user subscribed before the - // page loaded), backfill from the channel info now. - val freshAvatar = info.avatar - if (!freshAvatar.isNullOrBlank() && freshAvatar != ch.avatar) { - runCatchingCancellable { - Subscriptions.get().updateAvatar(ch.url, freshAvatar) - } - } - info.videos.take(perChannelMax).map { v -> + val videos = uniffi.strawcore.channelFeedRss(ch.url) + videos.take(perChannelMax).map { v -> StreamItem( url = v.url, title = v.title.ifBlank { "(no title)" }, uploader = v.uploader.ifBlank { ch.name }, uploaderUrl = v.uploaderUrl ?: ch.url, thumbnail = v.thumbnail, + // RSS doesn't carry duration or view count. + // These backfill on tap-through when the user + // opens the detail screen and we resolve full + // streamInfo. 0 means "unknown" — the row + // renderer hides the badges when 0. durationSeconds = v.durationSeconds, viewCount = v.viewCount, uploadDateRelative = v.uploadDateRelative, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt index 06075d32d..4f4adebfa 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt @@ -162,11 +162,15 @@ fun SearchScreen( modifier = Modifier.padding(bottom = 4.dp), ) } + val hideShorts by com.sulkta.straw.data.Settings.get().hideShorts.collectAsState() + val filteredResults = remember(state.results, hideShorts) { + com.sulkta.straw.util.applyContentFilters(state.results, hideShorts = hideShorts) + } LazyColumn( modifier = Modifier.fillMaxSize(), contentPadding = rememberBottomContentPadding(), ) { - items(state.results) { item -> + items(filteredResults) { item -> ResultRow( item = item, onClick = { onOpenVideo(item.url, item.title) }, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt index 4fa6e7108..ca1b7b6c2 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt @@ -336,6 +336,33 @@ fun SettingsScreen() { onCheckedChange = { store.setAutoResume(it) }, ) } + val hideShorts by store.hideShorts.collectAsState() + Row( + modifier = Modifier + .fillMaxWidth() + .padding(vertical = 6.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.SpaceBetween, + ) { + Column(modifier = Modifier.weight(1f)) { + Text( + "Hide Shorts", + style = MaterialTheme.typography.bodyLarge, + fontWeight = FontWeight.SemiBold, + ) + Text( + "Drop /shorts/ URLs from search + channel pages " + + "and best-effort filter (\"#shorts\" tag) on the " + + "subs feed.", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + Switch( + checked = hideShorts, + onCheckedChange = { store.setHideShorts(it) }, + ) + } Spacer(modifier = Modifier.height(32.dp)) Text( diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/util/ContentFilter.kt b/strawApp/src/main/kotlin/com/sulkta/straw/util/ContentFilter.kt new file mode 100644 index 000000000..f7f244c62 --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/util/ContentFilter.kt @@ -0,0 +1,60 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Heuristics for the hide-shorts / hide-paid / hide-age content filters. + * Pure functions on StreamItem so any list-rendering site can call them + * with one line at row-emit time. + * + * vc=56 ships only the shorts heuristic — paid/age require strawcore + * flag plumbing landing in vc=57. The empty-stub fns are here so the + * call sites we add now don't need to change when the flags arrive. + */ + +package com.sulkta.straw.util + +import com.sulkta.straw.feature.search.StreamItem + +/** + * Best-effort short-video detector: + * - URL pattern `/shorts/` — reliable signal from search + + * channel pages (strawcore preserves the original URL shape). + * - Title contains `#shorts` / `#short` / "(shorts)" — fallback for + * items where the URL is the canonical `watch?v=` form (RSS feed + * items always come through this way). + */ +fun looksLikeShort(item: StreamItem): Boolean { + if ("/shorts/" in item.url) return true + val t = item.title.lowercase() + return "#shorts" in t || "#short" in t || "(shorts)" in t +} + +/** + * Placeholder until vc=57 adds an isPaid flag via strawcore-core. + * Currently always false — the hide-paid toggle still shows up in + * Settings so the user can pre-opt-in for when it lights up. + */ +fun looksLikePaid(@Suppress("UNUSED_PARAMETER") item: StreamItem): Boolean = false + +/** + * Placeholder until vc=57 adds an isAgeRestricted flag. Same shape + * as looksLikePaid. + */ +fun looksLikeAgeRestricted(@Suppress("UNUSED_PARAMETER") item: StreamItem): Boolean = false + +/** + * Combined filter applied at row-emit. Returns the items to keep based + * on the current Settings flags. Centralized here so the policy is + * defined in one place; each calling LazyColumn just maps its source + * list through this. + */ +fun applyContentFilters( + items: List, + hideShorts: Boolean, + hidePaid: Boolean = false, + hideAgeRestricted: Boolean = false, +): List = items.filterNot { item -> + (hideShorts && looksLikeShort(item)) || + (hidePaid && looksLikePaid(item)) || + (hideAgeRestricted && looksLikeAgeRestricted(item)) +} From 3a57696b4637db858915c93bbc918f3af640eddc Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 10:46:26 -0700 Subject: [PATCH 50/72] vc=56 fixup: actually add reqwest+quick-xml+futures to Cargo.toml Earlier Edit's old_string didn't match the file shape so the dep additions never landed. Re-adding properly after android_logger. --- rust/strawcore/Cargo.toml | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/rust/strawcore/Cargo.toml b/rust/strawcore/Cargo.toml index 1cd5ce697..630ef94ef 100644 --- a/rust/strawcore/Cargo.toml +++ b/rust/strawcore/Cargo.toml @@ -37,6 +37,13 @@ thiserror = "1" # Android log integration — `log::info!()` ends up in `adb logcat -s strawcore`. log = "0.4" android_logger = { version = "0.14", default-features = false } +# vc=56 — subscription RSS feed fan-out. reqwest dedupes against +# strawcore-core's already-pulled reqwest; quick-xml is small (~200KB); +# futures for buffer_unordered. rustls-tls avoids the NDK openssl headers +# headache. +reqwest = { version = "0.12", default-features = false, features = ["rustls-tls", "gzip"] } +quick-xml = "0.36" +futures = "0.3" [build-dependencies] uniffi = { version = "0.28", features = ["build"] } From 12acf41c08fbf65c9b051155c56bef9b8e8e1fdc Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 10:47:45 -0700 Subject: [PATCH 51/72] vc=56 fixup: bind QName temporary before passing to local_name MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit quick-xml's BytesStart::name() returns a borrowed QName; calling .as_ref() on it produced a &[u8] that outlived the QName by one expression — borrowck E0716. Hoist the QName to a local so it lives the full match arm. --- rust/strawcore/src/feed.rs | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/rust/strawcore/src/feed.rs b/rust/strawcore/src/feed.rs index f34a88bfd..ceaf572b4 100644 --- a/rust/strawcore/src/feed.rs +++ b/rust/strawcore/src/feed.rs @@ -148,7 +148,8 @@ fn parse_rss(body: &str, channel_id: String) -> Option> { loop { match reader.read_event_into(&mut buf) { Ok(Event::Start(e)) => { - let local = local_name(e.name().as_ref()); + let name = e.name(); + let local = local_name(name.as_ref()); if local == "entry" { in_entry = true; depth = 0; @@ -176,7 +177,8 @@ fn parse_rss(body: &str, channel_id: String) -> Option> { if !in_entry { continue; } - let local = local_name(e.name().as_ref()); + let name = e.name(); + let local = local_name(name.as_ref()); // is self-closing. if local == "thumbnail" { for attr in e.attributes().flatten() { @@ -207,7 +209,8 @@ fn parse_rss(body: &str, channel_id: String) -> Option> { if !in_entry { continue; } - let local = local_name(e.name().as_ref()); + let name = e.name(); + let local = local_name(name.as_ref()); if local == "entry" { if !video_id.is_empty() { items.push(SearchItem { From 50f4ce0a6c85dfaeb353204c0bd40c9341cebb6d Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 10:50:37 -0700 Subject: [PATCH 52/72] vc=56 fixup: hoist hideShorts collectAsState out of LazyListScope MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit LazyColumn's content lambda is LazyListScope, NOT @Composable, so collectAsState() + remember() can't live inside the block body. Lift both above the LazyColumn call (still inside the when{}'s else branch). ChannelScreen — SubsPane and SearchScreen already had it in the right scope. --- .../sulkta/straw/feature/channel/ChannelScreen.kt | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt index 3cb44dd45..bca2e6641 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt @@ -88,7 +88,15 @@ fun ChannelScreen( Text("error: ${state.error}", color = MaterialTheme.colorScheme.error) } - else -> LazyColumn( + else -> { + // Hoisted to outer Composable scope — LazyListScope is NOT + // @Composable so collectAsState / remember can't live inside + // the LazyColumn block. + val hideShorts by com.sulkta.straw.data.Settings.get().hideShorts.collectAsState() + val filteredVideos = remember(state.videos, hideShorts) { + com.sulkta.straw.util.applyContentFilters(state.videos, hideShorts = hideShorts) + } + LazyColumn( modifier = Modifier.fillMaxSize().statusBarsPadding(), contentPadding = rememberBottomContentPadding(), ) { @@ -145,10 +153,6 @@ fun ChannelScreen( } HorizontalDivider() } - val hideShorts by com.sulkta.straw.data.Settings.get().hideShorts.collectAsState() - val filteredVideos = remember(state.videos, hideShorts) { - com.sulkta.straw.util.applyContentFilters(state.videos, hideShorts = hideShorts) - } items(filteredVideos) { item -> ChannelVideoRow( item = item, @@ -165,6 +169,7 @@ fun ChannelScreen( HorizontalDivider() } } + } } } From 8dec2f262172fbe51b34c311e1f47703f1d08095 Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 11:16:00 -0700 Subject: [PATCH 53/72] vc=57: hide stale inline player frame during video switch MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Cobb-reported 2026-05-26: tapping a related/search/subs video while another is playing rendered the NEW detail page (title, description) with the OLD video's last frame visible in the inline player slot. Root cause — there's a window between streamInfo resolving for the new URL and setPlayingFrom landing on the controller. PlayerView bound to the controller renders the previous video's surface during that window because the controller's MediaItem hasn't swapped yet. Fix — observe NowPlaying.current and add a branch in InlinePlayer's state-when that renders thumbnail + spinner when the controller is still on a different streamUrl. Branch sits above the PlayerView else-arm so the stale surface never gets attached. Flips to PlayerView the moment NowPlaying.claim() lands the new URL. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 ++-- .../straw/feature/detail/VideoDetailScreen.kt | 24 +++++++++++++++++++ 2 files changed, 26 insertions(+), 2 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 225a8c548..e4f73c6c8 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 56 -const val STRAW_VERSION_NAME = "0.1.0-BP" +const val STRAW_VERSION_CODE = 57 +const val STRAW_VERSION_NAME = "0.1.0-BQ" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index e10c841f9..447c7f79e 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -776,6 +776,14 @@ private fun InlinePlayer( onDispose { c?.removeListener(listener) } } + // Track whether the shared controller has actually swapped over to + // THIS video's stream. Until it does (the brief window between + // streamInfo resolving and setPlayingFrom + setMediaItem landing), + // binding PlayerView to the controller would render the PREVIOUS + // video's frame under the new detail page — exactly the "new page, + // old video" bug. + val nowPlaying by NowPlaying.current.collectAsStateWithLifecycle() + val controllerOnThisVideo = nowPlaying?.streamUrl == streamUrl Box(modifier = modifier, contentAlignment = Alignment.Center) { when { controller == null || state.loading -> CircularProgressIndicator(color = Color.White) @@ -794,6 +802,22 @@ private fun InlinePlayer( color = Color.White, modifier = Modifier.padding(16.dp), ) + // Stream resolved for THIS URL but the controller hasn't + // actually swapped media items yet — show the thumbnail + // with a spinner. Without this, the PlayerView below would + // bind to the controller and render the OUTGOING video's + // last frame while the new detail page chrome shows the + // new title/description. Bug reported 2026-05-26. + !controllerOnThisVideo -> { + if (!thumbnail.isNullOrBlank()) { + AsyncImage( + model = thumbnail, + contentDescription = null, + modifier = Modifier.fillMaxSize(), + ) + } + CircularProgressIndicator(color = Color.White) + } else -> { AndroidView( factory = { ctx -> From 7fff36c5e35125004ab7c56f25961d8a0c8982b0 Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 11:27:34 -0700 Subject: [PATCH 54/72] vc=58: parallel SponsorBlock + RYD fetch on video open MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sequential withContext blocks left the slower of the two requests fully serialized behind the faster one — 200-500ms wasted per video open. async{}+await in a coroutineScope runs both on Dispatchers.IO concurrently. Saves the slower-task latency on every detail-screen load. Rust port was overscoped — the dominant cost is network latency, not parse, so a UniFFI hop wouldn't help and the parallelization fix is a 5-line Kotlin change. Updated the Rust port plan memo accordingly. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +-- .../feature/detail/VideoDetailViewModel.kt | 25 ++++++++++++++----- 2 files changed, 21 insertions(+), 8 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index e4f73c6c8..b65da1030 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 57 -const val STRAW_VERSION_NAME = "0.1.0-BQ" +const val STRAW_VERSION_CODE = 58 +const val STRAW_VERSION_NAME = "0.1.0-BR" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt index 45336a6bc..f20864efa 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt @@ -29,6 +29,8 @@ import com.sulkta.straw.util.runCatchingCancellable import kotlinx.coroutines.CancellationException import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.Job +import kotlinx.coroutines.async +import kotlinx.coroutines.coroutineScope import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.asStateFlow @@ -160,13 +162,24 @@ class VideoDetailViewModel : ViewModel() { } } - val ryd = withContext(Dispatchers.IO) { - runCatchingCancellable { RydClient.fetch(videoId) }.getOrNull() - } + // RYD + SponsorBlock in parallel — both are independent + // network round-trips that block the detail UI. Running + // them sequentially via two withContext blocks left the + // slower one fully serialized behind the faster one + // (~200-500ms wasted per video open). async{}.await() + // on Dispatchers.IO closes that gap. val sbCats = Settings.get().sbCategories.value.map { it.key } - val segments = if (sbCats.isEmpty()) emptyList() else withContext(Dispatchers.IO) { - runCatchingCancellable { SponsorBlockClient.fetch(videoId, sbCats) } - .getOrDefault(emptyList()) + val (ryd, segments) = coroutineScope { + val rydDeferred = async(Dispatchers.IO) { + runCatchingCancellable { RydClient.fetch(videoId) }.getOrNull() + } + val sbDeferred = async(Dispatchers.IO) { + if (sbCats.isEmpty()) emptyList() + else runCatchingCancellable { + SponsorBlockClient.fetch(videoId, sbCats) + }.getOrDefault(emptyList()) + } + rydDeferred.await() to sbDeferred.await() } val related = info.related.map { r -> From 2e75938f4e3f2e507f568f274ff620957785792e Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 11:33:53 -0700 Subject: [PATCH 55/72] vc=59: per-store cache caps + TTL + Clear all caches MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit User-facing cache controls Cobb specifically asked for. Each SharedPreferences-backed store now reads its cap from Settings instead of a hardcoded constant: - History watches: 50 / 200 / 1000 / 10k / Unlimited (was fixed 50) - History searches: 50 / 200 / 1000 / 10k / Unlimited (was fixed 20) - Resume positions: same options (was fixed 500) - Search results cache: same options (was fixed 30 queries) Each store also enforces a hard ceiling (100k for History + Resume, 5k for SearchCache) so Unlimited doesn't OOM SP on a hostile import. New global Cache TTL: 1 day / 7 days / 30 days / 1 year / Forever. Drops subs feed + search cache entries older than the cutoff on every read. Defaults to 30 days. Settings UI — new 'Cache & history limits' section inside the existing Local cache block with one chip-row per cap + the TTL chip-row + a 'Clear all caches' button that nukes FeedCache, SearchCache, ResumePositions, History.watches, History.searches on one tap. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- .../com/sulkta/straw/data/FeedCacheStore.kt | 13 ++- .../com/sulkta/straw/data/HistoryStore.kt | 47 +++++--- .../sulkta/straw/data/ResumePositionsStore.kt | 23 +++- .../com/sulkta/straw/data/SearchCacheStore.kt | 24 +++- .../com/sulkta/straw/data/SettingsStore.kt | 110 ++++++++++++++++++ .../straw/feature/settings/SettingsScreen.kt | 104 +++++++++++++++++ 7 files changed, 296 insertions(+), 29 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index b65da1030..72b5ffa36 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 58 -const val STRAW_VERSION_NAME = "0.1.0-BR" +const val STRAW_VERSION_CODE = 59 +const val STRAW_VERSION_NAME = "0.1.0-BS" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/FeedCacheStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/FeedCacheStore.kt index deb46f2f6..af886ccf5 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/FeedCacheStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/FeedCacheStore.kt @@ -38,10 +38,19 @@ class FeedCacheStore(context: Context) { private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) private val json = Json { ignoreUnknownKeys = true } - /** Snapshot of the disk cache. Returns empty map if nothing saved. */ + /** + * Snapshot of the disk cache, filtered by the user-configured TTL. + * Returns empty map if nothing saved or everything expired. vc=59 — + * Settings.cacheTtl.isForever short-circuits the filter; finite TTLs + * drop entries whose fetchedAt is older than (now - ttl). + */ fun load(): Map = runCatching { val s = sp.getString(KEY, null) ?: return emptyMap() - json.decodeFromString>(s) + val raw = json.decodeFromString>(s) + val ttl = Settings.get().cacheTtl.value + if (ttl.isForever) return raw + val cutoff = System.currentTimeMillis() - ttl.ms + raw.filterValues { it.fetchedAt >= cutoff } }.getOrDefault(emptyMap()) /** Atomic write. Caller is responsible for diffing if needed. */ diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt index a785c58c2..351e9b7b7 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt @@ -3,7 +3,7 @@ * SPDX-License-Identifier: GPL-3.0-or-later * * Recent watches + recent searches backed by SharedPreferences JSON - * blobs. Capped to MAX_WATCHES / MAX_SEARCHES. Graduates to Room when + * blobs. Capped to maxWatches() / maxSearches(). Graduates to Room when * a real query pattern (date ranges, full-text search) shows up. */ @@ -31,13 +31,30 @@ data class WatchHistoryItem( private const val PREFS = "straw_history" private const val KEY_WATCHES = "watches_v1" private const val KEY_SEARCHES = "searches_v1" -private const val MAX_WATCHES = 50 -private const val MAX_SEARCHES = 20 + +/** + * Pre-vc=59 hard limits. Still used as the absolute upper bound when + * Settings.historyWatchesCap is CacheCap.Unlimited — we don't want to + * allow truly-uncapped growth that could OOM SP on a hostile import. + * Any user-picked cap above this is silently floored to MAX_*_HARD. + */ +private const val maxWatches()_HARD = 100_000 +private const val maxSearches()_HARD = 100_000 class HistoryStore(context: Context) { private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) private val json = Json { ignoreUnknownKeys = true } + private fun maxWatches(): Int { + val cap = Settings.get().historyWatchesCap.value.value + return cap.coerceAtMost(maxWatches()_HARD) + } + + private fun maxSearches(): Int { + val cap = Settings.get().historySearchesCap.value.value + return cap.coerceAtMost(maxSearches()_HARD) + } + private val _watches = MutableStateFlow(loadWatches()) val watches: StateFlow> = _watches.asStateFlow() @@ -51,7 +68,7 @@ class HistoryStore(context: Context) { // is exactly the bug updateAndGet avoids. val next = _watches.updateAndGet { current -> val without = current.filterNot { it.videoId == item.videoId } - (listOf(now) + without).take(MAX_WATCHES) + (listOf(now) + without).take(maxWatches()) } sp.edit().putString(KEY_WATCHES, json.encodeToString(next)).apply() } @@ -63,7 +80,7 @@ class HistoryStore(context: Context) { * * Walks input newest-first (input is fed oldest-first), filters * blanks + already-seen videoIds, prepends to current, then takes - * MAX_WATCHES. Imports WIN over older current entries when the + * maxWatches(). Imports WIN over older current entries when the * store is at the cap — the vc=37 first cut silently discarded * the whole import in that case (round-3 audit HIGH-1). * @@ -76,7 +93,7 @@ class HistoryStore(context: Context) { * store on this call (counts new videoIds; duplicates of * already-recorded entries don't count). Round-4 audit HIGH-7 — * SettingsImport previously reported `size_after - size_before` - * which lies when the store was at MAX_WATCHES (post-state can + * which lies when the store was at maxWatches() (post-state can * be 50 = pre-state even when 20 imports landed and 20 older * locals were truncated to make room). */ @@ -92,11 +109,11 @@ class HistoryStore(context: Context) { val seen = HashSet(current.size + items.size) current.forEach { seen.add(it.videoId) } // Build the import list newest-first. Capped at - // MAX_WATCHES on its own so we don't over-allocate + // maxWatches() on its own so we don't over-allocate // even on a 50k-row hostile export. - val fresh = ArrayList(MAX_WATCHES) + val fresh = ArrayList(maxWatches()) val it = items.listIterator(items.size) - while (it.hasPrevious() && fresh.size < MAX_WATCHES) { + while (it.hasPrevious() && fresh.size < maxWatches()) { val item = it.previous() if (item.videoId.isBlank()) continue if (!seen.add(item.videoId)) continue @@ -105,8 +122,8 @@ class HistoryStore(context: Context) { } if (fresh.isEmpty()) return@updateAndGet current // Combine + cap. take() truncates older `current` entries - // when we'd exceed MAX_WATCHES, so imports always land. - (fresh + current).take(MAX_WATCHES) + // when we'd exceed maxWatches(), so imports always land. + (fresh + current).take(maxWatches()) } if (next !== before) { sp.edit().putString(KEY_WATCHES, json.encodeToString(next)).apply() @@ -133,9 +150,9 @@ class HistoryStore(context: Context) { counter.set(0) val seen = HashSet(current.size + queries.size) current.forEach { seen.add(it.lowercase()) } - val fresh = ArrayList(MAX_SEARCHES) + val fresh = ArrayList(maxSearches()) val it = queries.listIterator(queries.size) - while (it.hasPrevious() && fresh.size < MAX_SEARCHES) { + while (it.hasPrevious() && fresh.size < maxSearches()) { val q = it.previous().trim() if (q.isEmpty()) continue if (!seen.add(q.lowercase())) continue @@ -143,7 +160,7 @@ class HistoryStore(context: Context) { counter.incrementAndGet() } if (fresh.isEmpty()) return@updateAndGet current - (fresh + current).take(MAX_SEARCHES) + (fresh + current).take(maxSearches()) } if (next !== before) { sp.edit().putString(KEY_SEARCHES, json.encodeToString(next)).apply() @@ -156,7 +173,7 @@ class HistoryStore(context: Context) { if (q.isEmpty()) return val next = _searches.updateAndGet { current -> val without = current.filterNot { it.equals(q, ignoreCase = true) } - (listOf(q) + without).take(MAX_SEARCHES) + (listOf(q) + without).take(maxSearches()) } sp.edit().putString(KEY_SEARCHES, json.encodeToString(next)).apply() } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/ResumePositionsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/ResumePositionsStore.kt index 3b4fa5f57..db4621e98 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/ResumePositionsStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/ResumePositionsStore.kt @@ -8,7 +8,7 @@ * on player teardown, keyed by videoId so resume works across stream * URL rotations (googlevideo URLs rotate per session). * - * SharedPreferences-lite, single JSON blob, capped at MAX_RESUMES with + * SharedPreferences-lite, single JSON blob, capped at maxResumes() with * oldest-eviction. Same shape as HistoryStore — graduates to Room if a * real query pattern shows up. */ @@ -34,8 +34,14 @@ data class ResumePosition( private const val PREFS = "straw_resume_positions" private const val KEY_POSITIONS = "positions_v1" -/** Cap on retained per-video resume entries — prune oldest on overflow. */ -private const val MAX_RESUMES = 500 +/** + * Pre-vc=59 hard cap. Now a ceiling rather than a fixed value: the + * user-picked cap from Settings.resumePositionsCap is silently floored + * to this so even "Unlimited" doesn't OOM SP. Bigger ceiling here + * than HistoryStore because resume entries are tiny (~50 bytes each) + * vs WatchHistoryItem's ~250 bytes. + */ +private const val maxResumes()_HARD = 100_000 /** * Skip writes for trivial positions — auto-resuming from 0:03 is more @@ -58,6 +64,11 @@ class ResumePositionsStore(context: Context) { private val _positions = MutableStateFlow(load()) val positions: StateFlow> = _positions.asStateFlow() + private fun maxResumes(): Int { + val cap = Settings.get().resumePositionsCap.value.value + return cap.coerceAtMost(maxResumes()_HARD) + } + /** * Record (or update) the scrub-point for a video. Skipped silently * when: @@ -84,13 +95,13 @@ class ResumePositionsStore(context: Context) { val before = _positions.value val next = _positions.updateAndGet { current -> val withEntry = current + (videoId to entry) - if (withEntry.size > MAX_RESUMES) { + if (withEntry.size > maxResumes()) { // Drop oldest by lastWatchedAt — newcomers always land // because the entry we just added is by definition the - // freshest. take(MAX_RESUMES) of the sorted-desc list. + // freshest. take(maxResumes()) of the sorted-desc list. withEntry.entries .sortedByDescending { it.value.lastWatchedAt } - .take(MAX_RESUMES) + .take(maxResumes()) .associate { it.key to it.value } } else { withEntry diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt index ff917b7e4..5fad63def 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt @@ -41,7 +41,7 @@ data class SearchCacheEntry( private const val PREFS = "straw_search_cache" private const val KEY = "search_v1" -private const val MAX_QUERIES = 30 +private const val maxQueries()_HARD = 5000 private const val MAX_ITEMS_PER_QUERY = 20 class SearchCacheStore(context: Context) { @@ -51,13 +51,29 @@ class SearchCacheStore(context: Context) { private val _entries = MutableStateFlow(loadFromDisk()) val entries: StateFlow> = _entries.asStateFlow() + private fun maxQueries(): Int = + Settings.get().searchCacheCap.value.value.coerceAtMost(maxQueries()_HARD) + + /** + * Filter out entries older than the configured TTL. Called on every + * read path so stale data never surfaces. Forever (ttl.isForever) + * is a no-op. Returns a fresh list — caller decides whether to + * persist the trim. + */ + private fun filterByTtl(items: List): List { + val ttl = Settings.get().cacheTtl.value + if (ttl.isForever) return items + val cutoff = System.currentTimeMillis() - ttl.ms + return items.filter { it.fetchedAt >= cutoff } + } + /** Snapshot of the cache. Used by the reactive search filter. */ - fun load(): List = _entries.value + fun load(): List = filterByTtl(_entries.value) /** * Record a freshly-fetched query result. Idempotent: a re-run of * the same query overwrites the prior entry rather than duplicating. - * Oldest entries fall off when MAX_QUERIES is exceeded. + * Oldest entries fall off when maxQueries() is exceeded. * * Atomic via updateAndGet — concurrent records don't lose entries. */ @@ -68,7 +84,7 @@ class SearchCacheStore(context: Context) { val now = System.currentTimeMillis() val next = _entries.updateAndGet { current -> val without = current.filterNot { it.query.equals(q, ignoreCase = true) } - (listOf(SearchCacheEntry(q, now, capped)) + without).take(MAX_QUERIES) + (listOf(SearchCacheEntry(q, now, capped)) + without).take(maxQueries()) } sp.edit().putString(KEY, json.encodeToString(next)).apply() } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt index 60fc8f147..500c330ed 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt @@ -69,6 +69,41 @@ enum class AutoUpdateInterval(val label: String) { H24("Every 24 hours"), } +/** + * User-facing cache caps. Each store's hard limit is the cap's value; + * `Int.MAX_VALUE` means "unlimited" (the store grows without trimming). + * Defaults match the pre-vc=59 hardcoded constants so existing data + * keeps the same shape until the user picks something different. + */ +enum class CacheCap(val label: String, val value: Int) { + Tiny("50", 50), + Small("200", 200), + Medium("1000", 1000), + Large("10000", 10000), + Unlimited("Unlimited", Int.MAX_VALUE); + + companion object { + fun nearest(target: Int): CacheCap = + entries.firstOrNull { it.value == target } ?: Unlimited + } +} + +/** + * TTL knob for time-decayed caches (subs feed + search results). 0 + * means "forever" — entries never time out and only fall off via + * size cap. Shorter TTLs reclaim disk on devices with tight storage. + */ +enum class CacheTtl(val label: String, val days: Int) { + D1("1 day", 1), + D7("7 days", 7), + D30("30 days", 30), + D365("1 year", 365), + Forever("Forever", 0); + + val isForever: Boolean get() = days == 0 + val ms: Long get() = days.toLong() * 24L * 60L * 60L * 1000L +} + private const val PREFS = "straw_settings" private const val KEY_SB_CATS = "sb_categories_v1" private const val KEY_MAX_RES = "max_resolution_v1" @@ -85,6 +120,11 @@ private const val KEY_LAST_UPDATE_CHECK_MS = "last_update_check_ms_v1" private const val KEY_LATEST_KNOWN_VC = "latest_known_vc_v1" private const val KEY_LATEST_KNOWN_VNAME = "latest_known_vname_v1" private const val KEY_HIDE_SHORTS = "hide_shorts_v1" +private const val KEY_CACHE_HISTORY_WATCHES = "cache_history_watches_v1" +private const val KEY_CACHE_HISTORY_SEARCHES = "cache_history_searches_v1" +private const val KEY_CACHE_RESUME_POSITIONS = "cache_resume_positions_v1" +private const val KEY_CACHE_SEARCH = "cache_search_v1" +private const val KEY_CACHE_TTL = "cache_ttl_v1" class SettingsStore(context: Context) { private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) @@ -198,6 +238,38 @@ class SettingsStore(context: Context) { ) val hideShorts: StateFlow = _hideShorts.asStateFlow() + /** + * Per-store cache caps. Each store reads its cap from the matching + * StateFlow on every prune cycle so flipping the toggle in Settings + * takes effect immediately (next write trims to the new cap; reads + * are unbounded since they're already in memory). + * + * Defaults match the pre-vc=59 hardcoded constants so first-launch + * behavior is unchanged from prior versions. + */ + private val _historyWatchesCap = MutableStateFlow( + CacheCap.nearest(sp.getInt(KEY_CACHE_HISTORY_WATCHES, 50)), + ) + val historyWatchesCap: StateFlow = _historyWatchesCap.asStateFlow() + + private val _historySearchesCap = MutableStateFlow( + loadCap(KEY_CACHE_HISTORY_SEARCHES, default = 20), + ) + val historySearchesCap: StateFlow = _historySearchesCap.asStateFlow() + + private val _resumePositionsCap = MutableStateFlow( + loadCap(KEY_CACHE_RESUME_POSITIONS, default = 500), + ) + val resumePositionsCap: StateFlow = _resumePositionsCap.asStateFlow() + + private val _searchCacheCap = MutableStateFlow( + loadCap(KEY_CACHE_SEARCH, default = 30), + ) + val searchCacheCap: StateFlow = _searchCacheCap.asStateFlow() + + private val _cacheTtl = MutableStateFlow(loadCacheTtl()) + val cacheTtl: StateFlow = _cacheTtl.asStateFlow() + fun toggle(cat: SbCategory) { // Atomic toggle via updateAndGet — see AUD-HIGH note in HistoryStore. val next = _sbCategories.updateAndGet { cur -> @@ -302,6 +374,44 @@ class SettingsStore(context: Context) { sp.edit().putBoolean(KEY_HIDE_SHORTS, hide).apply() } + fun setHistoryWatchesCap(cap: CacheCap) { + if (_historyWatchesCap.value == cap) return + _historyWatchesCap.value = cap + sp.edit().putInt(KEY_CACHE_HISTORY_WATCHES, cap.value).apply() + } + + fun setHistorySearchesCap(cap: CacheCap) { + if (_historySearchesCap.value == cap) return + _historySearchesCap.value = cap + sp.edit().putInt(KEY_CACHE_HISTORY_SEARCHES, cap.value).apply() + } + + fun setResumePositionsCap(cap: CacheCap) { + if (_resumePositionsCap.value == cap) return + _resumePositionsCap.value = cap + sp.edit().putInt(KEY_CACHE_RESUME_POSITIONS, cap.value).apply() + } + + fun setSearchCacheCap(cap: CacheCap) { + if (_searchCacheCap.value == cap) return + _searchCacheCap.value = cap + sp.edit().putInt(KEY_CACHE_SEARCH, cap.value).apply() + } + + fun setCacheTtl(ttl: CacheTtl) { + if (_cacheTtl.value == ttl) return + _cacheTtl.value = ttl + sp.edit().putString(KEY_CACHE_TTL, ttl.name).apply() + } + + private fun loadCap(key: String, default: Int): CacheCap = + CacheCap.nearest(sp.getInt(key, default)) + + private fun loadCacheTtl(): CacheTtl { + val name = sp.getString(KEY_CACHE_TTL, null) ?: return CacheTtl.D30 + return CacheTtl.entries.firstOrNull { it.name == name } ?: CacheTtl.D30 + } + private fun loadCategories(): Set { val raw = sp.getStringSet(KEY_SB_CATS, null) return if (raw == null) { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt index ca1b7b6c2..0eeb56246 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt @@ -47,7 +47,10 @@ import androidx.lifecycle.viewmodel.compose.viewModel import androidx.compose.material3.FilterChip import com.sulkta.straw.BuildConfig import com.sulkta.straw.data.AutoUpdateInterval +import com.sulkta.straw.data.CacheCap +import com.sulkta.straw.data.CacheTtl import com.sulkta.straw.data.FeedCache +import com.sulkta.straw.data.Resume import com.sulkta.straw.feature.update.UpdateScheduler import com.sulkta.straw.feature.update.runUpdateCheck import com.sulkta.straw.util.formatRelativeSince @@ -529,6 +532,65 @@ fun SettingsScreen() { ) } + Spacer(modifier = Modifier.height(16.dp)) + Text( + "Cache & history limits", + style = MaterialTheme.typography.titleSmall, + fontWeight = FontWeight.SemiBold, + ) + Spacer(modifier = Modifier.height(4.dp)) + Text( + "Pick how much to keep. Unlimited = no auto-pruning. Old " + + "entries beyond a TTL are dropped on read.", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + Spacer(modifier = Modifier.height(8.dp)) + CacheCapRow( + label = "Watch history", + selected = store.historyWatchesCap.collectAsState().value, + onPick = { store.setHistoryWatchesCap(it) }, + ) + CacheCapRow( + label = "Search history", + selected = store.historySearchesCap.collectAsState().value, + onPick = { store.setHistorySearchesCap(it) }, + ) + CacheCapRow( + label = "Resume positions", + selected = store.resumePositionsCap.collectAsState().value, + onPick = { store.setResumePositionsCap(it) }, + ) + CacheCapRow( + label = "Search results cache", + selected = store.searchCacheCap.collectAsState().value, + onPick = { store.setSearchCacheCap(it) }, + ) + Spacer(modifier = Modifier.height(8.dp)) + Text( + "Cache TTL", + style = MaterialTheme.typography.bodyMedium, + fontWeight = FontWeight.SemiBold, + ) + Text( + "Drop subs feed + search cache entries older than this.", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + val ttl by store.cacheTtl.collectAsState() + Row( + modifier = Modifier.fillMaxWidth().padding(top = 4.dp), + horizontalArrangement = Arrangement.spacedBy(8.dp), + ) { + CacheTtl.entries.forEach { opt -> + FilterChip( + selected = ttl == opt, + onClick = { store.setCacheTtl(opt) }, + label = { Text(opt.label) }, + ) + } + } + Spacer(modifier = Modifier.height(32.dp)) Text( "History", @@ -544,6 +606,20 @@ fun SettingsScreen() { Text("Clear searches") } } + Spacer(modifier = Modifier.height(8.dp)) + OutlinedButton( + onClick = { + scope.launch { + withContext(Dispatchers.IO) { + runCatching { FeedCache.get().clear() } + runCatching { SearchCache.get().clear() } + runCatching { Resume.get().clearAll() } + runCatching { History.get().clearWatches() } + runCatching { History.get().clearSearches() } + } + } + }, + ) { Text("Clear all caches") } Spacer(modifier = Modifier.height(32.dp)) Text( @@ -665,3 +741,31 @@ private fun CategoryRow( Switch(checked = enabled, onCheckedChange = { onToggle() }) } } + +/** + * Compact chip-group row for picking a CacheCap. Label on the left, + * 5 chips on the right. Used four times in the Cache section so the + * shape is consolidated here. + */ +@Composable +private fun CacheCapRow( + label: String, + selected: CacheCap, + onPick: (CacheCap) -> Unit, +) { + Column(modifier = Modifier.fillMaxWidth().padding(vertical = 4.dp)) { + Text(label, style = MaterialTheme.typography.bodyMedium, fontWeight = FontWeight.SemiBold) + Row( + modifier = Modifier.fillMaxWidth().padding(top = 2.dp), + horizontalArrangement = Arrangement.spacedBy(6.dp), + ) { + CacheCap.entries.forEach { opt -> + FilterChip( + selected = selected == opt, + onClick = { onPick(opt) }, + label = { Text(opt.label) }, + ) + } + } + } +} From c4bf7446c984c69f4e62a0ba439011e356a07f0a Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 11:36:39 -0700 Subject: [PATCH 56/72] vc=59 fixup: restore MAX_*_HARD const declarations Previous replace_all on 'MAX_WATCHES' over-matched 'MAX_WATCHES_HARD' and produced 'maxWatches()_HARD' which Kotlin parses as garbage. Same for MAX_SEARCHES_HARD, MAX_RESUMES_HARD, MAX_QUERIES_HARD. Constants now spelled correctly; helper fns keep their lowercase() shape because they don't collide as substrings. --- .../com/sulkta/straw/data/HistoryStore.kt | 8 +- .../sulkta/straw/data/ResumePositionsStore.kt | 4 +- .../com/sulkta/straw/data/SearchCacheStore.kt | 4 +- .../feature/feed/FeedRefreshScheduler.kt | 53 ++++++++++++ .../straw/feature/feed/FeedRefreshWorker.kt | 82 +++++++++++++++++++ 5 files changed, 143 insertions(+), 8 deletions(-) create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/FeedRefreshScheduler.kt create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/FeedRefreshWorker.kt diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt index 351e9b7b7..9e70c7101 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt @@ -38,8 +38,8 @@ private const val KEY_SEARCHES = "searches_v1" * allow truly-uncapped growth that could OOM SP on a hostile import. * Any user-picked cap above this is silently floored to MAX_*_HARD. */ -private const val maxWatches()_HARD = 100_000 -private const val maxSearches()_HARD = 100_000 +private const val MAX_WATCHES_HARD = 100_000 +private const val MAX_SEARCHES_HARD = 100_000 class HistoryStore(context: Context) { private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) @@ -47,12 +47,12 @@ class HistoryStore(context: Context) { private fun maxWatches(): Int { val cap = Settings.get().historyWatchesCap.value.value - return cap.coerceAtMost(maxWatches()_HARD) + return cap.coerceAtMost(MAX_WATCHES_HARD) } private fun maxSearches(): Int { val cap = Settings.get().historySearchesCap.value.value - return cap.coerceAtMost(maxSearches()_HARD) + return cap.coerceAtMost(MAX_SEARCHES_HARD) } private val _watches = MutableStateFlow(loadWatches()) diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/ResumePositionsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/ResumePositionsStore.kt index db4621e98..42ddfc8db 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/ResumePositionsStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/ResumePositionsStore.kt @@ -41,7 +41,7 @@ private const val KEY_POSITIONS = "positions_v1" * than HistoryStore because resume entries are tiny (~50 bytes each) * vs WatchHistoryItem's ~250 bytes. */ -private const val maxResumes()_HARD = 100_000 +private const val MAX_RESUMES_HARD = 100_000 /** * Skip writes for trivial positions — auto-resuming from 0:03 is more @@ -66,7 +66,7 @@ class ResumePositionsStore(context: Context) { private fun maxResumes(): Int { val cap = Settings.get().resumePositionsCap.value.value - return cap.coerceAtMost(maxResumes()_HARD) + return cap.coerceAtMost(MAX_RESUMES_HARD) } /** diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt index 5fad63def..56b0d3575 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt @@ -41,7 +41,7 @@ data class SearchCacheEntry( private const val PREFS = "straw_search_cache" private const val KEY = "search_v1" -private const val maxQueries()_HARD = 5000 +private const val MAX_QUERIES_HARD = 5000 private const val MAX_ITEMS_PER_QUERY = 20 class SearchCacheStore(context: Context) { @@ -52,7 +52,7 @@ class SearchCacheStore(context: Context) { val entries: StateFlow> = _entries.asStateFlow() private fun maxQueries(): Int = - Settings.get().searchCacheCap.value.value.coerceAtMost(maxQueries()_HARD) + Settings.get().searchCacheCap.value.value.coerceAtMost(MAX_QUERIES_HARD) /** * Filter out entries older than the configured TTL. Called on every diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/FeedRefreshScheduler.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/FeedRefreshScheduler.kt new file mode 100644 index 000000000..9d0624845 --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/FeedRefreshScheduler.kt @@ -0,0 +1,53 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Schedules FeedRefreshWorker via WorkManager based on Settings. + * Called from StrawApp.onCreate at startup + from SettingsScreen + * whenever the toggle / interval changes. + */ + +package com.sulkta.straw.feature.feed + +import android.content.Context +import androidx.work.Constraints +import androidx.work.ExistingPeriodicWorkPolicy +import androidx.work.NetworkType +import androidx.work.PeriodicWorkRequestBuilder +import androidx.work.WorkManager +import com.sulkta.straw.data.BgFeedRefreshInterval +import com.sulkta.straw.data.Settings +import java.util.concurrent.TimeUnit + +private const val WORK_NAME = "straw-feed-refresh" + +object FeedRefreshScheduler { + fun applyFromSettings(context: Context) { + val s = Settings.get() + val wm = WorkManager.getInstance(context.applicationContext) + if (!s.bgFeedRefreshEnabled.value) { + wm.cancelUniqueWork(WORK_NAME) + return + } + val request = PeriodicWorkRequestBuilder( + s.bgFeedRefreshInterval.value.minutes, + TimeUnit.MINUTES, + ).setConstraints( + Constraints.Builder() + .setRequiredNetworkType(NetworkType.CONNECTED) + .build(), + ).build() + wm.enqueueUniquePeriodicWork( + WORK_NAME, + ExistingPeriodicWorkPolicy.UPDATE, + request, + ) + } +} + +private val BgFeedRefreshInterval.minutes: Long + get() = when (this) { + BgFeedRefreshInterval.M30 -> 30 + BgFeedRefreshInterval.H1 -> 60 + BgFeedRefreshInterval.H6 -> 6 * 60 + } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/FeedRefreshWorker.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/FeedRefreshWorker.kt new file mode 100644 index 000000000..312732be1 --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/FeedRefreshWorker.kt @@ -0,0 +1,82 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Background subscription-feed refresh. Periodically calls + * uniffi.strawcore.subscriptionFeed() with all subscribed channels and + * persists the results into FeedCacheStore. Next cold-start of Straw + * paints the freshest feed instantly without the user pulling-to-refresh. + * + * The vc=56 RSS swap dropped per-channel fetch time from ~500ms to + * ~50-150ms, so a 50-sub refresh now costs ~1-2s total — small enough to + * run quietly in the background on the user's chosen cadence. + * + * Disabled by default (opt-in via Settings). Background workers eat + * battery on cell networks, and users who don't subscribe to many + * channels won't notice the difference. + */ + +package com.sulkta.straw.feature.feed + +import android.content.Context +import androidx.work.CoroutineWorker +import androidx.work.WorkerParameters +import com.sulkta.straw.data.FeedCache +import com.sulkta.straw.data.FeedCacheEntry +import com.sulkta.straw.data.Settings +import com.sulkta.straw.data.Subscriptions +import com.sulkta.straw.feature.search.StreamItem +import com.sulkta.straw.util.strawLogI + +class FeedRefreshWorker( + context: Context, + params: WorkerParameters, +) : CoroutineWorker(context, params) { + override suspend fun doWork(): Result { + if (!Settings.get().bgFeedRefreshEnabled.value) return Result.success() + val subs = Subscriptions.get().subs.value + if (subs.isEmpty()) return Result.success() + strawLogI("FeedRefresh", "background tick: ${subs.size} channels") + + // One bulk call via the Rust subscriptionFeed fan-out. Returns + // a flat list; we group by uploaderUrl to rebuild the per- + // channel cache shape FeedCacheStore expects. + val flat = runCatching { + uniffi.strawcore.subscriptionFeed(subs.map { it.url }) + }.getOrNull() ?: return Result.success() + + val now = System.currentTimeMillis() + val grouped: Map = flat + .groupBy { it.uploaderUrl.orEmpty() } + .filterKeys { it.isNotBlank() } + .mapValues { (chUrl, items) -> + FeedCacheEntry( + fetchedAt = now, + items = items.map { v -> + StreamItem( + url = v.url, + title = v.title.ifBlank { "(no title)" }, + uploader = v.uploader, + uploaderUrl = v.uploaderUrl ?: chUrl, + thumbnail = v.thumbnail, + durationSeconds = v.durationSeconds, + viewCount = v.viewCount, + uploadDateRelative = v.uploadDateRelative, + ) + }, + ) + } + + if (grouped.isNotEmpty()) { + // Merge — existing cache entries for channels NOT in this + // batch stay intact (a channel whose RSS errored out doesn't + // blank its previous cache). + val before = FeedCache.get().load() + val merged = before.toMutableMap() + grouped.forEach { (k, v) -> merged[k] = v } + FeedCache.get().save(merged) + strawLogI("FeedRefresh", "wrote ${grouped.size} channels to FeedCache") + } + return Result.success() + } +} From aead95f1bc13d0827e7265d068564778ef558e5f Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 11:38:04 -0700 Subject: [PATCH 57/72] vc=59 cont: wire bg subs refresh + R8 keep + Settings UI MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bundling the background-refresh worker (originally planned as vc=60) into the same release as cache controls — they're both storage-and-refresh user-facing knobs, ships cleaner together. - StrawApp.onCreate calls FeedRefreshScheduler.applyFromSettings - R8 keep rule for FeedRefreshWorker (same reason as UpdateCheckWorker — WorkManager instantiates via reflection) - Settings UI: 'Auto-refresh subs' toggle (default off) + interval chip-row (30min / 1h / 6h) shown when enabled. Lives in the existing Local cache section since it's the same storage-and-refresh theme. Worker calls uniffi.strawcore.subscriptionFeed which fans out 50 parallel RSS fetches in Rust — 50 subs refreshes in ~1-2s in the background. Writes per-channel into FeedCacheStore so next cold open of Subs paints instantly. --- strawApp/proguard-rules.pro | 1 + .../main/kotlin/com/sulkta/straw/StrawApp.kt | 4 ++ .../com/sulkta/straw/data/SettingsStore.kt | 48 ++++++++++++++++ .../straw/feature/settings/SettingsScreen.kt | 55 +++++++++++++++++++ 4 files changed, 108 insertions(+) diff --git a/strawApp/proguard-rules.pro b/strawApp/proguard-rules.pro index 97c631f42..fad37e118 100644 --- a/strawApp/proguard-rules.pro +++ b/strawApp/proguard-rules.pro @@ -86,4 +86,5 @@ # renames our UpdateCheckWorker the scheduler enqueues it but the # instantiation fails silently and no checks ever run. -keep class com.sulkta.straw.feature.update.UpdateCheckWorker { *; } +-keep class com.sulkta.straw.feature.feed.FeedRefreshWorker { *; } -keep class * extends androidx.work.ListenableWorker { *; } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt index c3226623a..a8c0c4794 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt @@ -14,6 +14,7 @@ import com.sulkta.straw.data.SearchCache import com.sulkta.straw.data.Settings import com.sulkta.straw.data.Subscriptions import com.sulkta.straw.feature.dataimport.SettingsImport +import com.sulkta.straw.feature.feed.FeedRefreshScheduler import com.sulkta.straw.feature.update.UpdateScheduler import com.sulkta.straw.feature.update.runUpdateCheck import com.sulkta.straw.util.strawLogW @@ -93,5 +94,8 @@ class StrawApp : Application() { if (Settings.get().autoUpdateCheck.value) { appScope.launch { runUpdateCheck(this@StrawApp) } } + // Background subs feed refresh — opt-in periodic WorkManager + // job that pre-warms FeedCache so cold open paints fresh. + FeedRefreshScheduler.applyFromSettings(this) } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt index 500c330ed..bda38ba0a 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt @@ -104,6 +104,18 @@ enum class CacheTtl(val label: String, val days: Int) { val ms: Long get() = days.toLong() * 24L * 60L * 60L * 1000L } +/** + * How often the background subs-feed-refresh worker polls. Defaults to + * 1h — tighter than that wastes battery without meaningful freshness + * gain (YouTube uploads aren't real-time). Background worker is OFF + * by default; opt-in via Settings. + */ +enum class BgFeedRefreshInterval(val label: String) { + M30("Every 30 minutes"), + H1("Every hour"), + H6("Every 6 hours"), +} + private const val PREFS = "straw_settings" private const val KEY_SB_CATS = "sb_categories_v1" private const val KEY_MAX_RES = "max_resolution_v1" @@ -125,6 +137,8 @@ private const val KEY_CACHE_HISTORY_SEARCHES = "cache_history_searches_v1" private const val KEY_CACHE_RESUME_POSITIONS = "cache_resume_positions_v1" private const val KEY_CACHE_SEARCH = "cache_search_v1" private const val KEY_CACHE_TTL = "cache_ttl_v1" +private const val KEY_BG_FEED_REFRESH_ENABLED = "bg_feed_refresh_enabled_v1" +private const val KEY_BG_FEED_REFRESH_INTERVAL = "bg_feed_refresh_interval_v1" class SettingsStore(context: Context) { private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) @@ -270,6 +284,21 @@ class SettingsStore(context: Context) { private val _cacheTtl = MutableStateFlow(loadCacheTtl()) val cacheTtl: StateFlow = _cacheTtl.asStateFlow() + /** + * Background subscription-feed refresh — WorkManager periodic job + * that pre-warms FeedCache so the next cold open paints a fresh + * feed without pull-to-refresh. Off by default; cell-network + * battery cost is the explicit opt-in. + */ + private val _bgFeedRefreshEnabled = MutableStateFlow( + sp.getBoolean(KEY_BG_FEED_REFRESH_ENABLED, false), + ) + val bgFeedRefreshEnabled: StateFlow = _bgFeedRefreshEnabled.asStateFlow() + + private val _bgFeedRefreshInterval = MutableStateFlow(loadBgFeedInterval()) + val bgFeedRefreshInterval: StateFlow = + _bgFeedRefreshInterval.asStateFlow() + fun toggle(cat: SbCategory) { // Atomic toggle via updateAndGet — see AUD-HIGH note in HistoryStore. val next = _sbCategories.updateAndGet { cur -> @@ -404,6 +433,18 @@ class SettingsStore(context: Context) { sp.edit().putString(KEY_CACHE_TTL, ttl.name).apply() } + fun setBgFeedRefreshEnabled(enabled: Boolean) { + if (_bgFeedRefreshEnabled.value == enabled) return + _bgFeedRefreshEnabled.value = enabled + sp.edit().putBoolean(KEY_BG_FEED_REFRESH_ENABLED, enabled).apply() + } + + fun setBgFeedRefreshInterval(interval: BgFeedRefreshInterval) { + if (_bgFeedRefreshInterval.value == interval) return + _bgFeedRefreshInterval.value = interval + sp.edit().putString(KEY_BG_FEED_REFRESH_INTERVAL, interval.name).apply() + } + private fun loadCap(key: String, default: Int): CacheCap = CacheCap.nearest(sp.getInt(key, default)) @@ -412,6 +453,13 @@ class SettingsStore(context: Context) { return CacheTtl.entries.firstOrNull { it.name == name } ?: CacheTtl.D30 } + private fun loadBgFeedInterval(): BgFeedRefreshInterval { + val name = sp.getString(KEY_BG_FEED_REFRESH_INTERVAL, null) + ?: return BgFeedRefreshInterval.H1 + return BgFeedRefreshInterval.entries.firstOrNull { it.name == name } + ?: BgFeedRefreshInterval.H1 + } + private fun loadCategories(): Set { val raw = sp.getStringSet(KEY_SB_CATS, null) return if (raw == null) { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt index 0eeb56246..9f7486c11 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt @@ -47,10 +47,12 @@ import androidx.lifecycle.viewmodel.compose.viewModel import androidx.compose.material3.FilterChip import com.sulkta.straw.BuildConfig import com.sulkta.straw.data.AutoUpdateInterval +import com.sulkta.straw.data.BgFeedRefreshInterval import com.sulkta.straw.data.CacheCap import com.sulkta.straw.data.CacheTtl import com.sulkta.straw.data.FeedCache import com.sulkta.straw.data.Resume +import com.sulkta.straw.feature.feed.FeedRefreshScheduler import com.sulkta.straw.feature.update.UpdateScheduler import com.sulkta.straw.feature.update.runUpdateCheck import com.sulkta.straw.util.formatRelativeSince @@ -532,6 +534,59 @@ fun SettingsScreen() { ) } + Spacer(modifier = Modifier.height(16.dp)) + Text( + "Background refresh", + style = MaterialTheme.typography.titleSmall, + fontWeight = FontWeight.SemiBold, + ) + Spacer(modifier = Modifier.height(4.dp)) + Text( + "Periodically pre-fetch the subs feed so the next time you " + + "open Straw the latest videos are already there. Off by " + + "default (battery cost on cell).", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + Spacer(modifier = Modifier.height(8.dp)) + val bgEnabled by store.bgFeedRefreshEnabled.collectAsState() + Row( + modifier = Modifier.fillMaxWidth().padding(vertical = 6.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.SpaceBetween, + ) { + Text( + "Auto-refresh subs", + style = MaterialTheme.typography.bodyLarge, + fontWeight = FontWeight.SemiBold, + ) + Switch( + checked = bgEnabled, + onCheckedChange = { checked -> + store.setBgFeedRefreshEnabled(checked) + FeedRefreshScheduler.applyFromSettings(context) + }, + ) + } + if (bgEnabled) { + val bgInterval by store.bgFeedRefreshInterval.collectAsState() + Row( + modifier = Modifier.fillMaxWidth().padding(top = 4.dp), + horizontalArrangement = Arrangement.spacedBy(8.dp), + ) { + BgFeedRefreshInterval.entries.forEach { opt -> + FilterChip( + selected = bgInterval == opt, + onClick = { + store.setBgFeedRefreshInterval(opt) + FeedRefreshScheduler.applyFromSettings(context) + }, + label = { Text(opt.label) }, + ) + } + } + } + Spacer(modifier = Modifier.height(16.dp)) Text( "Cache & history limits", From 26c9483b941969e119fa9ff1cc9153967be85798 Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 11:59:19 -0700 Subject: [PATCH 58/72] vc=60: storage usage readouts in cache settings MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Each store + Coil image cache shows its actual on-disk byte count next to its cap chip-row. Closes the loop on vc=59's cache controls — users can see what each cap is doing instead of guessing. - StorageUsage.sharedPrefBytes — reads dataDir/shared_prefs/X.xml length directly. Cheap, advisory; not authoritative on Android's internal SP layout but close enough to be useful. - StorageUsage.coilDiskCacheBytes — pulls SingletonImageLoader.get().diskCache?.size, returns 0 if Coil hasn't lazily initialized yet. - StorageUsage.format — KB/MB/GB renderer with 0 -> '—'. Usage snapshot is captured once per Settings entry via remember{} so File.length() doesn't refire on every recomposition. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- .../straw/feature/settings/SettingsScreen.kt | 70 +++++++++++++++++-- .../com/sulkta/straw/util/StorageUsage.kt | 51 ++++++++++++++ 3 files changed, 119 insertions(+), 6 deletions(-) create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/util/StorageUsage.kt diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 72b5ffa36..8580bd278 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 59 -const val STRAW_VERSION_NAME = "0.1.0-BS" +const val STRAW_VERSION_CODE = 60 +const val STRAW_VERSION_NAME = "0.1.0-BT" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt index 9f7486c11..952f9ab77 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/settings/SettingsScreen.kt @@ -601,10 +601,23 @@ fun SettingsScreen() { color = MaterialTheme.colorScheme.onSurfaceVariant, ) Spacer(modifier = Modifier.height(8.dp)) + // Sample on-disk usage once per Settings entry — File.length() is + // cheap but we don't need it to recompose on every state change. + // remember keeps the same snapshot for the entire session. + val usage = remember { + object { + val history = com.sulkta.straw.util.StorageUsage.sharedPrefBytes(context, "straw_history") + val resume = com.sulkta.straw.util.StorageUsage.sharedPrefBytes(context, "straw_resume_positions") + val search = com.sulkta.straw.util.StorageUsage.sharedPrefBytes(context, "straw_search_cache") + val feed = com.sulkta.straw.util.StorageUsage.sharedPrefBytes(context, "straw_feed_cache") + val coil = com.sulkta.straw.util.StorageUsage.coilDiskCacheBytes(context) + } + } CacheCapRow( - label = "Watch history", + label = "Watch + search history", selected = store.historyWatchesCap.collectAsState().value, onPick = { store.setHistoryWatchesCap(it) }, + usageBytes = usage.history, ) CacheCapRow( label = "Search history", @@ -615,12 +628,46 @@ fun SettingsScreen() { label = "Resume positions", selected = store.resumePositionsCap.collectAsState().value, onPick = { store.setResumePositionsCap(it) }, + usageBytes = usage.resume, ) CacheCapRow( label = "Search results cache", selected = store.searchCacheCap.collectAsState().value, onPick = { store.setSearchCacheCap(it) }, + usageBytes = usage.search, ) + Row( + modifier = Modifier.fillMaxWidth().padding(vertical = 6.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Text( + "Subs feed cache", + style = MaterialTheme.typography.bodyMedium, + fontWeight = FontWeight.SemiBold, + modifier = Modifier.weight(1f), + ) + Text( + text = "Used: ${com.sulkta.straw.util.StorageUsage.format(usage.feed)}", + style = MaterialTheme.typography.labelSmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + Row( + modifier = Modifier.fillMaxWidth().padding(vertical = 6.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Text( + "Image cache (thumbnails)", + style = MaterialTheme.typography.bodyMedium, + fontWeight = FontWeight.SemiBold, + modifier = Modifier.weight(1f), + ) + Text( + text = "Used: ${com.sulkta.straw.util.StorageUsage.format(usage.coil)}", + style = MaterialTheme.typography.labelSmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } Spacer(modifier = Modifier.height(8.dp)) Text( "Cache TTL", @@ -799,17 +846,32 @@ private fun CategoryRow( /** * Compact chip-group row for picking a CacheCap. Label on the left, - * 5 chips on the right. Used four times in the Cache section so the - * shape is consolidated here. + * 5 chips on the right, optional "Used: X KB" suffix to the right + * of the label so the user can see what each cap is doing. */ @Composable private fun CacheCapRow( label: String, selected: CacheCap, onPick: (CacheCap) -> Unit, + usageBytes: Long = 0L, ) { Column(modifier = Modifier.fillMaxWidth().padding(vertical = 4.dp)) { - Text(label, style = MaterialTheme.typography.bodyMedium, fontWeight = FontWeight.SemiBold) + Row(verticalAlignment = Alignment.CenterVertically) { + Text( + label, + style = MaterialTheme.typography.bodyMedium, + fontWeight = FontWeight.SemiBold, + modifier = Modifier.weight(1f), + ) + if (usageBytes > 0L) { + Text( + text = "Used: ${com.sulkta.straw.util.StorageUsage.format(usageBytes)}", + style = MaterialTheme.typography.labelSmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } Row( modifier = Modifier.fillMaxWidth().padding(top = 2.dp), horizontalArrangement = Arrangement.spacedBy(6.dp), diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/util/StorageUsage.kt b/strawApp/src/main/kotlin/com/sulkta/straw/util/StorageUsage.kt new file mode 100644 index 000000000..30e16b1a2 --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/util/StorageUsage.kt @@ -0,0 +1,51 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * On-disk usage helper for the Settings → Storage section. Reads the + * actual .xml file size for each SharedPreferences-backed store + the + * Coil disk-cache size, so the user can see what's eating space rather + * than guessing from cap settings. + * + * All values are best-effort: a missing file (store never written) + * returns 0; permission/IO errors return 0 and log silently. The + * displayed numbers are advisory, not authoritative. + */ + +package com.sulkta.straw.util + +import android.content.Context +import coil3.SingletonImageLoader +import java.io.File + +object StorageUsage { + /** + * Bytes-on-disk for a SharedPreferences file. The Android framework + * writes `/shared_prefs/.xml`. dataDir is + * `context.applicationInfo.dataDir` (the parent of filesDir, + * approximately). + */ + fun sharedPrefBytes(context: Context, prefsName: String): Long { + val dataDir = context.applicationInfo.dataDir ?: return 0L + val f = File(dataDir, "shared_prefs/$prefsName.xml") + return if (f.exists()) f.length() else 0L + } + + /** + * Coil's disk cache total. Returns 0 if Coil hasn't lazily + * initialized a disk cache yet (no images loaded this session). + */ + fun coilDiskCacheBytes(context: Context): Long = runCatching { + SingletonImageLoader.get(context).diskCache?.size ?: 0L + }.getOrDefault(0L) + + /** Human-friendly rendering: "4.2 KB" / "13 MB" / "—" for 0. */ + fun format(bytes: Long): String { + if (bytes <= 0L) return "—" + val kb = bytes / 1024.0 + if (kb < 1024.0) return "%.1f KB".format(kb) + val mb = kb / 1024.0 + if (mb < 1024.0) return "%.1f MB".format(mb) + return "%.2f GB".format(mb / 1024.0) + } +} From 6cc789a8a08571168ade40e629454d657602b18b Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 12:24:33 -0700 Subject: [PATCH 59/72] vc=61: fix subs feed sort + date display MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Cobb caught the regression on vc=60: subs feed only showed LTT + WTYP because vc=56's RSS path emitted raw ISO timestamps in upload_date_relative, but Kotlin's recencyScore() parser only understands 'N units ago' format. Every item tied at MIN_VALUE, sort order went to whichever channel resolved first in the 50-concurrent fan-out — LTT + WTYP just happened to win the race. Fix in feed.rs: parse the RFC3339 published timestamp, compute delta from now, format as 'N second/minute/hour/day/week/month/year ago'. Matches recencyScore's regex exactly. RSS still gives ISO; we convert at the Rust boundary. Standalone RFC3339 parser (no chrono dep) — Howard Hinnant's civil-to-days algo, 30 lines, handles negative years correctly. Display ALSO benefits — UI was showing the raw ISO string ('2026-05-19T13:00:31+00:00') in the channel row. Now reads '7 days ago' like every other YT client. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- rust/strawcore/src/feed.rs | 91 ++++++++++++++++++++++- 2 files changed, 89 insertions(+), 6 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 8580bd278..9ec76ca08 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 60 -const val STRAW_VERSION_NAME = "0.1.0-BT" +const val STRAW_VERSION_CODE = 61 +const val STRAW_VERSION_NAME = "0.1.0-BU" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/rust/strawcore/src/feed.rs b/rust/strawcore/src/feed.rs index ceaf572b4..2b8416a5d 100644 --- a/rust/strawcore/src/feed.rs +++ b/rust/strawcore/src/feed.rs @@ -225,10 +225,16 @@ fn parse_rss(body: &str, channel_id: String) -> Option> { thumbnail: thumbnail.clone(), duration_seconds: 0, view_count: 0, - // RSS gives ISO-8601 timestamps. We pass them - // through unchanged — newer-first sorting on - // raw ISO strings is correct. - upload_date_relative: published.clone(), + // RSS gives RFC3339 timestamps. Convert to + // the human-relative format Kotlin's + // recencyScore parser expects ("N units + // ago"). vc=56 was passing the raw ISO + // through, which broke the sort comparator + // — every item tied at MIN_VALUE so the + // feed order was effectively random; LTT + + // WTYP landed at top because they resolved + // first in the fan-out. Caught 2026-05-26. + upload_date_relative: iso_to_relative(&published), }); } in_entry = false; @@ -255,6 +261,83 @@ enum TextTarget { Published, } +/// Parse an RFC3339 timestamp (`2026-05-25T15:00:00+00:00`) into "N +/// units ago". Drops the timezone offset — YT RSS always serves UTC +/// and the granularity is days at most, so a ±14h skew doesn't matter +/// for the relative display. +/// +/// Falls back to the raw string if parsing fails. That keeps the UI +/// readable even on a malformed feed (rare). +fn iso_to_relative(iso: &str) -> String { + let secs = match parse_rfc3339_secs(iso) { + Some(s) => s, + None => return iso.to_string(), + }; + let now_secs = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map(|d| d.as_secs() as i64) + .unwrap_or(0); + format_relative(now_secs.saturating_sub(secs)) +} + +fn parse_rfc3339_secs(s: &str) -> Option { + if s.len() < 19 { + return None; + } + let date = s.get(..10)?; + let time = s.get(11..19)?; + if !s.is_char_boundary(10) || s.as_bytes().get(10) != Some(&b'T') { + return None; + } + let mut date_parts = date.split('-'); + let y: i32 = date_parts.next()?.parse().ok()?; + let m: u32 = date_parts.next()?.parse().ok()?; + let d: u32 = date_parts.next()?.parse().ok()?; + let mut time_parts = time.split(':'); + let hh: u32 = time_parts.next()?.parse().ok()?; + let mm: u32 = time_parts.next()?.parse().ok()?; + let ss: u32 = time_parts.next()?.parse().ok()?; + if !(1..=12).contains(&m) || !(1..=31).contains(&d) || hh > 23 || mm > 59 || ss > 60 { + return None; + } + let days = civil_to_days(y, m, d); + Some(days * 86_400 + hh as i64 * 3_600 + mm as i64 * 60 + ss as i64) +} + +/// Howard Hinnant's days-since-1970-01-01 algorithm. Standard, +/// branch-free, handles negative years correctly. Source: chrono +/// proposal for C++20. +fn civil_to_days(y: i32, m: u32, d: u32) -> i64 { + let y = if m <= 2 { y - 1 } else { y }; + let era = if y >= 0 { y / 400 } else { (y - 399) / 400 }; + let yoe = (y - era * 400) as u32; + let doy = (153 * (if m > 2 { m - 3 } else { m + 9 }) + 2) / 5 + d - 1; + let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy; + era as i64 * 146_097 + doe as i64 - 719_468 +} + +fn format_relative(age_secs: i64) -> String { + let s = age_secs.max(0); + fn unit(n: i64, name: &str) -> String { + format!("{} {}{} ago", n, name, if n == 1 { "" } else { "s" }) + } + if s < 60 { + unit(s, "second") + } else if s < 3_600 { + unit(s / 60, "minute") + } else if s < 86_400 { + unit(s / 3_600, "hour") + } else if s < 604_800 { + unit(s / 86_400, "day") + } else if s < 2_592_000 { + unit(s / 604_800, "week") + } else if s < 31_536_000 { + unit(s / 2_592_000, "month") + } else { + unit(s / 31_536_000, "year") + } +} + /// Strip the namespace prefix off an XML element name. YouTube's feed /// is heavily namespaced (`yt:videoId`, `media:thumbnail`) but we only /// care about the local part — namespace-vs-local distinguishing From 6775f8252fa5c273b69f5c603ecab36ed86e8801 Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 12:31:27 -0700 Subject: [PATCH 60/72] vc=62: audit-fix sprint on playback regressions MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Opus max-effort audit on vc=53-vc=61 diff caught four interlocked playback bugs. Cobb's 'video bugs are back' likely lived in the intersection of #1+#2 — stale auto-resume seek + no recovery path. BUG-1: setPlayingFrom clamps auto-resume against entry.durationMs. YouTube can replace a video at the same videoId with a shorter cut (live->VOD trim, premiere edit). Without the clamp, setMediaItem seeks past the new end, ExoPlayer fires onPlayerError, NowPlaying clears, surface locks at thumbnail+spinner. Clamp at lookup uses the recorded duration with a 5s safety margin; falls back to 0 when out of range. BUG-2: InlinePlayer adds a Retry button on the playback-error branch. Tapping it nulls playbackError + bumps a retryVersion that re-keys the setPlayingFrom LaunchedEffect. Previously the screen locked into the error message forever (no UI affordance to re-attempt; LaunchedEffect's keys never changed). Bonus protection: the manual retry path avoids the infinite-error-loop risk a NowPlaying-keyed auto-retry would have created. BUG-4: captureResumePosition now gates strictly on STATE_READY. STATE_BUFFERING during a fresh setMediaItem reports the PREVIOUS item's position via currentPosition — the 5s poll was happily writing A's tail position under B's videoId in that window. Next auto-resume would drop the user mid-A on a fresh open of B. BUG-5: onMediaItemTransition falls back to MediaItem.mediaMetadata when Queue.at(idx) is null. Without the fallback, a Queue/controller desync would leave NowPlaying stuck on the previous item forever, freezing controllerOnThisVideo at false and locking the inline player into thumbnail+spinner on the next screen. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- .../straw/feature/detail/VideoDetailScreen.kt | 30 +++++++++++--- .../straw/feature/player/PlaybackService.kt | 39 ++++++++++++++++--- .../feature/player/StrawMediaController.kt | 15 ++++++- 4 files changed, 74 insertions(+), 14 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 9ec76ca08..b1d852b9b 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 61 -const val STRAW_VERSION_NAME = "0.1.0-BU" +const val STRAW_VERSION_CODE = 62 +const val STRAW_VERSION_NAME = "0.1.0-BV" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index 447c7f79e..02c86e3b9 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -67,6 +67,7 @@ import androidx.compose.runtime.DisposableEffect import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.collectAsState import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableIntStateOf import androidx.compose.runtime.mutableFloatStateOf import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember @@ -741,8 +742,14 @@ private fun InlinePlayer( // Push the resolved stream into the shared controller if it isn't // already playing this URL. We don't kick off a new fetch — the // outer VideoDetailScreen already called vm.load(streamUrl). + // + // retryVersion lets the user manually re-fire setPlayingFrom after + // a playback error. Without it, the screen used to lock into the + // thumbnail+spinner branch once NowPlaying.clear() fired from + // onPlayerError. vc=62 audit BUG-2. val resolved = state.resolved - LaunchedEffect(controller, resolved, streamUrl) { + var retryVersion by remember(streamUrl) { mutableIntStateOf(0) } + LaunchedEffect(controller, resolved, streamUrl, retryVersion) { val c = controller ?: return@LaunchedEffect val r = resolved ?: return@LaunchedEffect // Optimization, not safety. claim() guards the race. @@ -792,11 +799,24 @@ private fun InlinePlayer( color = MaterialTheme.colorScheme.error, modifier = Modifier.padding(16.dp), ) - playbackError != null -> Text( - "playback error: $playbackError", - color = MaterialTheme.colorScheme.error, + playbackError != null -> Column( modifier = Modifier.padding(16.dp), - ) + horizontalAlignment = Alignment.CenterHorizontally, + ) { + Text( + "playback error: $playbackError", + color = MaterialTheme.colorScheme.error, + ) + Spacer(modifier = Modifier.height(12.dp)) + OutlinedButton(onClick = { + // Clear the error AND nudge the LaunchedEffect to + // re-attempt setPlayingFrom. vc=62 audit BUG-2 — + // without this the screen used to lock on the + // error forever after NowPlaying.clear(). + playbackError = null + retryVersion += 1 + }) { Text("Retry") } + } resolved?.isPlayable != true -> Text( "no playable stream", color = Color.White, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt index 692aebd04..ea0e89f50 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/PlaybackService.kt @@ -158,12 +158,32 @@ class PlaybackService : MediaSessionService() { override fun onMediaItemTransition(item: MediaItem?, reason: Int) { if (item == null) return val idx = player.currentMediaItemIndex - val queued = Queue.at(idx) ?: return - NowPlaying.claim(queued) - if (queued.segments.isEmpty()) { - val videoId = com.sulkta.straw.feature.detail.extractYtVideoId(queued.streamUrl) - if (!videoId.isNullOrBlank()) fetchSbForQueued(queued, videoId) + val queued = Queue.at(idx) + if (queued != null) { + NowPlaying.claim(queued) + if (queued.segments.isEmpty()) { + val videoId = + com.sulkta.straw.feature.detail.extractYtVideoId(queued.streamUrl) + if (!videoId.isNullOrBlank()) fetchSbForQueued(queued, videoId) + } + return } + // Queue desync — MediaItem was added by a path that + // bypassed enqueueInternal, OR the queue was cleared + // while a transition was pending. Fall back to the + // MediaItem's own metadata so NowPlaying doesn't stay + // stuck on the previous video forever (would freeze + // VideoDetail's controllerOnThisVideo guard at false + // and lock the inline player into thumbnail+spinner). + // vc=62 audit BUG-5. + val uri = item.localConfiguration?.uri?.toString() ?: return + val fallback = NowPlayingItem( + streamUrl = uri, + title = item.mediaMetadata.title?.toString().orEmpty(), + uploader = item.mediaMetadata.artist?.toString().orEmpty(), + thumbnail = item.mediaMetadata.artworkUri?.toString(), + ) + NowPlaying.claim(fallback) } override fun onIsPlayingChanged(isPlaying: Boolean) { @@ -205,10 +225,17 @@ class PlaybackService : MediaSessionService() { * ResumePositionsStore. Bails on idle/ended states and unknown * durations (live streams). The store itself enforces minimum- * position + near-end-clear thresholds. + * + * Gates STRICTLY on STATE_READY. STATE_BUFFERING during a fresh + * setMediaItem still reports the PREVIOUS item's position via + * currentPosition until prepare finishes and the new timeline + * lands — without the gate we'd record A's tail position under + * B's videoId and auto-resume the user mid-A on next open. + * vc=62 audit BUG-4. */ private fun captureResumePosition(player: Player) { val state = player.playbackState - if (state == Player.STATE_IDLE || state == Player.STATE_ENDED) return + if (state != Player.STATE_READY) return val item = NowPlaying.current.value ?: return val videoId = com.sulkta.straw.feature.detail.extractYtVideoId(item.streamUrl) ?: return val pos = player.currentPosition diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt index 923dcd095..8e277eac2 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/StrawMediaController.kt @@ -121,9 +121,22 @@ fun Player.setPlayingFrom( // an app update / process death. The store skips trivial // positions and clears near-end so we don't auto-resume to 0:03 // or to the credits. + // + // Clamp the resume position against the RECORDED duration with a + // safety margin. vc=62 audit BUG-1: YouTube can replace a video + // at the same videoId with a shorter cut (live→VOD trim, premiere + // edit, channel replace) — without the clamp, setMediaItem seeks + // past the new end, ExoPlayer fires onPlayerError, the screen + // ends up stuck on the thumbnail+spinner (BUG-2 cascade). val effectiveStart = if (startPositionMs == 0L && Settings.get().autoResume.value) { val videoId = extractYtVideoId(streamUrl) - videoId?.let { Resume.get().get(it)?.positionMs } ?: 0L + val saved = videoId?.let { Resume.get().get(it) } + if (saved == null) { + 0L + } else { + val safeCeiling = saved.durationMs - 5_000L + if (saved.positionMs in 1L..safeCeiling) saved.positionMs else 0L + } } else { startPositionMs } From 7bd2740055826fe64b5b488f00502252c6e95a25 Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 12:47:31 -0700 Subject: [PATCH 61/72] vc=63: fix stale-state nav-bug (new page shows, old video plays) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Cobb reproduced 2026-05-26: clicking video B from detail A's related section opens detail B (title, description correct), minibar/media notification show A's title, and AUDIO plays A. The bug everyone was hitting as 'video bugs are back'. Root cause — VideoDetailViewModel is activity-scoped, so navigating A→B shows ONE composition frame with the previous video's state before vm.load(B)'s reset propagates. During that frame: 1. VideoDetailScreen body runs with streamUrl=B but state.detail=A and state.resolved=A's playback URLs (stale). 2. InlinePlayer is called with title=A, streamUrl=B, resolved=A's. 3. Its LaunchedEffect launches a coroutine. Body is synchronous (no suspend), runs to completion before cancellation can interrupt. 4. setPlayingFrom(streamUrl=B, resolved=A's URLs) fires. claim() succeeds → NowPlaying = {streamUrl=B, title=A's title}. setMediaItem with A's playback URIs → player loads + plays A. 5. State reset propagates. InlinePlayer disposes. 6. After vm.load completes with B's data, InlinePlayer recomposes with B's resolved. Its NEW LaunchedEffect fires. The check 'NowPlaying.streamUrl == streamUrl' returns true (because step 4 already stamped streamUrl=B). RETURN EARLY. setPlayingFrom(B) NEVER fires with the correct B data. Fix — add a loadedUrl field to VideoDetailUiState that tracks which streamUrl the current detail/resolved actually belong to. Gate VideoDetailScreen's player composition on state.loadedUrl == streamUrl, so the stale-state frame can't fire setPlayingFrom with mismatched data. vm.load sets loadedUrl in the initial reset AND the success/error updates — every state transition carries the URL that owns it. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 ++-- .../straw/feature/detail/VideoDetailScreen.kt | 9 +++++++++ .../straw/feature/detail/VideoDetailViewModel.kt | 14 +++++++++++++- 3 files changed, 24 insertions(+), 3 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index b1d852b9b..409599050 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 62 -const val STRAW_VERSION_NAME = "0.1.0-BV" +const val STRAW_VERSION_CODE = 63 +const val STRAW_VERSION_NAME = "0.1.0-BW" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index 02c86e3b9..4d4e67411 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -258,6 +258,15 @@ fun VideoDetailScreen( else -> { val d = state.detail ?: return@Column + // Guard against vm's activity-scoped staleness — on a + // fresh navigation A → B, the shared VM still holds + // A's detail/resolved for one composition frame before + // vm.load(B)'s reset propagates. Without this gate, the + // InlinePlayer's LaunchedEffect would fire with + // streamUrl=B but resolved=A's URLs and play A under + // B's chrome (Cobb-reported 2026-05-26: detail page + // shows new video, audio is the old one). + if (state.loadedUrl != streamUrl) return@Column // Player surface — edge-to-edge, NewPipe/YouTube style. // Lives outside the 16dp horizontal padding so the // thumbnail fills the screen width with no gutters. diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt index f20864efa..76a12d77e 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt @@ -93,6 +93,16 @@ data class VideoDetailUiState( val error: String? = null, /** Raw extractor result — kept around for the Download dialog. */ val streamInfo: uniffi.strawcore.StreamInfo? = null, + /** + * Tracks which URL the current `detail`/`resolved` belong to. + * vm is activity-scoped, so a fresh navigation to detail B sees + * the PREVIOUS video's state for one composition frame before + * vm.load(B) clears it. Without this field, the InlinePlayer's + * setPlayingFrom would fire with streamUrl=B but resolved=A's + * playback URLs — claiming NowPlaying with B's streamUrl but + * playing A's video under it. vc=63 audit. + */ + val loadedUrl: String? = null, ) class VideoDetailViewModel : ViewModel() { @@ -127,7 +137,7 @@ class VideoDetailViewModel : ViewModel() { } inFlight?.cancel() loadedUrl = streamUrl - _ui.update { VideoDetailUiState(loading = true) } + _ui.update { VideoDetailUiState(loading = true, loadedUrl = streamUrl) } inFlight = viewModelScope.launch { try { // strawcore.streamInfo is suspend on tokio; no Dispatchers.IO wrap. @@ -273,6 +283,7 @@ class VideoDetailViewModel : ViewModel() { ), resolved = resolved, streamInfo = info, + loadedUrl = streamUrl, ) } } catch (t: Throwable) { @@ -284,6 +295,7 @@ class VideoDetailViewModel : ViewModel() { error = com.sulkta.straw.util.LogDump.scrubLine( t.message ?: t.javaClass.simpleName, ), + loadedUrl = streamUrl, ) } } From 944fbd4335be6d6dbbd296811e1d31af6b412381 Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 13:06:57 -0700 Subject: [PATCH 62/72] =?UTF-8?q?vc=3D64:=20UX=20polish=20=E2=80=94=20chip?= =?UTF-8?q?=20wrap=20+=20RelatedRow=20metadata?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two issues Cobb caught on the vc=63 walkthrough: (1) Subscription chip names wrapped to two lines mid-word at 80dp chip width: 'NoCopyrightS / ounds', 'DEFCONConfe / rence', 'Practica / Engineer...'. Switched to maxLines=1 + ellipsis + center-align. 'NoCopyrigh…' reads cleaner than the broken wrap. (2) Related + More-from-channel rows showed an empty metadata line under the title because the buildString started with item.uploader (empty for channelInfo-sourced rows — channel pages omit the uploader name from each card since it's implicit). Switched to a leading-separator pattern that gracefully composes whatever pieces are populated: 'uploader · views · date', 'views · date', 'date', etc., and hides the line entirely when nothing's available. Date was also never rendered before — channelInfo gives it but RelatedRow ignored it. Now visible everywhere. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- .../main/kotlin/com/sulkta/straw/StrawHome.kt | 9 +++- .../straw/feature/detail/VideoDetailScreen.kt | 41 +++++++++++++------ 3 files changed, 38 insertions(+), 16 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 409599050..df9a9cfd5 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 63 -const val STRAW_VERSION_NAME = "0.1.0-BW" +const val STRAW_VERSION_CODE = 64 +const val STRAW_VERSION_NAME = "0.1.0-BX" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt index 322b7bd4f..06acdf2cb 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt @@ -587,11 +587,18 @@ private fun SubChip( ) } Spacer(modifier = Modifier.height(4.dp)) + // Single line + ellipsis instead of maxLines=2. The 80dp chip + // width breaks the prior 2-line wrap mid-word ("NoCopyrightS + // / ounds", "DEFCONConfe / rence") — uglier than a clean + // "NoCopyrigh…". Centered text alignment so the ellipsis + // sits over the chip's icon column. vc=64. Text( text = ch.name, style = MaterialTheme.typography.labelSmall, - maxLines = 2, + maxLines = 1, overflow = TextOverflow.Ellipsis, + textAlign = androidx.compose.ui.text.style.TextAlign.Center, + modifier = Modifier.fillMaxWidth(), ) } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index 4d4e67411..87f9e2b3e 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -709,19 +709,34 @@ private fun RelatedRow( overflow = TextOverflow.Ellipsis, ) Spacer(modifier = Modifier.height(2.dp)) - Text( - text = buildString { - append(item.uploader) - if (item.viewCount > 0) { - append(" · ") - append(formatViews(item.viewCount)) - } - }, - style = MaterialTheme.typography.bodySmall, - color = MaterialTheme.colorScheme.onSurfaceVariant, - maxLines = 1, - overflow = TextOverflow.Ellipsis, - ) + // Build the metadata line from whatever's available. + // channelInfo-sourced items (More from channel) come back + // with uploader="" because the channel page doesn't repeat + // the uploader name on each row — it's implicit. Skip + // empty pieces with the leading-separator dance so we + // never end up with " · viewCount" or trailing dots. + // vc=64 — Cobb caught the empty metadata line on + // More-from-channel rows. + val meta = buildString { + if (item.uploader.isNotBlank()) append(item.uploader) + if (item.viewCount > 0) { + if (isNotEmpty()) append(" · ") + append(formatViews(item.viewCount)) + } + if (item.uploadDateRelative.isNotBlank()) { + if (isNotEmpty()) append(" · ") + append(item.uploadDateRelative) + } + } + if (meta.isNotEmpty()) { + Text( + text = meta, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + } } } } From 7156208c3c3c391040182b6d4e9424fd6359f458 Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 13:09:23 -0700 Subject: [PATCH 63/72] vc=65: metadata consistency across ChannelScreen + SearchScreen rows MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit vc=64 fixed RelatedRow's empty-metadata bug. ChannelVideoRow and ResultRow had the same shape problem AND duplicated duration: - ChannelVideoRow: showed 'N views · 0:42' which doubled with the VideoThumbnail's bottom-right duration badge. Stripped the duration text, added uploadDateRelative. Now reads 'N views · 2 days ago' matching YT's channel page format. - ResultRow: same duplicate-duration. Same fix. Search results now show 'N views · 2 days ago' under the uploader line. All four video-row composables (FeedRow, RelatedRow, ChannelVideoRow, ResultRow) now use the same leading-separator buildString pattern: 'piece [· piece]*' that gracefully composes whatever fields are populated. No more empty metadata lines, no more duplicate duration. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +-- .../straw/feature/channel/ChannelScreen.kt | 32 ++++++++++++------- .../straw/feature/search/SearchScreen.kt | 20 ++++++++---- 3 files changed, 36 insertions(+), 20 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index df9a9cfd5..75e693f5e 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 64 -const val STRAW_VERSION_NAME = "0.1.0-BX" +const val STRAW_VERSION_CODE = 65 +const val STRAW_VERSION_NAME = "0.1.0-BY" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt index bca2e6641..1618fc2a9 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt @@ -205,18 +205,26 @@ private fun ChannelVideoRow( overflow = TextOverflow.Ellipsis, ) Spacer(modifier = Modifier.height(2.dp)) - Text( - text = buildString { - if (item.viewCount > 0) append("${formatCount(item.viewCount)} views") - if (item.durationSeconds > 0) { - if (isNotEmpty()) append(" · ") - append(formatDuration(item.durationSeconds)) - } - }, - style = MaterialTheme.typography.bodySmall, - color = MaterialTheme.colorScheme.onSurfaceVariant, - maxLines = 1, - ) + // Don't repeat duration here — VideoThumbnail's + // bottom-right badge already shows it. Add the upload + // date so the row reads 'N views · 2 days ago' the way + // YT renders it. vc=65 — Cobb caught the duplicate + // duration + missing date on the channel page. + val meta = buildString { + if (item.viewCount > 0) append("${formatCount(item.viewCount)} views") + if (item.uploadDateRelative.isNotBlank()) { + if (isNotEmpty()) append(" · ") + append(item.uploadDateRelative) + } + } + if (meta.isNotEmpty()) { + Text( + text = meta, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + maxLines = 1, + ) + } } } } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt index 4f4adebfa..17d804b12 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/search/SearchScreen.kt @@ -247,13 +247,21 @@ private fun ResultRow( else Modifier.padding(vertical = 4.dp), ) - if (item.viewCount > 0 || item.durationSeconds > 0) { + // Drop the duration here — VideoThumbnail's badge already + // renders it on the bottom-right of the thumbnail. Add the + // upload date instead so search results read like YT's + // own format. vc=65 — caught with the + // channel-page + related-row consistency pass. + val meta = buildString { + if (item.viewCount > 0) append(formatViews(item.viewCount)) + if (item.uploadDateRelative.isNotBlank()) { + if (isNotEmpty()) append(" · ") + append(item.uploadDateRelative) + } + } + if (meta.isNotEmpty()) { Text( - text = buildString { - if (item.viewCount > 0) append(formatViews(item.viewCount)) - if (item.viewCount > 0 && item.durationSeconds > 0) append(" · ") - if (item.durationSeconds > 0) append(formatDuration(item.durationSeconds)) - }, + text = meta, style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant, maxLines = 1, From dd151e322dea70f097d06578a9845332c5318b02 Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 13:40:26 -0700 Subject: [PATCH 64/72] =?UTF-8?q?vc=3D66:=20hybrid=20feed=20backfill=20?= =?UTF-8?q?=E2=80=94=20RSS-fast=20+=20streamInfo-complete?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Cobb asked for views + durations back in the subs feed without giving up the 5-10× RSS speedup vc=56 bought. Hybrid path: 1. Rust wrapper — new enrich_feed_item(video_url) -> EnrichedFeedMetadata { view_count, duration_seconds }. Thin wrapper around stream_info that discards the heavy play-URL payload. Future opt: parse watch-page HTML JSON state directly to skip JS deobf entirely. ~150 lines of pluck logic, punted. 2. EnrichmentStore — new SharedPreferences-lite store keyed by videoId, value Enrichment(viewCount, durationSeconds, fetchedAt). Bound to Settings.cacheTtl for staleness. Hard cap 5000 entries with oldest-eviction. 3. SubscriptionFeedViewModel — after the RSS refresh paints, enrichVisibleItems() fans out enrichFeedItem for the first 30 items (skipping any already enriched fresh). Bounded at 8 wide so we don't hammer YT; each call ~500ms full streamInfo so 30 items in ~2s. Runs on StrawApp.globalScope so a refresh-cancel doesn't kill the in-flight enrichment. mergeFromCache overlays the enrichment via .withEnrichment() so RSS rows pick up viewCount + durationSeconds the moment they land. The Enrichment store's StateFlow.value is read on every merge call; the enrichment-complete handler triggers a _ui.update that re-merges. Net behavior: feed paints instantly from RSS (no view/duration), ~2s later the visible top-N populate with full metadata. Cached forever (or until TTL/cap). Subsequent opens read straight from EnrichmentStore. StrawApp.onCreate inits the new store alongside the existing SP-backed ones. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- rust/strawcore/src/feed.rs | 30 +++++ .../main/kotlin/com/sulkta/straw/StrawApp.kt | 2 + .../com/sulkta/straw/data/EnrichmentStore.kt | 118 ++++++++++++++++++ .../feature/feed/SubscriptionFeedViewModel.kt | 85 ++++++++++++- 5 files changed, 236 insertions(+), 3 deletions(-) create mode 100644 strawApp/src/main/kotlin/com/sulkta/straw/data/EnrichmentStore.kt diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 75e693f5e..f7ebda3b7 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 65 -const val STRAW_VERSION_NAME = "0.1.0-BY" +const val STRAW_VERSION_CODE = 66 +const val STRAW_VERSION_NAME = "0.1.0-BZ" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/rust/strawcore/src/feed.rs b/rust/strawcore/src/feed.rs index 2b8416a5d..259dee238 100644 --- a/rust/strawcore/src/feed.rs +++ b/rust/strawcore/src/feed.rs @@ -25,6 +25,36 @@ const RSS_BASE: &str = "https://www.youtube.com/feeds/videos.xml?channel_id="; const MAX_CONCURRENT: usize = 50; const PER_CHANNEL_TIMEOUT_S: u64 = 8; +/// Hybrid-backfill metadata: just the two fields RSS doesn't return +/// (view count + duration). Kotlin calls this lazily for visible feed +/// items after the RSS-fed paint to fill in the gaps that +/// channel_feed_rss leaves empty. +/// +/// vc=66 — built specifically so the subs feed can show 'N views · +/// X duration' the way YT does, without paying the full channel_info +/// page-scrape cost on initial paint. The underlying stream_info IS +/// heavier than we'd like (~500ms each, runs JS deobf for play URLs +/// we'll discard) — future opt would be to parse the watch-page HTML +/// JSON state directly for just these two fields. ~100ms savings per +/// call but ~150 lines of HTML/JSON pluck logic. Punted until needed. +#[derive(Debug, Clone, uniffi::Record)] +pub struct EnrichedFeedMetadata { + pub view_count: i64, + pub duration_seconds: i64, +} + +#[uniffi::export(async_runtime = "tokio")] +pub async fn enrich_feed_item( + video_url: String, +) -> Result { + crate::runtime::ensure_initialized(); + let info = crate::stream::stream_info(video_url).await?; + Ok(EnrichedFeedMetadata { + view_count: info.view_count, + duration_seconds: info.duration_seconds, + }) +} + /// Single-channel RSS — Kotlin keeps its per-channel cache + fan-out /// (parallelism cranked to 50 in the wrapper). Each call is ~50-150ms /// instead of the ~500ms channelInfo page-scrape, so a 50-sub refresh diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt index a8c0c4794..ec492835d 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawApp.kt @@ -7,6 +7,7 @@ package com.sulkta.straw import android.app.Application import com.sulkta.straw.data.FeedCache +import com.sulkta.straw.data.FeedEnrichment import com.sulkta.straw.data.History import com.sulkta.straw.data.Playlists import com.sulkta.straw.data.Resume @@ -72,6 +73,7 @@ class StrawApp : Application() { Subscriptions.init(this) Playlists.init(this) Resume.init(this) + FeedEnrichment.init(this) // vc=36 audit HIGH-R3: FeedCache (~225 KB) + SearchCache // (~150 KB) JSON-decode at construction. Stash the // applicationContext eagerly (cheap) so `get()` is callable diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/EnrichmentStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/EnrichmentStore.kt new file mode 100644 index 000000000..c18448bfd --- /dev/null +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/EnrichmentStore.kt @@ -0,0 +1,118 @@ +/* + * SPDX-FileCopyrightText: 2026 Sulkta-Coop + * SPDX-License-Identifier: GPL-3.0-or-later + * + * Subs-feed enrichment cache. RSS gives us title/url/thumbnail/date + * fast but no view count or duration. After a feed refresh paints + * from RSS, SubscriptionFeedViewModel fans out lightweight + * uniffi.strawcore.enrichFeedItem() calls for the top visible items + * and stashes the results here. mergeFromCache overlays the + * enrichment onto each StreamItem at render time so the row shows + * 'N views · X duration' once available. + * + * Storage: SharedPreferences-lite, single JSON blob keyed by videoId. + * TTL bound to Settings.cacheTtl so enrichments age out alongside the + * rest of the cache. Hard cap at MAX_ENRICHMENTS to bound disk + + * memory. + */ + +package com.sulkta.straw.data + +import android.content.Context +import android.content.SharedPreferences +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.updateAndGet +import kotlinx.serialization.Serializable +import kotlinx.serialization.json.Json + +@Serializable +data class Enrichment( + val viewCount: Long, + val durationSeconds: Long, + val fetchedAt: Long, +) + +private const val PREFS = "straw_feed_enrichment" +private const val KEY = "enrichments_v1" + +/** + * Hard ceiling — keeps the JSON blob below ~250 KB even at the cap + * (50 bytes/entry × 5000 = 250 KB). The user-facing cap doesn't tie + * to this; enrichment is "cache" not "user data." + */ +private const val MAX_ENRICHMENTS = 5_000 + +class EnrichmentStore(context: Context) { + private val sp: SharedPreferences = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE) + private val json = Json { ignoreUnknownKeys = true } + + private val _entries = MutableStateFlow(load()) + val entries: StateFlow> = _entries.asStateFlow() + + /** + * Return a fresh enrichment for this videoId, or null when missing + * or aged out per Settings.cacheTtl. Forever-TTL never expires. + */ + fun get(videoId: String): Enrichment? { + if (videoId.isBlank()) return null + val e = _entries.value[videoId] ?: return null + val ttl = Settings.get().cacheTtl.value + if (ttl.isForever) return e + val cutoff = System.currentTimeMillis() - ttl.ms + return if (e.fetchedAt >= cutoff) e else null + } + + fun put(videoId: String, viewCount: Long, durationSeconds: Long) { + if (videoId.isBlank()) return + // Don't write all-zero entries — that's failure not data, and + // would waste a slot the cap could spend on a real hit. + if (viewCount <= 0L && durationSeconds <= 0L) return + val entry = Enrichment( + viewCount = viewCount, + durationSeconds = durationSeconds, + fetchedAt = System.currentTimeMillis(), + ) + val before = _entries.value + val next = _entries.updateAndGet { current -> + val withEntry = current + (videoId to entry) + if (withEntry.size > MAX_ENRICHMENTS) { + withEntry.entries + .sortedByDescending { it.value.fetchedAt } + .take(MAX_ENRICHMENTS) + .associate { it.key to it.value } + } else { + withEntry + } + } + if (next !== before) { + sp.edit().putString(KEY, json.encodeToString(next)).apply() + } + } + + fun clear() { + _entries.updateAndGet { emptyMap() } + sp.edit().putString(KEY, json.encodeToString(emptyMap())).apply() + } + + private fun load(): Map = runCatching { + val s = sp.getString(KEY, null) ?: return emptyMap() + json.decodeFromString>(s) + }.getOrDefault(emptyMap()) +} + +object FeedEnrichment { + @Volatile private var instance: EnrichmentStore? = null + + fun init(context: Context) { + if (instance == null) { + synchronized(this) { + if (instance == null) instance = EnrichmentStore(context.applicationContext) + } + } + } + + fun get(): EnrichmentStore = instance + ?: error("EnrichmentStore not initialized — call FeedEnrichment.init(context)") +} diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt index 302d898b4..eb393c851 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt @@ -19,8 +19,10 @@ package com.sulkta.straw.feature.feed import androidx.lifecycle.ViewModel import androidx.lifecycle.viewModelScope import com.sulkta.straw.data.ChannelRef +import com.sulkta.straw.data.Enrichment import com.sulkta.straw.data.FeedCache import com.sulkta.straw.data.FeedCacheEntry +import com.sulkta.straw.data.FeedEnrichment import com.sulkta.straw.data.Settings import com.sulkta.straw.data.Subscriptions import com.sulkta.straw.feature.search.StreamItem @@ -191,13 +193,19 @@ class SubscriptionFeedViewModel : ViewModel() { .awaitAll() } pruneCacheToSubs(channels) + val freshItems = mergeFromCache(channels) _ui.update { SubscriptionFeedUiState( loading = false, - items = mergeFromCache(channels), + items = freshItems, lastFetchedAt = System.currentTimeMillis(), ) } + // vc=66 — hybrid backfill. RSS-fed items have + // viewCount=0 + durationSeconds=0; kick a bounded + // background job that calls enrichFeedItem for the + // top items and pumps a fresh _ui emit when done. + enrichVisibleItems(freshItems) // Persist what we just freshened. Off the main thread — // JSON encode on 30 subs * 30 items is small but not // free, and SharedPreferences.apply is async anyway. @@ -283,7 +291,15 @@ class SubscriptionFeedViewModel : ViewModel() { // Pre-compute recencyScore once per item — vc=35 audit // MED-Q15: sortedWith's comparator was invoking the regex // twice per pair, so ~1800 regex matches on a 900-item merge. + // + // vc=66 — overlay FeedEnrichment data on each item so RSS-fed + // rows (viewCount=0, durationSeconds=0) get backfilled with + // metadata fetched by the background enrichment job below. + // Pure read of the enrichment store; the enrichment write + // path triggers a fresh _ui emit. + val enrichments = FeedEnrichment.get().entries.value return channels.flatMap { ch -> channelCache[ch.url]?.items.orEmpty() } + .map { it.withEnrichment(enrichments) } .map { it to it.recencyScore() } .sortedWith( compareByDescending> { it.second } @@ -293,6 +309,73 @@ class SubscriptionFeedViewModel : ViewModel() { .map { it.first } } + /** + * Background enrichment: pulls viewCount + durationSeconds for the + * top-N freshly-merged items via the lightweight + * uniffi.strawcore.enrichFeedItem endpoint. Bounded parallel + * (8-wide) — each call is ~500ms full streamInfo, so 30 items + * complete in ~2s. Skipped per-item when FeedEnrichment already + * has a fresh hit (TTL controlled by Settings.cacheTtl). + * + * Runs OFF viewModelScope so a refresh-cancel doesn't kill an + * enrichment that's almost done — the background fill is for + * NEXT-open paint, no rush. Uses StrawApp.globalScope. + */ + private fun enrichVisibleItems(items: List) { + val take = items.take(ENRICH_HEAD_COUNT) + .filter { it.viewCount <= 0L && it.durationSeconds <= 0L } + if (take.isEmpty()) return + com.sulkta.straw.StrawApp.globalScope.launch { + val gate = Semaphore(ENRICH_PARALLELISM) + coroutineScope { + take.map { item -> + async { + gate.withPermit { + val videoId = com.sulkta.straw.feature.detail.extractYtVideoId(item.url) + ?: return@withPermit + if (FeedEnrichment.get().get(videoId) != null) return@withPermit + val md = runCatchingCancellable { + withContext(Dispatchers.IO) { + uniffi.strawcore.enrichFeedItem(item.url) + } + }.getOrNull() ?: return@withPermit + FeedEnrichment.get().put( + videoId, + md.viewCount, + md.durationSeconds, + ) + } + } + }.awaitAll() + } + // Pump a fresh emit so the UI picks up the overlay. + withContext(Dispatchers.Main) { + val channels = Subscriptions.get().subs.value + _ui.update { it.copy(items = mergeFromCache(channels)) } + } + } + } + + private val ENRICH_HEAD_COUNT = 30 + private val ENRICH_PARALLELISM = 8 + + /** + * Apply an enrichment overlay to a StreamItem. Only fills fields + * that RSS left empty — if the source already had non-zero values + * (e.g. a channelInfo path populated them) we don't clobber. + */ + private fun StreamItem.withEnrichment( + enrichments: Map, + ): StreamItem { + if (viewCount > 0L && durationSeconds > 0L) return this + val videoId = com.sulkta.straw.feature.detail.extractYtVideoId(url) ?: return this + val e = enrichments[videoId] ?: return this + return copy( + viewCount = if (viewCount > 0L) viewCount else e.viewCount, + durationSeconds = if (durationSeconds > 0L) durationSeconds else e.durationSeconds, + ) + } + /** * Clear in-memory cache. Called from Settings when the user flips * off the local-cache toggle — disk wipe via FeedCacheStore.clear() From 796244e0655115907ed6c9d056c0a67bd4b6bd2b Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 15:32:47 -0700 Subject: [PATCH 65/72] vc=67: fix subs feed scroll jank MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit LazyColumn items() now keyed by url so pagination doesn't re-key every row from scratch when visibleCount jumps. The displayed page slice is remembered so SubsPane doesn't reallocate the take() ArrayList on every recomposition. ThumbnailProgressOverlay switched from collectAsStateWithLifecycle to plain collectAsState — the lifecycle wrapper added a DisposableEffect per call site, which adds up across the ~30 visible rows and was contributing to scroll hitch. --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 ++-- .../src/main/kotlin/com/sulkta/straw/StrawHome.kt | 11 +++++++++-- .../sulkta/straw/feature/player/ThumbnailProgress.kt | 10 ++++++++-- 3 files changed, 19 insertions(+), 6 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index f7ebda3b7..5e3d33135 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 66 -const val STRAW_VERSION_NAME = "0.1.0-BZ" +const val STRAW_VERSION_CODE = 67 +const val STRAW_VERSION_NAME = "0.1.0-CA" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt index 06acdf2cb..94ac9fe69 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt @@ -323,7 +323,11 @@ private fun SubsPane( visibleCount = PAGE_SIZE } } - val displayed = filteredItems.take(visibleCount) + // remember the page-slice so we don't allocate a new ArrayList on + // every recomposition (scroll hitch vc=67). + val displayed = remember(filteredItems, visibleCount) { + filteredItems.take(visibleCount) + } val hasMore = filteredItems.size > visibleCount Column { @@ -442,7 +446,10 @@ private fun SubsPane( state = listState, contentPadding = rememberBottomContentPadding(), ) { - items(displayed) { item -> + items( + items = displayed, + key = { it.url }, + ) { item -> FeedRow( item = item, onClick = { onOpenVideo(item.url, item.title) }, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/ThumbnailProgress.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/ThumbnailProgress.kt index bc4bd4e4f..26daa53f0 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/ThumbnailProgress.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/ThumbnailProgress.kt @@ -25,13 +25,13 @@ import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Text import androidx.compose.runtime.Composable +import androidx.compose.runtime.collectAsState import androidx.compose.runtime.getValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.draw.clip import androidx.compose.ui.graphics.Color import androidx.compose.ui.unit.dp -import androidx.lifecycle.compose.collectAsStateWithLifecycle import coil3.compose.AsyncImage import com.sulkta.straw.OverlayDimColor import com.sulkta.straw.ProgressBarFillColor @@ -51,7 +51,13 @@ import com.sulkta.straw.util.formatDuration @Composable fun BoxScope.ThumbnailProgressOverlay(videoId: String?) { if (videoId.isNullOrBlank()) return - val positions by Resume.get().positions.collectAsStateWithLifecycle() + // Plain collectAsState — collectAsStateWithLifecycle adds a + // DisposableEffect for lifecycle observation per call site, which + // adds up across 30 visible LazyColumn rows and contributes to + // scroll jank (vc=67). The Lifecycle pause optimization doesn't + // matter for a foreground feed that's only collected while the + // composable is on screen anyway. + val positions by Resume.get().positions.collectAsState() val entry = positions[videoId] ?: return if (entry.durationMs <= 0L) return val fraction = (entry.positionMs.toFloat() / entry.durationMs.toFloat()) From c960a1f424ea044e5f32b09e388f49eaf1b4e46b Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 20:53:25 -0700 Subject: [PATCH 66/72] vc=68: audit-fix sprint round 1 (11 HIGH + MED batch) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Block B — enrichment lifecycle drift: * SubscriptionFeedViewModel tracks enrichJob, cancelled in refresh + clearInMemoryCache so spam-refresh and cache-toggle no longer leave a globalScope coroutine writing to a destroyed _ui * Enrich now runs on viewModelScope, channels snapshotted at job start so the terminal merge doesn't read a stale subs list * mergeFromCache moved off Main on both the refresh path AND the init-hydration path — 750-item flatMap+sort+regex no longer blocks the UI thread * VideoDetailViewModel dual loadedUrl bookkeeping collapsed to the UiState field only; the rejected-URL path also stamps loadedUrl so the gate reads coherently Block A — auto-update authenticity: * AppUpdateClient pins the fdroid.sulkta.com leaf SPKI + the Let's Encrypt E7 intermediate via OkHttp CertificatePinner * file.name accepted only when matching ^/[A-Za-z0-9._-]+\.apk$ * versionCode clamped to (0, 10_000_000] before we trust the 'update available' notification — a hostile index can no longer pin us to MAX_VALUE Block C — captureResumePosition perf: * ResumePositionsStore.record short-circuits when the existing entry matches position+duration so the 5s poll's before !== next guard actually skips the SP write * JSON encode + SP write off Main via globalScope IO Block D — Rust feed.rs hardening: * Shared reqwest Client via OnceLock — 50 channels no longer pay 50 TLS handshakes * Response body capped at 2 MiB via bytes_stream — adversarial feeds can't OOM the JVM * parse_rss returns partial results on quick-xml errors instead of nuking everything already parsed * extract_channel_id widened (m./www./http(s)?/trailing path) and validates exact 24-char UC<22 base64-ish> * Skip entries with empty title/published * iso_to_relative future dates → 'just now' (clock skew no longer pins items to top) * civil_to_days year clamp 1970..=2200 before the i64 arithmetic * Redirect chain capped at 3 * Dropped the broken lexicographic sort on upload_date_relative * Cap parsed entries at 50 per channel MED batch: * ThumbnailProgressOverlay uses derivedStateOf so only rows whose specific entry changed recompose on the 5s positions tick * EnrichmentStore.put short-circuits on identical view+duration so re-enrich within TTL doesn't write SP * EnrichmentStore.load prunes TTL-expired entries on hydration * FeedRefreshWorker distinguishes transient (Result.retry) from parse (Result.success) failures * WorkManager interval coerceAtLeast(15L) on both schedulers --- buildSrc/src/main/kotlin/ProjectConfig.kt | 4 +- rust/strawcore/src/feed.rs | 197 ++++++++++++++---- .../com/sulkta/straw/data/EnrichmentStore.kt | 20 +- .../sulkta/straw/data/ResumePositionsStore.kt | 42 +++- .../feature/detail/VideoDetailViewModel.kt | 28 ++- .../feature/feed/FeedRefreshScheduler.kt | 4 +- .../straw/feature/feed/FeedRefreshWorker.kt | 18 +- .../feature/feed/SubscriptionFeedViewModel.kt | 66 ++++-- .../straw/feature/player/ThumbnailProgress.kt | 20 +- .../straw/feature/update/AppUpdateClient.kt | 63 +++++- .../straw/feature/update/UpdateScheduler.kt | 6 +- 11 files changed, 385 insertions(+), 83 deletions(-) diff --git a/buildSrc/src/main/kotlin/ProjectConfig.kt b/buildSrc/src/main/kotlin/ProjectConfig.kt index 5e3d33135..1b4ad26a7 100644 --- a/buildSrc/src/main/kotlin/ProjectConfig.kt +++ b/buildSrc/src/main/kotlin/ProjectConfig.kt @@ -55,6 +55,6 @@ const val NEWPIPE_APPLICATION_ID_NEW = "net.newpipe.app" // vc=19 / 0.1.0-AE — rust pipeline cutover. Extraction via // strawcore-core (Sulkta-Coop/strawcore) via the UniFFI wrapper; no // NewPipeExtractor in the runtime path. -const val STRAW_VERSION_CODE = 67 -const val STRAW_VERSION_NAME = "0.1.0-CA" +const val STRAW_VERSION_CODE = 68 +const val STRAW_VERSION_NAME = "0.1.0-CB" const val STRAW_APPLICATION_ID = "com.sulkta.straw" diff --git a/rust/strawcore/src/feed.rs b/rust/strawcore/src/feed.rs index 259dee238..395b66840 100644 --- a/rust/strawcore/src/feed.rs +++ b/rust/strawcore/src/feed.rs @@ -13,6 +13,7 @@ // the full stream_info path to fetch the rich metadata when actually // needed. +use std::sync::OnceLock; use std::time::Duration; use futures::stream::{self, StreamExt}; @@ -24,6 +25,23 @@ use crate::search::SearchItem; const RSS_BASE: &str = "https://www.youtube.com/feeds/videos.xml?channel_id="; const MAX_CONCURRENT: usize = 50; const PER_CHANNEL_TIMEOUT_S: u64 = 8; +/// Cap on the body bytes we'll read for a single RSS fetch. Real YT +/// Atom feeds are ~5-30 KB; 2 MiB leaves comfortable headroom while +/// blocking a hostile or compromised host from streaming GB-scale +/// bodies into JVM memory inside the 8s timeout. Round-67 audit +/// rust-HIGH-5. +const RSS_MAX_BYTES: usize = 2 * 1024 * 1024; +/// Cap on parsed entries per channel — RSS normally returns 15. +/// 50 leaves headroom for one-off legitimate variance; anything +/// past that is a sign the feed isn't what we expect. +/// Round-67 audit rust-MED-6. +const RSS_MAX_ENTRIES: usize = 50; +/// Year range we trust civil-to-days math for. Strawcore RSS only +/// emits real-world recent uploads; clamping here turns adversarial +/// year fields into a parse failure rather than i64 overflow. +/// Round-67 audit rust-CRIT-1. +const YEAR_MIN: i32 = 1970; +const YEAR_MAX: i32 = 2200; /// Hybrid-backfill metadata: just the two fields RSS doesn't return /// (view count + duration). Kotlin calls this lazily for visible feed @@ -55,6 +73,28 @@ pub async fn enrich_feed_item( }) } +/// Shared reqwest Client — DNS resolver + TLS keepalive + connection +/// pool live here so a 50-channel fan-out reuses one pool instead of +/// paying 50 handshakes. Round-67 audit rust-HIGH-4. +static RSS_CLIENT: OnceLock = OnceLock::new(); + +fn rss_client() -> Result<&'static Client, StrawcoreError> { + if let Some(c) = RSS_CLIENT.get() { + return Ok(c); + } + let client = Client::builder() + .timeout(Duration::from_secs(PER_CHANNEL_TIMEOUT_S)) + .user_agent(concat!("Mozilla/5.0 (Android; Mobile; Straw/", env!("CARGO_PKG_VERSION"), ")")) + // Cap redirect chains so a misconfigured/hostile feed can't + // spin a server out of our 8s budget. Round-67 audit rust-LOW-8. + .redirect(reqwest::redirect::Policy::limited(3)) + .build() + .map_err(|e| StrawcoreError::Extractor { + msg: format!("http client build: {e}"), + })?; + Ok(RSS_CLIENT.get_or_init(|| client)) +} + /// Single-channel RSS — Kotlin keeps its per-channel cache + fan-out /// (parallelism cranked to 50 in the wrapper). Each call is ~50-150ms /// instead of the ~500ms channelInfo page-scrape, so a 50-sub refresh @@ -65,14 +105,8 @@ pub async fn channel_feed_rss( ) -> Result, StrawcoreError> { crate::runtime::ensure_initialized(); log::info!("strawcore::channel_feed_rss url_len={}", channel_url.len()); - let client = Client::builder() - .timeout(Duration::from_secs(PER_CHANNEL_TIMEOUT_S)) - .user_agent("Mozilla/5.0 (Android; Mobile; Straw/0.1)") - .build() - .map_err(|e| StrawcoreError::Extractor { - msg: format!("http client build: {e}"), - })?; - Ok(fetch_channel_rss(&client, &channel_url).await.unwrap_or_default()) + let client = rss_client()?; + Ok(fetch_channel_rss(client, &channel_url).await.unwrap_or_default()) } /// Bulk subscription feed fan-out — for callers that want one round-trip @@ -88,68 +122,109 @@ pub async fn subscription_feed( if channel_urls.is_empty() { return Ok(Vec::new()); } - let client = Client::builder() - .timeout(Duration::from_secs(PER_CHANNEL_TIMEOUT_S)) - .user_agent("Mozilla/5.0 (Android; Mobile; Straw/0.1)") - .build() - .map_err(|e| StrawcoreError::Extractor { - msg: format!("http client build: {e}"), - })?; + let client = rss_client()?; let results: Vec> = stream::iter(channel_urls.into_iter()) - .map(|url| { - let client = client.clone(); - async move { fetch_channel_rss(&client, &url).await.unwrap_or_default() } - }) + .map(|url| async move { fetch_channel_rss(client, &url).await.unwrap_or_default() }) .buffer_unordered(MAX_CONCURRENT) .collect() .await; - let mut flat: Vec = results.into_iter().flatten().collect(); - // Newest first by published timestamp baked into the upload_date_relative - // field at parse time — RSS already returns entries newest-first per - // channel so we mostly just need cross-channel interleave. - flat.sort_by(|a, b| b.upload_date_relative.cmp(&a.upload_date_relative)); - Ok(flat) + // Per-channel ordering is RSS-served-newest-first. Cross-channel + // interleave is the caller's responsibility — Kotlin's mergeFromCache + // sorts by parsed recency, which is the source of truth. Returning + // the flat list as-is. (vc=66 prior code sorted lexicographically + // on the relative-date STRING, which is wrong because "10 hours + // ago" < "2 hours ago" in cmp order — round-67 audit rust-HIGH-6.) + Ok(results.into_iter().flatten().collect()) } async fn fetch_channel_rss(client: &Client, channel_url: &str) -> Option> { let channel_id = extract_channel_id(channel_url)?; let url = format!("{RSS_BASE}{channel_id}"); - let body = client + let resp = client .get(&url) .send() .await .ok()? .error_for_status() - .ok()? - .text() - .await .ok()?; + // Streaming body read with a hard byte cap — `.text()` reads + // unbounded into a String. Round-67 audit rust-HIGH-5. + let body = read_capped_body(resp).await?; parse_rss(&body, channel_id) } -/// Extract the `UCxxx` channel ID from a channel URL. Handles the -/// common shapes: +/// Drain a reqwest Response into a String, bailing out (return None) if +/// the body exceeds RSS_MAX_BYTES. Round-67 audit rust-HIGH-5. +async fn read_capped_body(resp: reqwest::Response) -> Option { + use futures::StreamExt; + let mut total = 0usize; + let mut buf: Vec = Vec::with_capacity(32 * 1024); + let mut stream = resp.bytes_stream(); + while let Some(chunk_result) = stream.next().await { + let chunk = chunk_result.ok()?; + total = total.saturating_add(chunk.len()); + if total > RSS_MAX_BYTES { + log::warn!("strawcore::rss body exceeded {RSS_MAX_BYTES} bytes; aborting"); + return None; + } + buf.extend_from_slice(&chunk); + } + String::from_utf8(buf).ok() +} + +/// Extract the `UCxxx` channel ID from a channel URL. Accepts the +/// shapes the Android app actually has in Subscriptions plus the ones +/// users paste from share intents: /// * `https://www.youtube.com/channel/UCxxx...` -/// * `https://www.youtube.com/UCxxx...` (canonical clone) +/// * `https://youtube.com/channel/UCxxx...` +/// * `http(s)://m.youtube.com/channel/UCxxx...` +/// * trailing `/videos`, `?si=...`, etc — anything after the ID is dropped /// * raw `UCxxx...` (already an ID) /// +/// Real YT channel IDs are EXACTLY 24 chars (`UC` + 22 base64-ish). +/// Round-67 audit rust-HIGH-1. +/// /// `@handle` URLs are NOT supported here — RSS requires the channel ID. -/// Callers that only have an @handle should resolve via channel_info() -/// once, cache the ID into Subscriptions, and pass the ID forever after. +/// Callers with @handles should resolve via channel_info() once and +/// cache the ID into Subscriptions. fn extract_channel_id(input: &str) -> Option { let trimmed = input.trim(); - if let Some(stripped) = trimmed.strip_prefix("https://www.youtube.com/channel/") { - return Some(stripped.split('/').next()?.to_string()); + let trimmed_lower = trimmed.to_lowercase(); + // Match the ":///channel/" prefix in a single sweep + // so we accept http/https + www./m. variants without four-way + // string-strip ladders. + const PREFIXES: &[&str] = &[ + "https://www.youtube.com/channel/", + "https://youtube.com/channel/", + "https://m.youtube.com/channel/", + "http://www.youtube.com/channel/", + "http://youtube.com/channel/", + "http://m.youtube.com/channel/", + ]; + for p in PREFIXES { + if let Some(idx) = trimmed_lower.find(p) { + let rest = &trimmed[idx + p.len()..]; + let id = rest.split(|c: char| c == '/' || c == '?' || c == '#').next()?; + return validate_channel_id(id); + } } - if let Some(stripped) = trimmed.strip_prefix("https://youtube.com/channel/") { - return Some(stripped.split('/').next()?.to_string()); + validate_channel_id(trimmed) +} + +/// A real YouTube channel ID is `UC` followed by exactly 22 chars from +/// `[A-Za-z0-9_-]`. Round-67 audit rust-HIGH-1. +fn validate_channel_id(id: &str) -> Option { + if id.len() != 24 || !id.starts_with("UC") { + return None; } - if trimmed.starts_with("UC") && trimmed.len() >= 22 && trimmed.len() <= 26 { - return Some(trimmed.to_string()); + if !id.bytes().skip(2).all(|b| { + matches!(b, b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'_' | b'-') + }) { + return None; } - None + Some(id.to_string()) } fn parse_rss(body: &str, channel_id: String) -> Option> { @@ -242,7 +317,11 @@ fn parse_rss(body: &str, channel_id: String) -> Option> { let name = e.name(); let local = local_name(name.as_ref()); if local == "entry" { - if !video_id.is_empty() { + // Skip entries missing the load-bearing fields — + // an empty title renders as a blank card the user + // can't tap, and an empty published collapses the + // recency sort. Round-67 audit rust-HIGH-2. + if !video_id.is_empty() && !title.is_empty() && !published.is_empty() { items.push(SearchItem { url: format!("https://www.youtube.com/watch?v={video_id}"), title: title.clone(), @@ -266,6 +345,12 @@ fn parse_rss(body: &str, channel_id: String) -> Option> { // first in the fan-out. Caught 2026-05-26. upload_date_relative: iso_to_relative(&published), }); + if items.len() >= RSS_MAX_ENTRIES { + // Defense-in-depth against a feed that + // ships thousands of blocks. + // Round-67 audit rust-MED-6. + return Some(items); + } } in_entry = false; depth = 0; @@ -275,7 +360,15 @@ fn parse_rss(body: &str, channel_id: String) -> Option> { text_target = None; } Ok(Event::Eof) => break, - Err(_) => return None, + // Partial-parse on error: return whatever we've already + // collected rather than throwing the whole batch away. + // A truncated body (EOF mid-stream on a flaky network) + // would otherwise silently disappear the channel. + // Round-67 audit rust-CRIT-3. + Err(e) => { + log::warn!("strawcore::rss parse error after {} items: {e}", items.len()); + return Some(items); + } _ => {} } buf.clear(); @@ -307,7 +400,16 @@ fn iso_to_relative(iso: &str) -> String { .duration_since(std::time::UNIX_EPOCH) .map(|d| d.as_secs() as i64) .unwrap_or(0); - format_relative(now_secs.saturating_sub(secs)) + // A device with a skewed clock can see RSS timestamps as future- + // dated. saturating_sub returns 0 → "0 seconds ago" → sorts to + // top, which is the LTT/WTYP-recurrence vector. Treat future + // dates as "just now" so the relative-string sort behaves and + // a single skewed item doesn't pin itself at the top of the + // feed. Round-67 audit rust-HIGH-7. + if secs > now_secs { + return "just now".to_string(); + } + format_relative(now_secs - secs) } fn parse_rfc3339_secs(s: &str) -> Option { @@ -327,6 +429,13 @@ fn parse_rfc3339_secs(s: &str) -> Option { let hh: u32 = time_parts.next()?.parse().ok()?; let mm: u32 = time_parts.next()?.parse().ok()?; let ss: u32 = time_parts.next()?.parse().ok()?; + // Year clamp BEFORE civil_to_days — out-of-range years overflow + // the era arithmetic in debug, wrap in release. A hostile feed + // serving year=2147483647 must not produce junk timestamps. + // Round-67 audit rust-CRIT-1. + if !(YEAR_MIN..=YEAR_MAX).contains(&y) { + return None; + } if !(1..=12).contains(&m) || !(1..=31).contains(&d) || hh > 23 || mm > 59 || ss > 60 { return None; } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/EnrichmentStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/EnrichmentStore.kt index c18448bfd..5851fda9c 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/EnrichmentStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/EnrichmentStore.kt @@ -76,6 +76,17 @@ class EnrichmentStore(context: Context) { ) val before = _entries.value val next = _entries.updateAndGet { current -> + // Round-67 audit HIGH-4: short-circuit when the cached + // value is already the same view+duration — re-enriching + // within TTL otherwise allocates a new Map every call + // and the `before !== next` guard never triggers, so a + // refresh-after-refresh hammers the SP file. + val existing = current[videoId] + if (existing != null && + existing.viewCount == entry.viewCount && + existing.durationSeconds == entry.durationSeconds) { + return@updateAndGet current + } val withEntry = current + (videoId to entry) if (withEntry.size > MAX_ENRICHMENTS) { withEntry.entries @@ -98,7 +109,14 @@ class EnrichmentStore(context: Context) { private fun load(): Map = runCatching { val s = sp.getString(KEY, null) ?: return emptyMap() - json.decodeFromString>(s) + val loaded = json.decodeFromString>(s) + // Round-67 audit MED-6: prune TTL-expired entries on load + // so the store doesn't accumulate dead weight up to + // MAX_ENRICHMENTS over time. `Forever` TTL skips the prune. + val ttl = Settings.get().cacheTtl.value + if (ttl.isForever) return loaded + val cutoff = System.currentTimeMillis() - ttl.ms + loaded.filterValues { it.fetchedAt >= cutoff } }.getOrDefault(emptyMap()) } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/ResumePositionsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/ResumePositionsStore.kt index 42ddfc8db..9ef0c07bc 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/ResumePositionsStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/ResumePositionsStore.kt @@ -17,10 +17,13 @@ package com.sulkta.straw.data import android.content.Context import android.content.SharedPreferences +import com.sulkta.straw.StrawApp +import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.asStateFlow import kotlinx.coroutines.flow.updateAndGet +import kotlinx.coroutines.launch import kotlinx.serialization.Serializable import kotlinx.serialization.json.Json @@ -94,7 +97,27 @@ class ResumePositionsStore(context: Context) { ) val before = _positions.value val next = _positions.updateAndGet { current -> + // Round-67 audit HIGH-6: short-circuit value-equality — + // a 5s poll tick that finds the same (position, duration, + // wall-time) for an existing entry returns `current` + // unchanged so the outer `next !== before` guard + // actually short-circuits the SP write. + // + // lastWatchedAt updates every tick by definition, but + // ResumePosition equality on position+duration alone is + // ALL we care about for "did anything meaningful change." + // We re-stamp lastWatchedAt only when the player position + // actually advances. + val existing = current[videoId] + if (existing != null && + existing.positionMs == entry.positionMs && + existing.durationMs == entry.durationMs) { + return@updateAndGet current + } val withEntry = current + (videoId to entry) + // Skip sort+associate when we're under the cap (the + // common case at default 500). Sort is O(n log n); + // associate allocates another map. Round-67 audit HIGH-6. if (withEntry.size > maxResumes()) { // Drop oldest by lastWatchedAt — newcomers always land // because the entry we just added is by definition the @@ -108,7 +131,13 @@ class ResumePositionsStore(context: Context) { } } if (next !== before) { - sp.edit().putString(KEY_POSITIONS, json.encodeToString(next)).apply() + // JSON encode + SP write off Main — encoding 100k entries + // would be ~50-100 ms on a low-end device, and the 5s + // captureResumePosition poll runs on Main. Round-67 + // audit HIGH-6. + StrawApp.globalScope.launch(Dispatchers.IO) { + sp.edit().putString(KEY_POSITIONS, json.encodeToString(next)).apply() + } } } @@ -125,13 +154,20 @@ class ResumePositionsStore(context: Context) { if (videoId !in current) current else current - videoId } if (next !== before) { - sp.edit().putString(KEY_POSITIONS, json.encodeToString(next)).apply() + StrawApp.globalScope.launch(Dispatchers.IO) { + sp.edit().putString(KEY_POSITIONS, json.encodeToString(next)).apply() + } } } fun clearAll() { + val before = _positions.value _positions.updateAndGet { emptyMap() } - sp.edit().putString(KEY_POSITIONS, json.encodeToString(emptyMap())).apply() + if (before.isNotEmpty()) { + StrawApp.globalScope.launch(Dispatchers.IO) { + sp.edit().putString(KEY_POSITIONS, json.encodeToString(emptyMap())).apply() + } + } } private fun load(): Map = runCatching { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt index 76a12d77e..665e57afe 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt @@ -109,8 +109,6 @@ class VideoDetailViewModel : ViewModel() { private val _ui = MutableStateFlow(VideoDetailUiState()) val ui: StateFlow = _ui.asStateFlow() - private var loadedUrl: String? = null - // Track the active load coroutine so a rapid tap to a different video // cancels the prior fetch; otherwise a slow-to-finish older load // overwrites the newer state and the player ends up streaming A while @@ -120,23 +118,31 @@ class VideoDetailViewModel : ViewModel() { fun load(streamUrl: String) { // viewModel() is activity-scoped, so the same VM is reused across // navigations. Skip the refetch if the requested URL already has - // a resolved state. - if (loadedUrl == streamUrl && _ui.value.detail != null) return + // a resolved state. Snapshot _ui once so the two reads agree. + val snap = _ui.value + if (snap.loadedUrl == streamUrl && snap.detail != null) return // Same YT-host gate as ChannelViewModel — covers the case // where a tap on a poisoned related-card lands here. // Round-5 audit MED-3. Round-6 audit HIGH-1: cancel any // in-flight load on rejection too — otherwise the // late-arriving prior-job's fence still PASSES (loadedUrl // wasn't moved) and clobbers the "Unsupported URL" error - // banner. + // banner. round-67 audit HIGH-7: also set loadedUrl on this + // path so the gate reads coherently for any caller that + // checks _ui.value.loadedUrl on the rejected path. if (!isAllowedYtUrl(streamUrl)) { inFlight?.cancel() inFlight = null - _ui.update { VideoDetailUiState(loading = false, error = "Unsupported URL") } + _ui.update { + VideoDetailUiState( + loading = false, + error = "Unsupported URL", + loadedUrl = streamUrl, + ) + } return } inFlight?.cancel() - loadedUrl = streamUrl _ui.update { VideoDetailUiState(loading = true, loadedUrl = streamUrl) } inFlight = viewModelScope.launch { try { @@ -261,8 +267,10 @@ class VideoDetailViewModel : ViewModel() { // loads: if a subsequent load(B) cancelled this one but // we resolved past the suspension point, drop our // result rather than clobber B's state. Round-4 audit - // HIGH-2. - if (loadedUrl != streamUrl) return@launch + // HIGH-2. Round-67 audit HIGH-7: single source of + // truth — read loadedUrl from _ui rather than a + // shadowing field. + if (_ui.value.loadedUrl != streamUrl) return@launch _ui.update { VideoDetailUiState( loading = false, @@ -288,7 +296,7 @@ class VideoDetailViewModel : ViewModel() { } } catch (t: Throwable) { if (t is CancellationException) throw t - if (loadedUrl != streamUrl) return@launch + if (_ui.value.loadedUrl != streamUrl) return@launch _ui.update { VideoDetailUiState( loading = false, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/FeedRefreshScheduler.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/FeedRefreshScheduler.kt index 9d0624845..ad4f8922f 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/FeedRefreshScheduler.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/FeedRefreshScheduler.kt @@ -29,8 +29,10 @@ object FeedRefreshScheduler { wm.cancelUniqueWork(WORK_NAME) return } + // WorkManager 15-minute periodic floor — see UpdateScheduler. + // Round-67 audit MED-4. val request = PeriodicWorkRequestBuilder( - s.bgFeedRefreshInterval.value.minutes, + s.bgFeedRefreshInterval.value.minutes.coerceAtLeast(15L), TimeUnit.MINUTES, ).setConstraints( Constraints.Builder() diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/FeedRefreshWorker.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/FeedRefreshWorker.kt index 312732be1..849988922 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/FeedRefreshWorker.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/FeedRefreshWorker.kt @@ -27,6 +27,8 @@ import com.sulkta.straw.data.Settings import com.sulkta.straw.data.Subscriptions import com.sulkta.straw.feature.search.StreamItem import com.sulkta.straw.util.strawLogI +import com.sulkta.straw.util.strawLogW +import java.io.IOException class FeedRefreshWorker( context: Context, @@ -41,9 +43,21 @@ class FeedRefreshWorker( // One bulk call via the Rust subscriptionFeed fan-out. Returns // a flat list; we group by uploaderUrl to rebuild the per- // channel cache shape FeedCacheStore expects. - val flat = runCatching { + // + // Round-67 audit MED-5: distinguish transient failures + // (network down, timeout) from parse failures. The former + // wants Result.retry() so WorkManager re-attempts within the + // current window with exponential backoff; without this, a + // 30-second offline blip eats a full 6-hour refresh cycle. + val flat = try { uniffi.strawcore.subscriptionFeed(subs.map { it.url }) - }.getOrNull() ?: return Result.success() + } catch (e: IOException) { + strawLogW("FeedRefresh") { "transient network failure, retrying: ${e.message}" } + return Result.retry() + } catch (e: Throwable) { + strawLogW("FeedRefresh") { "non-transient failure, giving up this cycle: ${e.message}" } + return Result.success() + } val now = System.currentTimeMillis() val grouped: Map = flat diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt index eb393c851..391105a11 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/feed/SubscriptionFeedViewModel.kt @@ -91,12 +91,17 @@ class SubscriptionFeedViewModel : ViewModel() { if (channels.isNotEmpty()) { pruneCacheToSubs(channels) val savedTs = saved.values.maxOfOrNull { it.fetchedAt } ?: 0L + // Compute the merge off-Main first (round-67 audit + // HIGH-1) — flatMap + regex + sort on hydration was + // running on Main and could add ~10-20 ms to cold + // start on a slow phone. + val hydrated = withContext(Dispatchers.Default) { mergeFromCache(channels) } // _ui.update so a concurrent refresh()'s state write // doesn't race with this copy. vc=37 round-3 audit // HIGH-4. Only advance lastFetchedAt — never regress. _ui.update { it.copy( - items = mergeFromCache(channels), + items = hydrated, lastFetchedAt = maxOf(it.lastFetchedAt, savedTs), ) } @@ -134,6 +139,16 @@ class SubscriptionFeedViewModel : ViewModel() { /** Live refresh job, so spam-tapping Refresh doesn't fan out racing fetches. */ private var inFlight: Job? = null + /** + * The background enrichment job runs on StrawApp.globalScope so it + * outlives the VM's viewModelScope — but a refresh-cancel must + * still kill the *previous* enrichment so we don't pile up + * overlapping fan-outs (8-wide × N overlapping refreshes blows the + * concurrency budget). Tracked here, cancelled in the same places + * `inFlight` is. Round-67 audit HIGH-2/3/8. + */ + private var enrichJob: Job? = null + fun refreshIfStale() { // Skip if a refresh is already in flight. vc=36 audit CRIT-R1: // SubsPane's LaunchedEffect(subs) re-fires every time @@ -160,8 +175,11 @@ class SubscriptionFeedViewModel : ViewModel() { // channelCache when the user unsubscribes from the last // channel; we'd clear() then immediately repopulate with // phantom entries when the prior fetchChannelInto resolved. - // vc=37 round-3 audit HIGH-3. + // vc=37 round-3 audit HIGH-3. Also kill any in-flight + // enrichment fan-out so we don't end up with N overlapping + // enrich jobs piling up under spam-refresh — round-67 HIGH-8. inFlight?.cancel() + enrichJob?.cancel() val channels = Subscriptions.get().subs.value if (channels.isEmpty()) { _ui.update { it.copy(loading = false, items = emptyList(), error = null) } @@ -193,7 +211,11 @@ class SubscriptionFeedViewModel : ViewModel() { .awaitAll() } pruneCacheToSubs(channels) - val freshItems = mergeFromCache(channels) + // Move flatMap + per-item regex + sort off Main — + // viewModelScope.launch runs on Main by default and + // mergeFromCache is non-trivial on a 500-item merge. + // Round-67 audit HIGH-1. + val freshItems = withContext(Dispatchers.Default) { mergeFromCache(channels) } _ui.update { SubscriptionFeedUiState( loading = false, @@ -205,7 +227,11 @@ class SubscriptionFeedViewModel : ViewModel() { // viewCount=0 + durationSeconds=0; kick a bounded // background job that calls enrichFeedItem for the // top items and pumps a fresh _ui emit when done. - enrichVisibleItems(freshItems) + // Pass the channels snapshot so the enrich job's + // terminal mergeFromCache uses what was current at + // job start, not whatever the user's subs are by + // the time enrichment finishes ~2s later. + enrichVisibleItems(freshItems, channels) // Persist what we just freshened. Off the main thread — // JSON encode on 30 subs * 30 items is small but not // free, and SharedPreferences.apply is async anyway. @@ -317,15 +343,19 @@ class SubscriptionFeedViewModel : ViewModel() { * complete in ~2s. Skipped per-item when FeedEnrichment already * has a fresh hit (TTL controlled by Settings.cacheTtl). * - * Runs OFF viewModelScope so a refresh-cancel doesn't kill an - * enrichment that's almost done — the background fill is for - * NEXT-open paint, no rush. Uses StrawApp.globalScope. + * Runs on viewModelScope (round-67 audit HIGH-2): outliving the VM + * would mean a destroyed _ui can still receive a stale emit (and + * mergeFromCache reads a now-cleared channelCache). The next + * VM instance does its own enrichment on next refresh; nothing + * is lost by not finishing the prior one. Tracked in enrichJob so + * refresh + clearInMemoryCache can cancel it. */ - private fun enrichVisibleItems(items: List) { + private fun enrichVisibleItems(items: List, channelsSnapshot: List) { val take = items.take(ENRICH_HEAD_COUNT) .filter { it.viewCount <= 0L && it.durationSeconds <= 0L } if (take.isEmpty()) return - com.sulkta.straw.StrawApp.globalScope.launch { + enrichJob?.cancel() + enrichJob = viewModelScope.launch { val gate = Semaphore(ENRICH_PARALLELISM) coroutineScope { take.map { item -> @@ -348,11 +378,14 @@ class SubscriptionFeedViewModel : ViewModel() { } }.awaitAll() } - // Pump a fresh emit so the UI picks up the overlay. - withContext(Dispatchers.Main) { - val channels = Subscriptions.get().subs.value - _ui.update { it.copy(items = mergeFromCache(channels)) } + // Compute the merge off-Main — flatMap + per-item regex + // + sort over up to 500 items is too much for the UI + // thread. Then hop to Main only for the StateFlow emit. + // Round-67 audit HIGH-1. + val merged = withContext(Dispatchers.Default) { + mergeFromCache(channelsSnapshot) } + _ui.update { it.copy(items = merged) } } } @@ -385,8 +418,13 @@ class SubscriptionFeedViewModel : ViewModel() { fun clearInMemoryCache() { // Cancel any in-flight refresh — without this, fetchChannelInto // coroutines mid-execution would re-populate the cache after - // the clear. Round-3 audit function MED-3. + // the clear. Round-3 audit function MED-3. Also cancel any + // enrichment fan-out (lives on globalScope, NOT viewModelScope) + // — otherwise a still-running enrichment would write to + // FeedEnrichment + then push a merged emit reading the empty + // channelCache. Round-67 audit HIGH-3. inFlight?.cancel() + enrichJob?.cancel() channelCache.clear() // Use _ui.update for atomicity vs concurrent refresh writes // (round-3 audit HIGH-4). diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/ThumbnailProgress.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/ThumbnailProgress.kt index 26daa53f0..4e31e6b12 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/ThumbnailProgress.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/player/ThumbnailProgress.kt @@ -26,7 +26,9 @@ import androidx.compose.material3.MaterialTheme import androidx.compose.material3.Text import androidx.compose.runtime.Composable import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.derivedStateOf import androidx.compose.runtime.getValue +import androidx.compose.runtime.remember import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.draw.clip @@ -57,10 +59,20 @@ fun BoxScope.ThumbnailProgressOverlay(videoId: String?) { // scroll jank (vc=67). The Lifecycle pause optimization doesn't // matter for a foreground feed that's only collected while the // composable is on screen anyway. - val positions by Resume.get().positions.collectAsState() - val entry = positions[videoId] ?: return - if (entry.durationMs <= 0L) return - val fraction = (entry.positionMs.toFloat() / entry.durationMs.toFloat()) + // + // Round-67 audit MED-2: derivedStateOf isolates each row's + // dependency to ONLY its own videoId's entry. Without this, the + // 5s captureResumePosition tick re-emits the entire positions + // map → every visible thumbnail recomposes. With it, only rows + // whose specific entry changed recompose. + val positionsFlow = Resume.get().positions + val positions by positionsFlow.collectAsState() + val entry by remember(videoId) { + derivedStateOf { positions[videoId] } + } + val resolved = entry ?: return + if (resolved.durationMs <= 0L) return + val fraction = (resolved.positionMs.toFloat() / resolved.durationMs.toFloat()) .coerceIn(0f, 1f) Box( modifier = Modifier diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/update/AppUpdateClient.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/update/AppUpdateClient.kt index 4f0eacc6c..69428cec1 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/update/AppUpdateClient.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/update/AppUpdateClient.kt @@ -16,17 +16,37 @@ package com.sulkta.straw.feature.update import com.sulkta.straw.BuildConfig import com.sulkta.straw.util.runCatchingCancellable +import com.sulkta.straw.util.strawLogW import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.withContext import kotlinx.serialization.Serializable import kotlinx.serialization.json.Json +import okhttp3.CertificatePinner import okhttp3.OkHttpClient import okhttp3.Request import java.util.concurrent.TimeUnit +private const val INDEX_HOST = "fdroid.sulkta.com" private const val INDEX_URL = "https://fdroid.sulkta.com/fdroid/repo/index-v2.json" private const val REPO_BASE = "https://fdroid.sulkta.com/fdroid/repo" +/** + * Only accept file names that look like a plain APK basename. The index + * controls a string we substitute into an `ACTION_VIEW` intent; without + * sanitization a hostile or compromised index could ship `..//host/x.apk` + * or worse. Round-67 audit HIGH-5. + */ +private val APK_NAME_RE = Regex("""^/[A-Za-z0-9._-]+\.apk$""") + +/** + * Sanity-cap on parsed versionCode. Straw vc is currently low double + * digits; ten million is a horizon we won't hit organically but blocks + * a hostile index from latching us to Long.MAX_VALUE and burying every + * legitimate update behind a "you're already up to date" check. + * Round-67 audit HIGH-5. + */ +private const val MAX_PLAUSIBLE_VC = 10_000_000L + data class UpdateInfo( val versionCode: Long, val versionName: String, @@ -34,9 +54,31 @@ data class UpdateInfo( ) object AppUpdateClient { + /** + * Pin two Subject-Public-Key-Info SHA-256 hashes against + * fdroid.sulkta.com so an off-tree CA misissue can't ship the + * user an attacker-signed index. Round-67 audit HIGH-5. + * + * - sha256/8ofd... — current leaf SPKI. Rotates every ~90 days + * with each Let's Encrypt renewal; an app update before the + * next rotation refreshes this pin. + * - sha256/y7xV... — Let's Encrypt E7 intermediate SPKI. Stable + * for years; serves as the rotation-safety pin while we push + * a new leaf hash. + * + * When the leaf pin no longer matches (post-rotation), OkHttp + * still accepts the chain because the E7 intermediate pin + * matches. The next app release rolls the leaf forward. + */ + private val pinner: CertificatePinner = CertificatePinner.Builder() + .add(INDEX_HOST, "sha256/8ofdiPS6TAiUx9zb2O7Qa9IKZQ3D2i+18teKCrz/MqA=") + .add(INDEX_HOST, "sha256/y7xVm0TVJNahMr2sZydE2jQH8SquXV9yLF9seROHHHU=") + .build() + private val http: OkHttpClient = OkHttpClient.Builder() .connectTimeout(15, TimeUnit.SECONDS) .readTimeout(15, TimeUnit.SECONDS) + .certificatePinner(pinner) .build() private val json = Json { ignoreUnknownKeys = true } @@ -58,10 +100,29 @@ object AppUpdateClient { val best = pkg.versions.values .maxByOrNull { it.manifest.versionCode } ?: return@runCatchingCancellable null + // Reject implausible versionCodes outright — see + // MAX_PLAUSIBLE_VC. Round-67 audit HIGH-5. + if (best.manifest.versionCode <= 0 || + best.manifest.versionCode > MAX_PLAUSIBLE_VC) { + strawLogW("StrawUpdate") { + "rejecting implausible versionCode=${best.manifest.versionCode}" + } + return@runCatchingCancellable null + } + // Strict APK-basename match before we hand this off to + // ACTION_VIEW. Anything else gets logged + dropped. + // Round-67 audit HIGH-5. + val fileName = best.file.name + if (!APK_NAME_RE.matches(fileName)) { + strawLogW("StrawUpdate") { + "rejecting unsafe file.name=${fileName.take(80)}" + } + return@runCatchingCancellable null + } UpdateInfo( versionCode = best.manifest.versionCode, versionName = best.manifest.versionName.orEmpty(), - apkUrl = "$REPO_BASE${best.file.name}", + apkUrl = "$REPO_BASE$fileName", ) }.getOrNull() } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/update/UpdateScheduler.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/update/UpdateScheduler.kt index b24ffe6e5..d91cf3461 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/update/UpdateScheduler.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/update/UpdateScheduler.kt @@ -34,8 +34,12 @@ object UpdateScheduler { wm.cancelUniqueWork(WORK_NAME) return } + // WorkManager floors periodic intervals at 15 minutes. + // coerceAtLeast(15) future-proofs against a smaller enum case + // landing without anyone noticing the silent clamp. Round-67 + // audit MED-4. val request = PeriodicWorkRequestBuilder( - interval.minutes, + interval.minutes.coerceAtLeast(15L), TimeUnit.MINUTES, ).setConstraints( Constraints.Builder() From 5f2ba264b068bbf271641d8910f92b077f525c9d Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 20:56:24 -0700 Subject: [PATCH 67/72] vc=68 fixup: enable reqwest 'stream' feature for bytes_stream --- rust/strawcore/Cargo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rust/strawcore/Cargo.toml b/rust/strawcore/Cargo.toml index 630ef94ef..047f10f69 100644 --- a/rust/strawcore/Cargo.toml +++ b/rust/strawcore/Cargo.toml @@ -41,7 +41,7 @@ android_logger = { version = "0.14", default-features = false } # strawcore-core's already-pulled reqwest; quick-xml is small (~200KB); # futures for buffer_unordered. rustls-tls avoids the NDK openssl headers # headache. -reqwest = { version = "0.12", default-features = false, features = ["rustls-tls", "gzip"] } +reqwest = { version = "0.12", default-features = false, features = ["rustls-tls", "gzip", "stream"] } quick-xml = "0.36" futures = "0.3" From 23fb6f52b01800a00092ba8f2c5d9ac15609a99c Mon Sep 17 00:00:00 2001 From: Kayos Date: Tue, 26 May 2026 21:31:07 -0700 Subject: [PATCH 68/72] vc=69: audit-fix sprint round 2 (regressions on round 1) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Round-2 audit caught four real regressions on round-1 fixes plus a handful of MEDs. This sprint fixes them. H1 — FeedRefreshWorker exception class Round 1 wrapped subscriptionFeed in try/catch IOException, but UniFFI generates StrawcoreException (kotlin.Exception, not IOException). The retry path was dead code. Catch StrawcoreException.Network instead — the variant our error.rs maps NetworkError::Transport into. H2 — enrichJob terminal emit cancellation race withContext(Dispatchers.Default) { mergeFromCache(...) } has no suspension points so a cancel arriving mid-merge isn't observed until the next suspending call. Without a guard, the non-suspending _ui.update lands AFTER clearInMemoryCache() and resurrects the cleared items. Add coroutineContext.ensureActive() after each withContext hop, before the emit. Applied on both the refresh terminal emit and the enrich terminal emit. H6 — enrichVisibleItems shows stale subscriptions The channelsSnapshot captured at refresh-end is ~2s stale by the time the enrich terminal emit runs. If the user unsubscribed from X in that window, X's items still appear on the feed for one frame. Re-read Subscriptions at the terminal step and intersect with the snapshot. R-H3 — extract_channel_id substring match Round 1 used trimmed_lower.find(prefix) which matches ANY position. evil.com/?redir=https://www.youtube.com/channel/UCxxx silently rewrote to the embedded channel ID. strip_prefix() anchors at byte 0. ASCII-only prefix means byte indices align in trimmed_lower vs trimmed. R-H2 — String::from_utf8 silent-drop YouTube ships mojibake titles in the wild. Strict from_utf8 returned None on any bad byte, dropping the entire channel from the feed with only a quiet None. Switch to from_utf8_lossy — quick-xml tolerates U+FFFD replacement chars and the per-entry skip-on-empty handles broken entries. R-H1 — read_capped_body per-chunk size sanity HTTP allows arbitrarily large single chunks. Reject any chunk exceeding the whole body cap before adding it to the buffer, so a hostile server can't get us to allocate a hyper Bytes larger than the cap. M3 — Avatar URL validation ch.avatar is extractor-emitted; a poisoned channel page could ship data:image/svg+xml,...

We are rewriting large chunks of the codebase, to bring about a modern and stable NewPipe! You can download nightly builds here.

-

Please work on the refactor branch if you want to contribute new features. The current codebase is in maintenance mode and will only receive bugfixes.

+# Straw -

-

NewPipe

-

A libre lightweight streaming front-end for Android.

+A Sulkta fork of [NewPipe](https://github.com/TeamNewPipe/NewPipe). Android YouTube +client, Compose UI, Media3 player, with [SponsorBlock](https://sponsor.ajay.app/) +and [Return YouTube Dislike](https://returnyoutubedislike.com/) baked in. -

Get it on F-Droid

+The extractor is `strawcore`, a Rust port of NewPipeExtractor exposed to Kotlin +via UniFFI. No InnerTube/JS deobf code path lives on the JVM anymore. -

- - - - - - -

+## Install -

- - -

+F-Droid repo: -
-

Screenshots • Supported Services • Description • Features • Installation and updates • Contribution • Donate • License

-

Website • Blog • FAQ • Press

-
+Add the repo in your F-Droid client of choice, then install Straw. -*Read this document in other languages: [Deutsch](doc/README.de.md), [English](README.md), [Español](doc/README.es.md), [Français](doc/README.fr.md), [हिन्दी](doc/README.hi.md), [Italiano](doc/README.it.md), [한국어](doc/README.ko.md), [Português Brasil](doc/README.pt_BR.md), [Polski](doc/README.pl.md), [ਪੰਜਾਬੀ ](doc/README.pa.md), [日本語](doc/README.ja.md), [Română](doc/README.ro.md), [Soomaali](doc/README.so.md), [Türkçe](doc/README.tr.md), [正體中文](doc/README.zh_TW.md), [অসমীয়া](doc/README.asm.md), [Српски](doc/README.sr.md), [العربية](README.ar.md)* +The app also self-updates from the same repo when an APK lands there with a +higher `versionCode`. -> [!warning] -> THIS APP IS IN BETA, SO YOU MAY ENCOUNTER BUGS. IF YOU DO, OPEN AN ISSUE IN OUR GITHUB REPOSITORY BY FILLING OUT THE ISSUE TEMPLATE. -> -> PUTTING NEWPIPE, OR ANY FORK OF IT, INTO THE GOOGLE PLAY STORE VIOLATES THEIR TERMS AND CONDITIONS. +## What's in -## Screenshots +- Search, video detail, channel pages, playlists +- Inline player + fullscreen + minibar + background audio + PiP +- Media3 ExoPlayer (DASH / HLS / progressive / merged DASH chunks) +- SponsorBlock auto-skip (categories user-toggleable) +- Return YouTube Dislike on video detail +- RSS-based subscription feed (fast — ~1s for 50 subs) +- Hide-shorts / hide-paid / hide-age-restricted feed filters +- Resume positions + watch history + search history +- Local playlists, downloads (video + audio) +- NewPipe-format settings import (subs + playlists + history) -[](fastlane/metadata/android/en-US/images/phoneScreenshots/00.png) -[](fastlane/metadata/android/en-US/images/phoneScreenshots/01.png) -[](fastlane/metadata/android/en-US/images/phoneScreenshots/02.png) -[](fastlane/metadata/android/en-US/images/phoneScreenshots/03.png) -[](fastlane/metadata/android/en-US/images/phoneScreenshots/04.png) -[](fastlane/metadata/android/en-US/images/phoneScreenshots/05.png) -[](fastlane/metadata/android/en-US/images/phoneScreenshots/06.png) -[](fastlane/metadata/android/en-US/images/phoneScreenshots/07.png) -[](fastlane/metadata/android/en-US/images/phoneScreenshots/08.png) -

-[](fastlane/metadata/android/en-US/images/tenInchScreenshots/09.png) -[](fastlane/metadata/android/en-US/images/tenInchScreenshots/10.png) +## What's out (on purpose) -### Supported Services +- Trending / algorithmic feeds. Subscriptions only. +- iOS / desktop targets. Android-only for now. +- Google Play Services anything. -NewPipe currently supports these services: +## Layout - -* YouTube ([website](https://www.youtube.com/)) and YouTube Music ([website](https://music.youtube.com/)) ([wiki](https://en.wikipedia.org/wiki/YouTube)) -* PeerTube ([website](https://joinpeertube.org/)) and all its instances (open the website to know what that means!) ([wiki](https://en.wikipedia.org/wiki/PeerTube)) -* Bandcamp ([website](https://bandcamp.com/)) ([wiki](https://en.wikipedia.org/wiki/Bandcamp)) -* SoundCloud ([website](https://soundcloud.com/)) ([wiki](https://en.wikipedia.org/wiki/SoundCloud)) -* media.ccc.de ([website](https://media.ccc.de/)) ([wiki](https://en.wikipedia.org/wiki/Chaos_Computer_Club)) - -As you can see, NewPipe supports multiple video and audio services. Though it started off with YouTube, other people have added more services over the years, making NewPipe more and more versatile! - -Partially due to circumstance, and partially due to its popularity, YouTube is the best supported out of these services. If you use or are familiar with any of these other services, please help us improve support for them! We're looking for maintainers for SoundCloud and PeerTube. - -If you intend to add a new service, please get in touch with us first! Our [docs](https://teamnewpipe.github.io/documentation/) provide more information on how a new service can be added to the app and to the [NewPipe Extractor](https://github.com/TeamNewPipe/NewPipeExtractor). - -## Description - -NewPipe works by fetching the required data from the official API (e.g. PeerTube) of the service you're using. If the official API is restricted (e.g. YouTube) for our purposes, or is proprietary, the app parses the website or uses an internal API instead. This means that you don't need an account on any service to use NewPipe. - -Also, since they are free and open source software, neither the app nor the Extractor use any proprietary libraries or frameworks, such as Google Play Services. This means you can use NewPipe on devices or custom ROMs that do not have Google apps installed. - -### Features - -* Watch videos at resolutions up to 4K -* Listen to audio in the background, only loading the audio stream to save data -* Popup mode (floating player, aka Picture-in-Picture) -* Watch live streams -* Show/hide subtitles/closed captions -* Search videos and audios (on YouTube, you can specify the content language as well) -* Enqueue videos (and optionally save them as local playlists) -* Show/hide general information about videos (such as description and tags) -* Show/hide next/related videos -* Show/hide comments -* Search videos, audios, channels, playlists and albums -* Browse videos and audios within a channel -* Subscribe to channels (yes, without logging into any account!) -* Get notifications about new videos from channels you're subscribed to -* Create and edit channel groups (for easier browsing and management) -* Browse video feeds generated from your channel groups -* View and search your watch history -* Search and watch playlists (these are remote playlists, which means they're fetched from the service you're browsing) -* Create and edit local playlists (these are created and saved within the app, and have nothing to do with any service) -* Download videos/audios/subtitles (closed captions) -* Open in Kodi -* Watch/Block age-restricted material - - - - -## Installation and updates -You can install NewPipe using one of the following methods: - 1. Add our custom repo to F-Droid and install it from there. The instructions are here: https://newpipe.net/FAQ/tutorials/install-add-fdroid-repo/ - 2. Download the APK from [GitHub Releases](https://github.com/TeamNewPipe/NewPipe/releases), [compare the signing key](#apk-info) and install it. - 3. Update via F-Droid. This is the slowest method of getting updates, as F-Droid must recognize changes, build the APK itself, sign it, and then push the update to users. - 4. Build a debug APK yourself. This is the fastest way to get new features on your device, but is much more complicated, so we recommend using one of the other methods. - 5. If you're interested in a specific feature or bugfix provided in a Pull Request in this repo, you can also download its APK from within the PR. Read the PR description for instructions. The great thing about PR-specific APKs is that they're installed side-by-side the official app, so you don't have to worry about losing your data or messing anything up. - -We recommend method 1 for most users. APKs installed using method 1 or 2 are compatible with each other (meaning that if you installed NewPipe using either method 1 or 2, you can also update NewPipe using the other), but not with those installed using method 3. This is due to the same signing key (ours) being used for 1 and 2, but a different signing key (F-Droid's) being used for 3. Building a debug APK using method 4 excludes a key entirely. Signing keys help ensure that a user isn't tricked into installing a malicious update to an app. When using method 5, each APK is signed with a different random key supplied by GitHub Actions, so you cannot even update it. You will have to backup and restore the app data each time you wish to use a new APK. - -In the meanwhile, if you want to switch sources for some reason (e.g. NewPipe's core functionality breaks and F-Droid doesn't have the latest update yet), we recommend following this procedure: -1. Back up your data via Settings > Backup and Restore > Export Database so you keep your history, subscriptions, and playlists -2. Uninstall NewPipe -3. Download the APK from the new source and install it -4. Import the data from step 1 via Settings > Backup and Restore > Import Database - -> [!Note] -> When you're importing a database into the official app, always make sure that it is the one you exported _from_ the official app. If you import a database exported from an APK other than the official app, it may break things. Such an action is unsupported, and you should only do so when you're absolutely certain you know what you're doing. - -### APK Info - -This is the SHA fingerprint of NewPipe's signing key to verify downloaded APKs which are signed by us. The fingerprint is also available on [NewPipe's website](https://newpipe.net#download). This is relevant for method 2. ``` -CB:84:06:9B:D6:81:16:BA:FA:E5:EE:4E:E5:B0:8A:56:7A:A6:D8:98:40:4E:7C:B1:2F:9E:75:6D:F5:CF:5C:AB +strawApp/ Sulkta-authored app — Compose UI, Media3 wiring, SB + RYD clients +rust/ strawcore — UniFFI wrapper around the Rust extractor +shared/ KMP scaffold inherited from upstream NewPipe (unused for now) +app/ Upstream NewPipe :app module — kept for reference ``` -## Contribution -Whether you have ideas, translations, design changes, code cleaning, or even major code changes, help is always welcome. The app gets better and better with each contribution, no matter how big or small! If you'd like to get involved, check our [contribution notes](.github/CONTRIBUTING.md). +## Build - -Translation status - +``` +./gradlew :strawApp:assembleDebug +``` -## Donate -If you like NewPipe, you're welcome to send a donation. We prefer Liberapay, as it is both open-source and non-profit. For further info on donating to NewPipe, please visit our [website](https://newpipe.net/donate). +Requires the Rust toolchain plus the four Android targets: - - - - - - -
LiberapayVisit NewPipe at liberapay.comDonate via Liberapay
+``` +rustup target add aarch64-linux-android armv7-linux-androideabi \ + x86_64-linux-android i686-linux-android +cargo install cargo-ndk uniffi-bindgen +``` -## Privacy Policy - -The NewPipe project aims to provide a private, anonymous experience for using web-based media services. Therefore, the app does not collect any data without your consent. NewPipe's privacy policy explains in detail what data is sent and stored when you send a crash report, or leave a comment in our blog. You can find the document [here](https://newpipe.net/legal/privacy/). +…and `ANDROID_NDK_HOME` pointing at NDK r27c (or newer). The Gradle build runs +`cargo ndk` + `uniffi-bindgen` automatically. ## License -[![GNU GPLv3 Image](https://www.gnu.org/graphics/gplv3-127x51.png)](https://www.gnu.org/licenses/gpl-3.0.en.html) -NewPipe is Free Software: You can use, study, share, and improve it at will. Specifically you can redistribute and/or modify it under the terms of the [GNU General Public License](https://www.gnu.org/licenses/gpl.html) as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. +GPL-3.0-or-later, inherited from upstream NewPipe. + +## Upstream + +This repo tracks . Upstream changes +get pulled periodically via the `upstream` remote. + +## Disclaimer + +Not affiliated with YouTube, Google, NewPipe e.V., the SponsorBlock project, +or Return YouTube Dislike. Trademarks belong to their owners. Straw uses +public web endpoints; nothing here authenticates to any account. diff --git a/rust/Cargo.toml b/rust/Cargo.toml index 7ee7f3ec7..880e1f4b7 100644 --- a/rust/Cargo.toml +++ b/rust/Cargo.toml @@ -14,7 +14,7 @@ members = ["strawcore"] edition = "2021" license = "GPL-3.0-or-later" authors = ["Sulkta-Coop"] -repository = "http://192.168.0.5:3001/Sulkta-Coop/straw" +repository = "https://git.sulkta.com/Sulkta-Coop/straw" [profile.release] # Strip debug info, run thin LTO. APK size matters more than build time here. @@ -29,6 +29,6 @@ opt-level = "z" url = "2" [profile.dev] -# Keep debug builds fast — we're rebuilding constantly during U-1..U-5. +# Keep debug builds fast — we rebuild often during NDK cross-compile. opt-level = 0 debug = 1 diff --git a/rust/README.md b/rust/README.md index 2aa515b4c..720f81fa9 100644 --- a/rust/README.md +++ b/rust/README.md @@ -20,12 +20,12 @@ moves to Rust. ## Build chain ``` -crafting-table +Build container (Sulkta uses one; any toolchain matching this layout works) ├── rustup stable (target add: aarch64-linux-android, armv7-linux-androideabi, │ x86_64-linux-android, i686-linux-android) ├── cargo-ndk (cross-compile helper) ├── android-sdk (ANDROID_HOME, sdkmanager, build-tools, platforms) -└── android-ndk (ANDROID_NDK_HOME, r27c LTS at /caches/android-sdk/ndk/...) +└── android-ndk (ANDROID_NDK_HOME, r27c LTS) Gradle (strawApp/build.gradle.kts) ├── cargoBuild Exec task → cargo ndk -t ... -o jniLibs/ build --release diff --git a/rust/strawcore/Cargo.toml b/rust/strawcore/Cargo.toml index 047f10f69..6ccd53fd5 100644 --- a/rust/strawcore/Cargo.toml +++ b/rust/strawcore/Cargo.toml @@ -30,14 +30,14 @@ strawcore-core = { path = "../../../strawcore" } # Android target has no pre-generated bindings — flip on the `bindgen` # feature so cargo regenerates at build time. Direct dep so the feature # flag propagates (cargo's unified feature resolver lifts this to the -# transitive use). Crafting-table has libclang preinstalled. +# transitive use). Build host needs libclang installed. rquickjs-sys = { version = "0.11", default-features = false, features = ["bindgen"] } # Error glue. thiserror = "1" # Android log integration — `log::info!()` ends up in `adb logcat -s strawcore`. log = "0.4" android_logger = { version = "0.14", default-features = false } -# vc=56 — subscription RSS feed fan-out. reqwest dedupes against +# subscription RSS feed fan-out. reqwest dedupes against # strawcore-core's already-pulled reqwest; quick-xml is small (~200KB); # futures for buffer_unordered. rustls-tls avoids the NDK openssl headers # headache. diff --git a/rust/strawcore/src/error.rs b/rust/strawcore/src/error.rs index 7b840fbe3..2703813b5 100644 --- a/rust/strawcore/src/error.rs +++ b/rust/strawcore/src/error.rs @@ -69,7 +69,7 @@ impl From for StrawcoreError { // catches googlevideo.com hosts. The challenge URL // itself still solves without `continue=`, so the // user can tap to unblock without leaking the - // signature/expire/pot token. Round-4 audit LOW-1. + // signature/expire/pot token. StrawcoreError::RequiresLogin { detail: format!("reCAPTCHA challenge: {}", strip_continue_param(&url)), } diff --git a/rust/strawcore/src/feed.rs b/rust/strawcore/src/feed.rs index 54a372df5..c50b2942c 100644 --- a/rust/strawcore/src/feed.rs +++ b/rust/strawcore/src/feed.rs @@ -1,4 +1,4 @@ -// vc=56 — fast subscription feed via YouTube's per-channel RSS endpoint. +// fast subscription feed via YouTube's per-channel RSS endpoint. // // YouTube serves `https://www.youtube.com/feeds/videos.xml?channel_id=UCxxx` // — small Atom XML, no auth, no JS, no InnerTube round-trip. Replaces the @@ -28,18 +28,15 @@ const PER_CHANNEL_TIMEOUT_S: u64 = 8; /// Cap on the body bytes we'll read for a single RSS fetch. Real YT /// Atom feeds are ~5-30 KB; 2 MiB leaves comfortable headroom while /// blocking a hostile or compromised host from streaming GB-scale -/// bodies into JVM memory inside the 8s timeout. Round-67 audit -/// rust-HIGH-5. +/// bodies into JVM memory inside the 8s timeout. const RSS_MAX_BYTES: usize = 2 * 1024 * 1024; /// Cap on parsed entries per channel — RSS normally returns 15. /// 50 leaves headroom for one-off legitimate variance; anything /// past that is a sign the feed isn't what we expect. -/// Round-67 audit rust-MED-6. const RSS_MAX_ENTRIES: usize = 50; /// Year range we trust civil-to-days math for. Strawcore RSS only /// emits real-world recent uploads; clamping here turns adversarial /// year fields into a parse failure rather than i64 overflow. -/// Round-67 audit rust-CRIT-1. const YEAR_MIN: i32 = 1970; const YEAR_MAX: i32 = 2200; @@ -48,7 +45,7 @@ const YEAR_MAX: i32 = 2200; /// items after the RSS-fed paint to fill in the gaps that /// channel_feed_rss leaves empty. /// -/// vc=66 — built specifically so the subs feed can show 'N views · +/// built specifically so the subs feed can show 'N views · /// X duration' the way YT does, without paying the full channel_info /// page-scrape cost on initial paint. The underlying stream_info IS /// heavier than we'd like (~500ms each, runs JS deobf for play URLs @@ -75,7 +72,7 @@ pub async fn enrich_feed_item( /// Shared reqwest Client — DNS resolver + TLS keepalive + connection /// pool live here so a 50-channel fan-out reuses one pool instead of -/// paying 50 handshakes. Round-67 audit rust-HIGH-4. +/// paying 50 handshakes. static RSS_CLIENT: OnceLock = OnceLock::new(); fn rss_client() -> Result<&'static Client, StrawcoreError> { @@ -86,7 +83,7 @@ fn rss_client() -> Result<&'static Client, StrawcoreError> { .timeout(Duration::from_secs(PER_CHANNEL_TIMEOUT_S)) .user_agent(concat!("Mozilla/5.0 (Android; Mobile; Straw/", env!("CARGO_PKG_VERSION"), ")")) // Cap redirect chains so a misconfigured/hostile feed can't - // spin a server out of our 8s budget. Round-67 audit rust-LOW-8. + // spin a server out of our 8s budget. .redirect(reqwest::redirect::Policy::limited(3)) .build() .map_err(|e| StrawcoreError::Extractor { @@ -133,9 +130,9 @@ pub async fn subscription_feed( // Per-channel ordering is RSS-served-newest-first. Cross-channel // interleave is the caller's responsibility — Kotlin's mergeFromCache // sorts by parsed recency, which is the source of truth. Returning - // the flat list as-is. (vc=66 prior code sorted lexicographically + // the flat list as-is. (an earlier version sorted lexicographically // on the relative-date STRING, which is wrong because "10 hours - // ago" < "2 hours ago" in cmp order — round-67 audit rust-HIGH-6.) + // ago" < "2 hours ago" in cmp order) Ok(results.into_iter().flatten().collect()) } @@ -150,13 +147,13 @@ async fn fetch_channel_rss(client: &Client, channel_url: &str) -> Option Option { use futures::StreamExt; let mut total = 0usize; @@ -168,8 +165,7 @@ async fn read_capped_body(resp: reqwest::Response) -> Option { // large (HTTP allows multi-GiB chunks). Reject any one chunk // bigger than the whole body cap before we even add it to the // running total — protects against hyper having already - // allocated the chunk on our behalf. Round-68 audit - // rust-HIGH-1. + // allocated the chunk on our behalf. if chunk.len() > RSS_MAX_BYTES { log::warn!("strawcore::rss single chunk {} exceeds cap; aborting", chunk.len()); return None; @@ -181,7 +177,7 @@ async fn read_capped_body(resp: reqwest::Response) -> Option { } buf.extend_from_slice(&chunk); } - // Lossy decode — round-68 audit rust-HIGH-2. A strict from_utf8 + // Lossy decode — A strict from_utf8 // returns None on any invalid byte, so a single mojibake title // would silently drop the entire channel from the feed. quick-xml // tolerates U+FFFD replacement chars and the per-entry skip-on- @@ -199,7 +195,6 @@ async fn read_capped_body(resp: reqwest::Response) -> Option { /// * raw `UCxxx...` (already an ID) /// /// Real YT channel IDs are EXACTLY 24 chars (`UC` + 22 base64-ish). -/// Round-67 audit rust-HIGH-1. /// /// `@handle` URLs are NOT supported here — RSS requires the channel ID. /// Callers with @handles should resolve via channel_info() once and @@ -210,7 +205,7 @@ fn extract_channel_id(input: &str) -> Option { // Match the ":///channel/" prefix in a single sweep // so we accept http/https + www./m. variants without four-way // string-strip ladders. ANCHORED at the start of the string — - // round-68 audit rust-HIGH-3: prior `find()` accepted any input + // prior `find()` accepted any input // containing the prefix as a substring, so a pasted // `evil.com/?redir=https://www.youtube.com/channel/UCxxx` would // silently rewrite to the wrong channel. @@ -237,7 +232,7 @@ fn extract_channel_id(input: &str) -> Option { } /// A real YouTube channel ID is `UC` followed by exactly 22 chars from -/// `[A-Za-z0-9_-]`. Round-67 audit rust-HIGH-1. +/// `[A-Za-z0-9_-]`. fn validate_channel_id(id: &str) -> Option { if id.len() != 24 || !id.starts_with("UC") { return None; @@ -343,7 +338,7 @@ fn parse_rss(body: &str, channel_id: String) -> Option> { // Skip entries missing the load-bearing fields — // an empty title renders as a blank card the user // can't tap, and an empty published collapses the - // recency sort. Round-67 audit rust-HIGH-2. + // recency sort. if !video_id.is_empty() && !title.is_empty() && !published.is_empty() { items.push(SearchItem { url: format!("https://www.youtube.com/watch?v={video_id}"), @@ -360,7 +355,7 @@ fn parse_rss(body: &str, channel_id: String) -> Option> { // RSS gives RFC3339 timestamps. Convert to // the human-relative format Kotlin's // recencyScore parser expects ("N units - // ago"). vc=56 was passing the raw ISO + // ago"). An earlier build was passing the raw ISO // through, which broke the sort comparator // — every item tied at MIN_VALUE so the // feed order was effectively random; LTT + @@ -371,7 +366,6 @@ fn parse_rss(body: &str, channel_id: String) -> Option> { if items.len() >= RSS_MAX_ENTRIES { // Defense-in-depth against a feed that // ships thousands of blocks. - // Round-67 audit rust-MED-6. return Some(items); } } @@ -387,7 +381,6 @@ fn parse_rss(body: &str, channel_id: String) -> Option> { // collected rather than throwing the whole batch away. // A truncated body (EOF mid-stream on a flaky network) // would otherwise silently disappear the channel. - // Round-67 audit rust-CRIT-3. Err(e) => { log::warn!("strawcore::rss parse error after {} items: {e}", items.len()); return Some(items); @@ -428,7 +421,7 @@ fn iso_to_relative(iso: &str) -> String { // top, which is the LTT/WTYP-recurrence vector. Treat future // dates as "just now" so the relative-string sort behaves and // a single skewed item doesn't pin itself at the top of the - // feed. Round-67 audit rust-HIGH-7. + // feed. if secs > now_secs { return "just now".to_string(); } @@ -455,7 +448,6 @@ fn parse_rfc3339_secs(s: &str) -> Option { // Year clamp BEFORE civil_to_days — out-of-range years overflow // the era arithmetic in debug, wrap in release. A hostile feed // serving year=2147483647 must not produce junk timestamps. - // Round-67 audit rust-CRIT-1. if !(YEAR_MIN..=YEAR_MAX).contains(&y) { return None; } diff --git a/rust/strawcore/src/runtime.rs b/rust/strawcore/src/runtime.rs index 7e1ef14c8..336d6b4bb 100644 --- a/rust/strawcore/src/runtime.rs +++ b/rust/strawcore/src/runtime.rs @@ -3,7 +3,7 @@ // strawcore-core Downloader + Localization singleton so the extractor // has an HTTP client to use. // -// Round-4 audit HIGH-1: the prior shape used `Once::call_once` and +// the prior shape used `Once::call_once` and // silently swallowed errors. If the FIRST call ran while the network // stack wasn't ready (cold boot in airplane mode, SELinux denial on // first TLS init, transient resolver failure), the Once slot was @@ -60,7 +60,7 @@ pub fn ensure_initialized() { // DownloaderMissing once from the extractor and recover on // the next user action; the alternative (blocking N tokio // workers for the full duration of a slow init) freezes the - // UI. Round-6 audit HIGH-2 was the regression on round-5's + // UI. was the regression on round-5's // mutex-first ordering. let _guard = match INIT_LOCK.try_lock() { Ok(g) => g, diff --git a/rust/strawcore/src/search.rs b/rust/strawcore/src/search.rs index 056af6977..f99c29da9 100644 --- a/rust/strawcore/src/search.rs +++ b/rust/strawcore/src/search.rs @@ -58,9 +58,9 @@ pub async fn search(query: String) -> Result, StrawcoreError> { // names, sometimes embarrassing) and android_logger emits at // info-level in release builds, which means they'd ride the // Settings → Export Logs path straight into a user's chat. Log - // shape, not content. vc=36 audit CVE HIGH-2. + // shape, not content. log::info!("strawcore::search query_len={}", query.len()); - // Round-5 audit MED-1: ensure_initialized was only wired into + // ensure_initialized was only wired into // init_logging() so the 5s-backoff retry path never fired from // the hot entry points. Now every extractor entry re-asserts // — cheap when INITIALIZED is true (single Acquire load). diff --git a/strawApp/build.gradle.kts b/strawApp/build.gradle.kts index e6458448e..13fbac20b 100644 --- a/strawApp/build.gradle.kts +++ b/strawApp/build.gradle.kts @@ -154,7 +154,7 @@ dependencies { // - cargo + rustup with the four Android targets installed // - cargo-ndk on PATH // - ANDROID_NDK_HOME pointing at an NDK with the right toolchains -// All of that lives in the crafting-table container. +// All of that lives in the Sulkta build container. // ============================================================================= val rustRoot = file("../rust").absolutePath @@ -166,9 +166,10 @@ val cargoBin: String = "$cargoHome/bin/cargo" val ndkHome: String = System.getenv("ANDROID_NDK_HOME") ?: System.getenv("ANDROID_NDK_ROOT") ?: "/caches/android-sdk/ndk/27.2.12479018" -// Honor CARGO_TARGET_DIR if set (we redirect it to /caches on crafting-table -// because the container's writable rootfs hits 100% before the cross-compile -// for 4 ABIs finishes). Falls back to the default `/target`. +// Honor CARGO_TARGET_DIR if set (our build container redirects it to a +// cache mount because the container's writable rootfs hits 100% before +// the cross-compile for 4 ABIs finishes). Falls back to the default +// `/target`. val cargoTargetDir: String = System.getenv("CARGO_TARGET_DIR") ?: "$rustRoot/target" diff --git a/strawApp/src/main/AndroidManifest.xml b/strawApp/src/main/AndroidManifest.xml index e751d37f5..56adc1f94 100644 --- a/strawApp/src/main/AndroidManifest.xml +++ b/strawApp/src/main/AndroidManifest.xml @@ -38,11 +38,11 @@ + with ALLOWED_YT_HOSTS in util/YtUrl.kt (canonical home). + Was previously inlined in StrawActivity.kt under YT_HOSTS; + the two lists drifted (music.youtube.com etc. accepted by + code but never offered by the launcher disambig), so the + canonical list lives in one place now. --> @@ -63,11 +63,11 @@ - + @@ -74,7 +74,7 @@ class StrawApp : Application() { Playlists.init(this) Resume.init(this) FeedEnrichment.init(this) - // vc=36 audit HIGH-R3: FeedCache (~225 KB) + SearchCache + // FeedCache (~225 KB) + SearchCache // (~150 KB) JSON-decode at construction. Stash the // applicationContext eagerly (cheap) so `get()` is callable // anywhere; the actual store construction (and the disk @@ -83,7 +83,7 @@ class StrawApp : Application() { // main thread. FeedCache.init(this) SearchCache.init(this) - // vc=36 audit CVE HIGH-5: sweepStale's deleteRecursively() + // sweepStale's deleteRecursively // can walk ~256 MB if a previous import was LMK-killed // mid-extraction. Strictly off the main thread. appScope.launch { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt index 94ac9fe69..d62c68852 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/StrawHome.kt @@ -295,7 +295,7 @@ private fun SubsPane( LaunchedEffect(subs) { feedVm.refreshIfStale() } // Filter + pagination state. hideWatched is sticky for the session - // (no SharedPreferences yet — easy to add if Cobb wants persistence). + // (no SharedPreferences yet — easy to add if persistence is wanted). // visibleCount starts at PAGE_SIZE and grows by PAGE_SIZE every time // the scroll passes ~5 items from the bottom of what's currently // visible. @@ -324,7 +324,7 @@ private fun SubsPane( } } // remember the page-slice so we don't allocate a new ArrayList on - // every recomposition (scroll hitch vc=67). + // every recomposition (scroll hitch). val displayed = remember(filteredItems, visibleCount) { filteredItems.take(visibleCount) } @@ -373,7 +373,7 @@ private fun SubsPane( Spacer(modifier = Modifier.height(16.dp)) // Show a slim error banner above cached items even if we have data — - // audit HIGH-7: previously a 401/429 looked identical to a successful + // previously a 401/429 looked identical to a successful // refresh because the error chip was hidden whenever items != empty. if (feed.error != null && feed.items.isNotEmpty()) { Text( @@ -425,7 +425,7 @@ private fun SubsPane( // (displayed.size, hasMore) was mutated BY this effect, // which cancelled the snapshotFlow collector mid-stream // and produced the "scrolled to bottom, nothing loads" - // bug from the vc=34 audit. + // bug from the audit. // // hasMore and filteredItems are read inside the // snapshotFlow producer (not closed over from outside) @@ -598,7 +598,7 @@ private fun SubChip( // width breaks the prior 2-line wrap mid-word ("NoCopyrightS // / ounds", "DEFCONConfe / rence") — uglier than a clean // "NoCopyrigh…". Centered text alignment so the ellipsis - // sits over the chip's icon column. vc=64. + // sits over the chip's icon column. Text( text = ch.name, style = MaterialTheme.typography.labelSmall, diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/EnrichmentStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/EnrichmentStore.kt index 5851fda9c..597688f1e 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/EnrichmentStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/EnrichmentStore.kt @@ -76,7 +76,7 @@ class EnrichmentStore(context: Context) { ) val before = _entries.value val next = _entries.updateAndGet { current -> - // Round-67 audit HIGH-4: short-circuit when the cached + // short-circuit when the cached // value is already the same view+duration — re-enriching // within TTL otherwise allocates a new Map every call // and the `before !== next` guard never triggers, so a @@ -110,7 +110,7 @@ class EnrichmentStore(context: Context) { private fun load(): Map = runCatching { val s = sp.getString(KEY, null) ?: return emptyMap() val loaded = json.decodeFromString>(s) - // Round-67 audit MED-6: prune TTL-expired entries on load + // prune TTL-expired entries on load // so the store doesn't accumulate dead weight up to // MAX_ENRICHMENTS over time. `Forever` TTL skips the prune. val ttl = Settings.get().cacheTtl.value diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/FeedCacheStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/FeedCacheStore.kt index af886ccf5..eab61b975 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/FeedCacheStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/FeedCacheStore.kt @@ -40,7 +40,7 @@ class FeedCacheStore(context: Context) { /** * Snapshot of the disk cache, filtered by the user-configured TTL. - * Returns empty map if nothing saved or everything expired. vc=59 — + * Returns empty map if nothing saved or everything expired. * Settings.cacheTtl.isForever short-circuits the filter; finite TTLs * drop entries whose fetchedAt is older than (now - ttl). */ @@ -73,7 +73,7 @@ object FeedCache { * (and the ~225 KB JSON decode that happens at construction) is * deferred until the first `get()` call. Lets Application.onCreate * return quickly while every caller still gets a valid Store — - * vc=36 audit HIGH-R3. Callers should access from a coroutine + * Callers should access from a coroutine * (IO dispatcher) where the lazy construction cost is acceptable. */ fun init(context: Context) { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt index 9e70c7101..1eb1bd2f8 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/HistoryStore.kt @@ -33,7 +33,7 @@ private const val KEY_WATCHES = "watches_v1" private const val KEY_SEARCHES = "searches_v1" /** - * Pre-vc=59 hard limits. Still used as the absolute upper bound when + * Earlier hard limits. Still used as the absolute upper bound when * Settings.historyWatchesCap is CacheCap.Unlimited — we don't want to * allow truly-uncapped growth that could OOM SP on a hostile import. * Any user-picked cap above this is silently floored to MAX_*_HARD. @@ -75,14 +75,14 @@ class HistoryStore(context: Context) { /** * Bulk import. Callers (currently SettingsImport) feed - * oldest→newest. Single SP write — vc=34 audit flagged the + * oldest→newest. Single SP write audit flagged the * per-row recordWatch in importHistory as a write-storm vector. * * Walks input newest-first (input is fed oldest-first), filters * blanks + already-seen videoIds, prepends to current, then takes * maxWatches(). Imports WIN over older current entries when the - * store is at the cap — the vc=37 first cut silently discarded - * the whole import in that case (round-3 audit HIGH-1). + * store is at the cap — the the first cut silently discarded + * the whole import in that case. * * Skips the SP write when the resulting list is identical (by * reference equality after updateAndGet's no-op return) so a @@ -91,7 +91,7 @@ class HistoryStore(context: Context) { /** * Returns the number of fresh items actually folded into the * store on this call (counts new videoIds; duplicates of - * already-recorded entries don't count). Round-4 audit HIGH-7 — + * already-recorded entries don't count). * SettingsImport previously reported `size_after - size_before` * which lies when the store was at maxWatches() (post-state can * be 50 = pre-state even when 20 imports landed and 20 older @@ -104,7 +104,7 @@ class HistoryStore(context: Context) { val next = _watches.updateAndGet { current -> // Reset the counter inside the CAS lambda so a retry // doesn't accumulate across attempts — same shape as - // SubscriptionsStore.addAll's vc=37 round-3 fix. + // SubscriptionsStore.addAll's round-3 fix. counter.set(0) val seen = HashSet(current.size + items.size) current.forEach { seen.add(it.videoId) } @@ -134,9 +134,8 @@ class HistoryStore(context: Context) { /** * Bulk import for search history. Same pattern as * recordAllWatches — single SP write regardless of input size. - * vc=37 round-3 audit CVE-MED-6: SettingsImport.importHistory was - * calling recordSearch per row, producing N SP writes on a - * potentially-100k-row import. + * SettingsImport.importHistory previously called recordSearch per + * row, producing N SP writes on a potentially-100k-row import. */ /** * Returns the number of fresh queries actually folded into the diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/PlaylistsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/PlaylistsStore.kt index e6cc3aa7a..26ba0e16d 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/PlaylistsStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/PlaylistsStore.kt @@ -69,7 +69,6 @@ class PlaylistsStore(context: Context) { * addItem() in a loop — both write SP, and addItem walks every * playlist linearly per insert. A 100-playlist × 100-items * NewPipe export was ~10,001 SP commits + ~10M comparisons. - * Round-4 audit HIGH-2. */ fun importPlaylist(name: String, items: List): Playlist { val stampNow = System.currentTimeMillis() diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/ResumePositionsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/ResumePositionsStore.kt index 9ef0c07bc..ffa02cd5f 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/ResumePositionsStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/ResumePositionsStore.kt @@ -38,7 +38,7 @@ private const val PREFS = "straw_resume_positions" private const val KEY_POSITIONS = "positions_v1" /** - * Pre-vc=59 hard cap. Now a ceiling rather than a fixed value: the + * Earlier hard cap. Now a ceiling rather than a fixed value: the * user-picked cap from Settings.resumePositionsCap is silently floored * to this so even "Unlimited" doesn't OOM SP. Bigger ceiling here * than HistoryStore because resume entries are tiny (~50 bytes each) @@ -97,7 +97,7 @@ class ResumePositionsStore(context: Context) { ) val before = _positions.value val next = _positions.updateAndGet { current -> - // Round-67 audit HIGH-6: short-circuit value-equality — + // short-circuit value-equality // a 5s poll tick that finds the same (position, duration, // wall-time) for an existing entry returns `current` // unchanged so the outer `next !== before` guard @@ -117,7 +117,7 @@ class ResumePositionsStore(context: Context) { val withEntry = current + (videoId to entry) // Skip sort+associate when we're under the cap (the // common case at default 500). Sort is O(n log n); - // associate allocates another map. Round-67 audit HIGH-6. + // associate allocates another map. if (withEntry.size > maxResumes()) { // Drop oldest by lastWatchedAt — newcomers always land // because the entry we just added is by definition the @@ -133,8 +133,7 @@ class ResumePositionsStore(context: Context) { if (next !== before) { // JSON encode + SP write off Main — encoding 100k entries // would be ~50-100 ms on a low-end device, and the 5s - // captureResumePosition poll runs on Main. Round-67 - // audit HIGH-6. + // captureResumePosition poll runs on Main. StrawApp.globalScope.launch(Dispatchers.IO) { sp.edit().putString(KEY_POSITIONS, json.encodeToString(next)).apply() } diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt index 56b0d3575..4b9473fe2 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/SearchCacheStore.kt @@ -12,7 +12,7 @@ * = ~150 KB worst case. * * Backed by a MutableStateFlow loaded once at construction — - * record()/load() are atomic against concurrent calls. vc=36 audit + * record/load are atomic against concurrent calls. audit * B5: the prior load()→edit()→write() pattern would clobber a * concurrent record() with whichever happened to persist last. * diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt index bda38ba0a..7ded93aba 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/SettingsStore.kt @@ -72,7 +72,7 @@ enum class AutoUpdateInterval(val label: String) { /** * User-facing cache caps. Each store's hard limit is the cap's value; * `Int.MAX_VALUE` means "unlimited" (the store grows without trimming). - * Defaults match the pre-vc=59 hardcoded constants so existing data + * Defaults match the earlier hardcoded constants so existing data * keeps the same shape until the user picks something different. */ enum class CacheCap(val label: String, val value: Int) { @@ -221,7 +221,7 @@ class SettingsStore(context: Context) { /** * Cached "latest version seen on fdroid" — 0 / "" while none known - * or while caught-up. Lets SettingsScreen show "vc=55 available" + * or while caught-up. Lets SettingsScreen show "an update available" * without re-polling. */ private val _latestKnownVc = MutableStateFlow( @@ -244,7 +244,7 @@ class SettingsStore(context: Context) { * "#shorts" / "#Shorts" / "(shorts)" which most short uploaders * include. * Filter is best-effort — a hand-tagged short with a clean title - * in the subs feed will slip through until vc=57 plumbs an + * in the subs feed will slip through until a future build plumbs an * isShort flag through strawcore-core. */ private val _hideShorts = MutableStateFlow( @@ -258,7 +258,7 @@ class SettingsStore(context: Context) { * takes effect immediately (next write trims to the new cap; reads * are unbounded since they're already in memory). * - * Defaults match the pre-vc=59 hardcoded constants so first-launch + * Defaults match the earlier hardcoded constants so first-launch * behavior is unchanged from prior versions. */ private val _historyWatchesCap = MutableStateFlow( @@ -308,10 +308,9 @@ class SettingsStore(context: Context) { } // Atomic + idempotent. Capture before-state, update in-memory, - // skip the SP write when the value didn't actually change. Round-5 - // audit LOW-1 / MED-2: the prior shape used - // `updateAndGet { r } == r` which is unconditionally true (lambda - // ignores prior) — dead code that confused readers. + // skip the SP write when the value didn't actually change. The + // prior shape used `updateAndGet { r } == r` which is unconditionally + // true (the lambda ignores prior) — dead code that confused readers. fun setMaxResolution(r: MaxResolution) { val before = _maxResolution.value if (before == r) return diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt b/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt index 97a3bf994..f25a6bbc0 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/data/SubscriptionsStore.kt @@ -66,7 +66,7 @@ class SubscriptionsStore(context: Context) { /** * Bulk-add. Single persist instead of N. Per-call `toggle()` was - * O(N²) + N SP writes, which the vc=34 security audit flagged as + * O(N²) + N SP writes, which the security audit flagged as * a DoS vector for hostile NewPipe-export imports. Single linear * scan to dedup, one persist regardless of input size. Returns the * count of NEW (not previously-subscribed) channels added so the @@ -76,8 +76,8 @@ class SubscriptionsStore(context: Context) { // Count NEW refs by checking each input URL against the // current state's pre-image inside the CAS lambda. Captures // exactly the additions this call made — concurrent - // toggle()s that race the CAS don't inflate the count (vc=37 - // round-3 audit HIGH-2/CVE-2). The counter lives in an + // toggles that race the CAS don't inflate the count ( + // ). The counter lives in an // AtomicInteger so each lambda re-run resets it correctly. val counter = java.util.concurrent.atomic.AtomicInteger(0) val next = _subs.updateAndGet { state -> diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt index 1b1ab29ce..c2ea93b5d 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelScreen.kt @@ -80,7 +80,7 @@ fun ChannelScreen( // the screen recomposes once with A's state before vm.load(B) // resets it. Without this branch we'd render channel A's banner / // name / videos under URL B. Same shape as VideoDetailScreen's - // gate. Round-69 audit HIGH-1. + // gate. state.loadedUrl != channelUrl -> Box( modifier = Modifier.fillMaxSize().statusBarsPadding(), contentAlignment = Alignment.Center, @@ -218,8 +218,8 @@ private fun ChannelVideoRow( // Don't repeat duration here — VideoThumbnail's // bottom-right badge already shows it. Add the upload // date so the row reads 'N views · 2 days ago' the way - // YT renders it. vc=65 — Cobb caught the duplicate - // duration + missing date on the channel page. + // YT renders it. The earlier row was duplicating duration + // and missing the upload date on the channel page. val meta = buildString { if (item.viewCount > 0) append("${formatCount(item.viewCount)} views") if (item.uploadDateRelative.isNotBlank()) { diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt index fa2dbd404..5415f2c95 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/channel/ChannelViewModel.kt @@ -36,7 +36,7 @@ data class ChannelUiState( * frame before vm.load(B) clears it. Without this field, any * caller that derives "this is the channel we want" from * `state.name` (or other display fields) is reading channel A's - * data while believing it's B. Round-68 audit MED-4. + * data while believing it's B. */ val loadedUrl: String? = null, ) @@ -47,20 +47,20 @@ class ChannelViewModel : ViewModel() { // Track the active load coroutine — same shape as // VideoDetailViewModel. Rapid channel switches no longer race; - // the late-arriving older fetch is cancelled. Round-4 audit - // HIGH-2 / MED-1. + // the late-arriving older fetch is cancelled. + // / MED-1. private var inFlight: Job? = null fun load(channelUrl: String) { - // Snapshot _ui once so the two reads agree. Round-68 audit MED-4. + // Snapshot _ui once so the two reads agree. val snap = _ui.value if (snap.loadedUrl == channelUrl && snap.videos.isNotEmpty()) return - // Round-5 audit MED-3: extractor-emitted uploaderUrl can be + // extractor-emitted uploaderUrl can be // attacker-controlled if the YT response is poisoned upstream. // Refuse non-YT hosts at the entry point so we don't even - // issue a network call to evil.com via strawcore. Round-6 - // audit HIGH-1: also cancel inFlight on rejection so a - // still-resolving prior load can't clobber the error banner. + // issue a network call to evil.com via strawcore. Also cancel + // inFlight on rejection so a still-resolving prior load can't + // clobber the error banner. if (!isAllowedYtUrl(channelUrl)) { inFlight?.cancel() inFlight = null @@ -110,8 +110,7 @@ class ChannelViewModel : ViewModel() { loading = false, // Scrub before storing — UniFFI/Rust exceptions // can embed full signed googlevideo URLs in the - // message (NetworkError::Recaptcha { url }). vc=37 - // round-3 audit CVE-1. + // message (NetworkError::Recaptcha { url }). error = com.sulkta.straw.util.LogDump.scrubLine( t.message ?: t.javaClass.simpleName, ), diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/dataimport/SettingsImport.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/dataimport/SettingsImport.kt index ed0c0e044..a4d7e4fc4 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/dataimport/SettingsImport.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/dataimport/SettingsImport.kt @@ -103,8 +103,7 @@ object SettingsImport { private const val YT_SERVICE_ID = 0 // The allowlist itself lives in util.YtUrl now — VideoDetailViewModel - // also gates auto-channelInfo + recordWatch through it. Round-4 - // audit HIGH-4 / HIGH-5. + // also gates auto-channelInfo + recordWatch through it. private fun isAllowedYtUrl(url: String): Boolean = com.sulkta.straw.util.isAllowedYtUrl(url) @@ -113,7 +112,7 @@ object SettingsImport { // runInner is suspend (it switches to NonCancellable for // cleanup). Plain runCatching would swallow a user-back // CancellationException and surface it as a normal - // failure with a misleading banner. Round-6 audit HIGH-2. + // failure with a misleading banner. com.sulkta.straw.util.runCatchingCancellable { runInner(context, zipUri) } @@ -121,7 +120,7 @@ object SettingsImport { /** * Sweep stale import work-dirs left behind by a previous run that - * was killed mid-extraction. CRIT from the vc=34 security audit: + * was killed mid-extraction. CRIT from the security audit: * a force-killed import leaves the user's full newpipe.db sitting * in cacheDir indefinitely. StrawApp.onCreate calls this on every * cold start. @@ -203,7 +202,7 @@ object SettingsImport { // Reject duplicate entries — a malicious zip // can put a benign db first and a hostile // second; ZipInputStream walks in order and - // would overwrite. Round-6 audit MED-5. + // would overwrite. if (dbFile != null) { warnings += "duplicate newpipe.db in archive — aborting" return null to null @@ -322,8 +321,7 @@ object SettingsImport { openDb(dbFile).use { db -> val playlistRows = mutableListOf>() // Hard caps so a malicious export with millions of rows - // doesn't walk an unbounded cursor into memory. Round-6 - // audit MED-3. + // doesn't walk an unbounded cursor into memory. db.rawQuery("SELECT uid, name FROM playlists LIMIT 256", null).use { c -> while (c.moveToNext()) { val uid = c.getLong(0) @@ -362,7 +360,7 @@ object SettingsImport { // instead of (1 create + N addItem) writes. Old shape // produced ~10k SP commits on a 100×100 export, plus // O(N²) work in addItem's per-call linear scan over - // every playlist. Round-4 audit HIGH-2. + // every playlist. store.importPlaylist(name, items) playlistsAdded++ itemsAdded += items.size @@ -390,7 +388,7 @@ object SettingsImport { openDb(dbFile).use { db -> // Search history — feed oldest first so the store ends up with // the most-recent on top after its own dedup + take(MAX). - // Stage + bulk-write — vc=37 round-3 audit CVE MED-6: + // Stage + bulk-write —: // per-row recordSearch was N SP writes on potentially // 100k+ rows. The SELECT also lacked a LIMIT; added now. val stagedSearches = mutableListOf() @@ -458,7 +456,7 @@ object SettingsImport { // recordAllWatches / recordAllSearches return the real // added count (counts fresh videoIds / queries that landed, // ignoring duplicates and pre-saturated-store truncation). - // Round-4 audit HIGH-7 / MED-2 — previous size_after - + // / MED-2 — previous size_after // size_before reported 0 when the store was already at cap // even when 20 fresh imports actually landed. return HistResult( @@ -496,7 +494,6 @@ object SettingsImport { // changed something. Prior shape counted every // observed key, inflating the import summary to // "12 settings applied" when only 2 changed. - // Round-6 audit MED-2. if (want != have) { settings.toggle(cat) applied++ diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt index 87f9e2b3e..6c726aff2 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailScreen.kt @@ -264,8 +264,8 @@ fun VideoDetailScreen( // vm.load(B)'s reset propagates. Without this gate, the // InlinePlayer's LaunchedEffect would fire with // streamUrl=B but resolved=A's URLs and play A under - // B's chrome (Cobb-reported 2026-05-26: detail page - // shows new video, audio is the old one). + // B's chrome — symptom is the detail page showing the + // new video while the audio is still the old one. if (state.loadedUrl != streamUrl) return@Column // Player surface — edge-to-edge, NewPipe/YouTube style. // Lives outside the 16dp horizontal padding so the @@ -485,7 +485,7 @@ fun VideoDetailScreen( } // PiP into nothing isn't useful — bail with a // Toast if there's no controller / no resolved - // playback to push into it. vc=34 audit Q-13. + // playback to push into it. val c = controller val r = state.resolved if (c == null || r == null) { @@ -715,7 +715,7 @@ private fun RelatedRow( // the uploader name on each row — it's implicit. Skip // empty pieces with the leading-separator dance so we // never end up with " · viewCount" or trailing dots. - // vc=64 — Cobb caught the empty metadata line on + // Earlier shape was leaving an empty metadata line on // More-from-channel rows. val meta = buildString { if (item.uploader.isNotBlank()) append(item.uploader) @@ -770,7 +770,7 @@ private fun InlinePlayer( // retryVersion lets the user manually re-fire setPlayingFrom after // a playback error. Without it, the screen used to lock into the // thumbnail+spinner branch once NowPlaying.clear() fired from - // onPlayerError. vc=62 audit BUG-2. + // onPlayerError. val resolved = state.resolved var retryVersion by remember(streamUrl) { mutableIntStateOf(0) } LaunchedEffect(controller, resolved, streamUrl, retryVersion) { @@ -794,12 +794,11 @@ private fun InlinePlayer( val listener = object : Player.Listener { override fun onPlayerError(error: androidx.media3.common.PlaybackException) { // Scrub the message — Media3's HttpDataSource exceptions - // include the full signed URL in .message. vc=36 audit - // CVE HIGH-1. + // include the full signed URL in.message. val raw = error.message ?: "(no message)" playbackError = "${error.errorCodeName}: ${LogDump.scrubLine(raw)}" // Clear NowPlaying so the minibar drops the dead - // session. vc=36 audit MED-3. + // session. NowPlaying.clear() } } @@ -834,7 +833,7 @@ private fun InlinePlayer( Spacer(modifier = Modifier.height(12.dp)) OutlinedButton(onClick = { // Clear the error AND nudge the LaunchedEffect to - // re-attempt setPlayingFrom. vc=62 audit BUG-2 — + // re-attempt setPlayingFrom. // without this the screen used to lock on the // error forever after NowPlaying.clear(). playbackError = null diff --git a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt index df48c4fb4..d6038f9b9 100644 --- a/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt +++ b/strawApp/src/main/kotlin/com/sulkta/straw/feature/detail/VideoDetailViewModel.kt @@ -100,7 +100,7 @@ data class VideoDetailUiState( * vm.load(B) clears it. Without this field, the InlinePlayer's * setPlayingFrom would fire with streamUrl=B but resolved=A's * playback URLs — claiming NowPlaying with B's streamUrl but - * playing A's video under it. vc=63 audit. + * playing A's video under it. audit. */ val loadedUrl: String? = null, ) @@ -112,7 +112,7 @@ class VideoDetailViewModel : ViewModel() { // Track the active load coroutine so a rapid tap to a different video // cancels the prior fetch; otherwise a slow-to-finish older load // overwrites the newer state and the player ends up streaming A while - // the detail UI shows B. Round-4 audit HIGH-2. + // the detail UI shows B. private var inFlight: Job? = null fun load(streamUrl: String) { @@ -123,11 +123,11 @@ class VideoDetailViewModel : ViewModel() { if (snap.loadedUrl == streamUrl && snap.detail != null) return // Same YT-host gate as ChannelViewModel — covers the case // where a tap on a poisoned related-card lands here. - // Round-5 audit MED-3. Round-6 audit HIGH-1: cancel any + // cancel any // in-flight load on rejection too — otherwise the // late-arriving prior-job's fence still PASSES (loadedUrl // wasn't moved) and clobbers the "Unsupported URL" error - // banner. round-67 audit HIGH-7: also set loadedUrl on this + // banner.: also set loadedUrl on this // path so the gate reads coherently for any caller that // checks _ui.value.loadedUrl on the rejected path. if (!isAllowedYtUrl(streamUrl)) { @@ -155,12 +155,11 @@ class VideoDetailViewModel : ViewModel() { // Move SP write off the main coroutine — recordWatch // JSON-encodes the watch list (up to 50 entries) + - // sp.edit().apply(). Small but synchronous; vc=36 + // sp.edit.apply. Small but synchronous; // audit Q9. Only record when the resolved URL passes // the YT allowlist — otherwise extractor-emitted // non-YT URLs (poisoned related/moreFromChannel) end // up in Recent Watches and survive process death. - // Round-4 audit HIGH-5. if (isAllowedYtUrl(streamUrl)) { withContext(Dispatchers.IO) { runCatchingCancellable { @@ -216,9 +215,9 @@ class VideoDetailViewModel : ViewModel() { // Gate the auto-fetch behind the same YT-host allowlist // we apply to imports: a poisoned uploaderUrl from the // extractor would otherwise trigger an arbitrary-host - // network call. Round-4 audit HIGH-4. + // network call. // - // Round-69 audit MED-3: validate once and persist the + // validate once and persist the // SAFE value into VideoDetail.uploaderUrl so downstream // consumers (NowPlaying → PlaybackService autoplay, // queue, etc.) inherit the validated string instead @@ -246,7 +245,7 @@ class VideoDetailViewModel : ViewModel() { // extractor surfaces the URL string verbatim // and a poisoned channel page could ship // `data:image/svg+xml,...